From 7f92556ad7951c1fc5117f738ea61489a6003911 Mon Sep 17 00:00:00 2001 From: Andrew Kryczka Date: Fri, 2 Mar 2018 12:42:03 -0800 Subject: [PATCH] Comment out unused variables --- cache/cache_test.cc | 6 +- cache/clock_cache.cc | 2 +- cache/sharded_cache.cc | 2 +- db/builder.cc | 8 +- db/c.cc | 16 +- db/column_family_test.cc | 9 +- db/compact_files_test.cc | 9 +- db/compacted_db_impl.h | 45 +++--- db/compaction_iterator.cc | 5 +- db/compaction_iterator.h | 2 +- db/compaction_iterator_test.cc | 33 ++-- db/compaction_job_stats_test.cc | 2 +- db/compaction_picker.cc | 9 +- db/compaction_picker.h | 26 +-- db/compaction_picker_test.cc | 4 +- db/compaction_picker_universal.cc | 2 +- db/comparator_db_test.cc | 18 +-- db/db_basic_test.cc | 7 +- db/db_block_cache_test.cc | 2 +- db/db_compaction_filter_test.cc | 48 +++--- db/db_compaction_test.cc | 2 +- db/db_impl.cc | 27 ++-- db/db_impl_compaction_flush.cc | 2 +- db/db_impl_readonly.cc | 2 +- db/db_impl_readonly.h | 59 +++---- db/db_impl_write.cc | 2 +- db/db_iterator_test.cc | 6 +- db/db_memtable_test.cc | 2 +- db/db_properties_test.cc | 12 +- db/db_test.cc | 152 ++++++++++-------- db/db_test2.cc | 17 +- db/db_test_util.cc | 11 +- db/db_test_util.h | 2 +- db/db_universal_compaction_test.cc | 14 +- db/deletefile_test.cc | 2 +- db/external_sst_file_test.cc | 9 +- db/file_indexer_test.cc | 6 +- db/forward_iterator.cc | 2 +- db/forward_iterator.h | 2 +- db/internal_stats.cc | 113 +++++++------ db/listener_test.cc | 17 +- db/manual_compaction_test.cc | 6 +- db/memtable.cc | 2 +- db/memtable_list.cc | 4 +- db/merge_test.cc | 2 +- db/plain_table_db_test.cc | 2 +- db/prefix_test.cc | 6 +- db/snapshot_checker.h | 4 +- db/table_cache.cc | 4 +- db/table_properties_collector.cc | 4 +- db/table_properties_collector.h | 2 +- db/table_properties_collector_test.cc | 19 +-- db/transaction_log_impl.cc | 10 +- db/version_builder.cc | 2 +- db/version_edit.cc | 2 +- db/version_set.cc | 2 +- db/version_set.h | 2 +- db/version_set_test.cc | 4 +- db/wal_manager_test.cc | 2 +- db/write_batch.cc | 6 +- db/write_batch_test.cc | 32 ++-- db/write_callback_test.cc | 6 +- db/write_thread.cc | 3 +- env/env_encryption.cc | 14 +- env/env_hdfs.cc | 10 +- env/env_test.cc | 28 ++-- env/io_posix.cc | 4 +- env/io_posix.h | 2 +- env/mock_env.cc | 14 +- hdfs/env_hdfs.h | 109 +++++++------ include/rocksdb/cache.h | 3 +- include/rocksdb/compaction_filter.h | 12 +- include/rocksdb/db.h | 11 +- include/rocksdb/env.h | 55 +++---- include/rocksdb/filter_policy.h | 5 +- include/rocksdb/listener.h | 4 +- include/rocksdb/memtablerep.h | 6 +- include/rocksdb/merge_operator.h | 17 +- include/rocksdb/rate_limiter.h | 2 +- include/rocksdb/slice.h | 2 +- include/rocksdb/slice_transform.h | 4 +- include/rocksdb/statistics.h | 2 +- include/rocksdb/table.h | 4 +- include/rocksdb/utilities/geo_db.h | 2 +- .../utilities/optimistic_transaction_db.h | 2 +- include/rocksdb/utilities/transaction.h | 10 +- include/rocksdb/wal_filter.h | 18 +-- include/rocksdb/write_batch.h | 13 +- memtable/hash_cuckoo_rep.cc | 6 +- memtable/hash_linklist_rep.cc | 14 +- memtable/hash_skiplist_rep.cc | 14 +- memtable/skiplistrep.cc | 2 +- memtable/vectorrep.cc | 6 +- options/options_parser.cc | 2 +- port/port_posix.cc | 2 +- port/stack_trace.cc | 2 +- table/adaptive_table_factory.cc | 2 +- table/adaptive_table_factory.h | 5 +- table/block_based_filter_block.cc | 10 +- table/block_based_table_builder.cc | 6 +- table/block_based_table_factory.cc | 3 +- table/block_based_table_reader.cc | 20 +-- table/block_test.cc | 2 +- table/cuckoo_table_builder_test.cc | 2 +- table/cuckoo_table_factory.cc | 2 +- table/cuckoo_table_factory.h | 9 +- table/cuckoo_table_reader.cc | 9 +- table/cuckoo_table_reader.h | 2 +- table/cuckoo_table_reader_test.cc | 2 +- table/filter_block.h | 2 +- table/full_filter_block.cc | 14 +- table/full_filter_block.h | 2 +- table/get_context.cc | 2 +- table/index_builder.h | 4 +- table/internal_iterator.h | 5 +- table/iterator.cc | 8 +- table/mock_table.cc | 16 +- table/mock_table.h | 6 +- table/partitioned_filter_block.cc | 2 +- table/plain_table_factory.cc | 4 +- table/plain_table_factory.h | 9 +- table/plain_table_key_coding.cc | 2 +- table/plain_table_reader.cc | 10 +- table/sst_file_writer_collectors.h | 6 +- table/table_reader.h | 6 +- table/table_test.cc | 53 +++--- table/two_level_iterator.cc | 3 +- third-party/fbson/FbsonDocument.h | 2 +- tools/db_bench_tool.cc | 16 +- tools/ldb_cmd.cc | 40 ++--- tools/ldb_tool.cc | 2 +- tools/sst_dump_tool.cc | 6 +- util/compression.h | 22 +-- util/file_reader_writer_test.cc | 36 +++-- util/slice.cc | 8 +- util/testutil.cc | 6 +- util/testutil.h | 74 +++++---- util/thread_local_test.cc | 2 +- utilities/backupable/backupable_db_test.cc | 11 +- utilities/blob_db/blob_db_impl.cc | 14 +- utilities/blob_db/blob_db_impl.h | 6 +- .../cassandra/cassandra_compaction_filter.cc | 10 +- .../cassandra/cassandra_functional_test.cc | 2 +- utilities/cassandra/merge_operator.cc | 6 +- utilities/checkpoint/checkpoint_impl.cc | 4 +- utilities/col_buf_decoder.h | 2 +- .../remove_emptyvalue_compactionfilter.cc | 11 +- utilities/document/document_db.cc | 21 +-- utilities/merge_operators/max.cc | 8 +- utilities/merge_operators/put.cc | 27 ++-- .../string_append/stringappend.cc | 8 +- .../string_append/stringappend2.cc | 8 +- utilities/merge_operators/uint64add.cc | 6 +- utilities/object_registry_test.cc | 13 +- utilities/options/options_util_test.cc | 37 ++--- .../persistent_cache/block_cache_tier_file.cc | 2 +- .../persistent_cache/block_cache_tier_file.h | 6 +- utilities/persistent_cache/hash_table_test.cc | 4 +- .../persistent_cache/persistent_cache_test.h | 4 +- .../persistent_cache/persistent_cache_tier.cc | 4 +- .../persistent_cache/volatile_tier_impl.cc | 2 +- utilities/redis/redis_list_iterator.h | 2 +- utilities/simulator_cache/sim_cache_test.cc | 2 +- utilities/spatialdb/spatial_db.cc | 2 +- .../compact_on_deletion_collector.cc | 11 +- .../compact_on_deletion_collector.h | 2 +- .../compact_on_deletion_collector_test.cc | 2 +- utilities/transactions/transaction_base.h | 2 +- utilities/transactions/write_prepared_txn.cc | 5 +- .../transactions/write_prepared_txn_db.cc | 4 +- utilities/ttl/ttl_test.cc | 6 +- .../write_batch_with_index_test.cc | 2 +- 172 files changed, 1009 insertions(+), 932 deletions(-) diff --git a/cache/cache_test.cc b/cache/cache_test.cc index 8e241226d..55f9cc6bb 100644 --- a/cache/cache_test.cc +++ b/cache/cache_test.cc @@ -40,9 +40,9 @@ static int DecodeValue(void* v) { const std::string kLRU = "lru"; const std::string kClock = "clock"; -void dumbDeleter(const Slice& key, void* value) {} +void dumbDeleter(const Slice& /*key*/, void* /*value*/) {} -void eraseDeleter(const Slice& key, void* value) { +void eraseDeleter(const Slice& /*key*/, void* value) { Cache* cache = reinterpret_cast(value); cache->Erase("foo"); } @@ -470,7 +470,7 @@ class Value { }; namespace { -void deleter(const Slice& key, void* value) { +void deleter(const Slice& /*key*/, void* value) { delete static_cast(value); } } // namespace diff --git a/cache/clock_cache.cc b/cache/clock_cache.cc index 7e42714ef..8c26f7a9c 100644 --- a/cache/clock_cache.cc +++ b/cache/clock_cache.cc @@ -586,7 +586,7 @@ Status ClockCacheShard::Insert(const Slice& key, uint32_t hash, void* value, size_t charge, void (*deleter)(const Slice& key, void* value), Cache::Handle** out_handle, - Cache::Priority priority) { + Cache::Priority /*priority*/) { CleanupContext context; HashTable::accessor accessor; char* key_data = new char[key.size()]; diff --git a/cache/sharded_cache.cc b/cache/sharded_cache.cc index 9bdea3a08..6a0a22282 100644 --- a/cache/sharded_cache.cc +++ b/cache/sharded_cache.cc @@ -53,7 +53,7 @@ Status ShardedCache::Insert(const Slice& key, void* value, size_t charge, ->Insert(key, hash, value, charge, deleter, handle, priority); } -Cache::Handle* ShardedCache::Lookup(const Slice& key, Statistics* stats) { +Cache::Handle* ShardedCache::Lookup(const Slice& key, Statistics* /*stats*/) { uint32_t hash = HashSlice(key); return GetShard(Shard(hash))->Lookup(key, hash); } diff --git a/db/builder.cc b/db/builder.cc index afb8e4403..4042d9685 100644 --- a/db/builder.cc +++ b/db/builder.cc @@ -61,10 +61,10 @@ TableBuilder* NewTableBuilder( Status BuildTable( const std::string& dbname, Env* env, const ImmutableCFOptions& ioptions, - const MutableCFOptions& mutable_cf_options, const EnvOptions& env_options, - TableCache* table_cache, InternalIterator* iter, - std::unique_ptr range_del_iter, FileMetaData* meta, - const InternalKeyComparator& internal_comparator, + const MutableCFOptions& /*mutable_cf_options*/, + const EnvOptions& env_options, TableCache* table_cache, + InternalIterator* iter, std::unique_ptr range_del_iter, + FileMetaData* meta, const InternalKeyComparator& internal_comparator, const std::vector>* int_tbl_prop_collector_factories, uint32_t column_family_id, const std::string& column_family_name, diff --git a/db/c.cc b/db/c.cc index 064103ed4..0dfdbda96 100644 --- a/db/c.cc +++ b/db/c.cc @@ -252,7 +252,7 @@ struct rocksdb_comparator_t : public Comparator { // No-ops since the C binding does not support key shortening methods. virtual void FindShortestSeparator(std::string*, const Slice&) const override {} - virtual void FindShortSuccessor(std::string* key) const override {} + virtual void FindShortSuccessor(std::string* /*key*/) const override {} }; struct rocksdb_filterpolicy_t : public FilterPolicy { @@ -367,7 +367,7 @@ struct rocksdb_mergeoperator_t : public MergeOperator { virtual bool PartialMergeMulti(const Slice& key, const std::deque& operand_list, std::string* new_value, - Logger* logger) const override { + Logger* /*logger*/) const override { size_t operand_count = operand_list.size(); std::vector operand_pointers(operand_count); std::vector operand_sizes(operand_count); @@ -2166,8 +2166,8 @@ void rocksdb_options_set_level0_stop_writes_trigger( opt->rep.level0_stop_writes_trigger = n; } -void rocksdb_options_set_max_mem_compaction_level(rocksdb_options_t* opt, - int n) {} +void rocksdb_options_set_max_mem_compaction_level(rocksdb_options_t* /*opt*/, + int /*n*/) {} void rocksdb_options_set_wal_recovery_mode(rocksdb_options_t* opt,int mode) { opt->rep.wal_recovery_mode = static_cast(mode); @@ -2231,8 +2231,8 @@ void rocksdb_options_set_manifest_preallocation_size( } // noop -void rocksdb_options_set_purge_redundant_kvs_while_flush(rocksdb_options_t* opt, - unsigned char v) {} +void rocksdb_options_set_purge_redundant_kvs_while_flush( + rocksdb_options_t* /*opt*/, unsigned char /*v*/) {} void rocksdb_options_set_use_direct_reads(rocksdb_options_t* opt, unsigned char v) { @@ -2402,7 +2402,7 @@ void rocksdb_options_set_table_cache_numshardbits( } void rocksdb_options_set_table_cache_remove_scan_count_limit( - rocksdb_options_t* opt, int v) { + rocksdb_options_t* /*opt*/, int /*v*/) { // this option is deprecated } @@ -2973,7 +2973,7 @@ rocksdb_sstfilewriter_t* rocksdb_sstfilewriter_create( rocksdb_sstfilewriter_t* rocksdb_sstfilewriter_create_with_comparator( const rocksdb_envoptions_t* env, const rocksdb_options_t* io_options, - const rocksdb_comparator_t* comparator) { + const rocksdb_comparator_t* /*comparator*/) { rocksdb_sstfilewriter_t* writer = new rocksdb_sstfilewriter_t; writer->rep = new SstFileWriter(env->rep, io_options->rep); return writer; diff --git a/db/column_family_test.cc b/db/column_family_test.cc index 94c087aac..cf7c13d65 100644 --- a/db/column_family_test.cc +++ b/db/column_family_test.cc @@ -1168,13 +1168,14 @@ TEST_F(ColumnFamilyTest, MemtableNotSupportSnapshot) { #endif // !ROCKSDB_LITE class TestComparator : public Comparator { - int Compare(const rocksdb::Slice& a, const rocksdb::Slice& b) const override { + int Compare(const rocksdb::Slice& /*a*/, + const rocksdb::Slice& /*b*/) const override { return 0; } const char* Name() const override { return "Test"; } - void FindShortestSeparator(std::string* start, - const rocksdb::Slice& limit) const override {} - void FindShortSuccessor(std::string* key) const override {} + void FindShortestSeparator(std::string* /*start*/, + const rocksdb::Slice& /*limit*/) const override {} + void FindShortSuccessor(std::string* /*key*/) const override {} }; static TestComparator third_comparator; diff --git a/db/compact_files_test.cc b/db/compact_files_test.cc index 5aad6114f..7f1504539 100644 --- a/db/compact_files_test.cc +++ b/db/compact_files_test.cc @@ -37,8 +37,7 @@ class FlushedFileCollector : public EventListener { FlushedFileCollector() {} ~FlushedFileCollector() {} - virtual void OnFlushCompleted( - DB* db, const FlushJobInfo& info) override { + virtual void OnFlushCompleted(DB* /*db*/, const FlushJobInfo& info) override { std::lock_guard lock(mutex_); flushed_files_.push_back(info.file_path); } @@ -257,9 +256,9 @@ TEST_F(CompactFilesTest, CapturingPendingFiles) { TEST_F(CompactFilesTest, CompactionFilterWithGetSv) { class FilterWithGet : public CompactionFilter { public: - virtual bool Filter(int level, const Slice& key, const Slice& value, - std::string* new_value, - bool* value_changed) const override { + virtual bool Filter(int /*level*/, const Slice& /*key*/, + const Slice& /*value*/, std::string* /*new_value*/, + bool* /*value_changed*/) const override { if (db_ == nullptr) { return true; } diff --git a/db/compacted_db_impl.h b/db/compacted_db_impl.h index de32f21e6..736002e1e 100644 --- a/db/compacted_db_impl.h +++ b/db/compacted_db_impl.h @@ -32,55 +32,56 @@ class CompactedDBImpl : public DBImpl { override; using DBImpl::Put; - virtual Status Put(const WriteOptions& options, - ColumnFamilyHandle* column_family, const Slice& key, - const Slice& value) override { + virtual Status Put(const WriteOptions& /*options*/, + ColumnFamilyHandle* /*column_family*/, + const Slice& /*key*/, const Slice& /*value*/) override { return Status::NotSupported("Not supported in compacted db mode."); } using DBImpl::Merge; - virtual Status Merge(const WriteOptions& options, - ColumnFamilyHandle* column_family, const Slice& key, - const Slice& value) override { + virtual Status Merge(const WriteOptions& /*options*/, + ColumnFamilyHandle* /*column_family*/, + const Slice& /*key*/, const Slice& /*value*/) override { return Status::NotSupported("Not supported in compacted db mode."); } using DBImpl::Delete; - virtual Status Delete(const WriteOptions& options, - ColumnFamilyHandle* column_family, - const Slice& key) override { + virtual Status Delete(const WriteOptions& /*options*/, + ColumnFamilyHandle* /*column_family*/, + const Slice& /*key*/) override { return Status::NotSupported("Not supported in compacted db mode."); } - virtual Status Write(const WriteOptions& options, - WriteBatch* updates) override { + virtual Status Write(const WriteOptions& /*options*/, + WriteBatch* /*updates*/) override { return Status::NotSupported("Not supported in compacted db mode."); } using DBImpl::CompactRange; - virtual Status CompactRange(const CompactRangeOptions& options, - ColumnFamilyHandle* column_family, - const Slice* begin, const Slice* end) override { + virtual Status CompactRange(const CompactRangeOptions& /*options*/, + ColumnFamilyHandle* /*column_family*/, + const Slice* /*begin*/, + const Slice* /*end*/) override { return Status::NotSupported("Not supported in compacted db mode."); } virtual Status DisableFileDeletions() override { return Status::NotSupported("Not supported in compacted db mode."); } - virtual Status EnableFileDeletions(bool force) override { + virtual Status EnableFileDeletions(bool /*force*/) override { return Status::NotSupported("Not supported in compacted db mode."); } virtual Status GetLiveFiles(std::vector&, - uint64_t* manifest_file_size, - bool flush_memtable = true) override { + uint64_t* /*manifest_file_size*/, + bool /*flush_memtable*/ = true) override { return Status::NotSupported("Not supported in compacted db mode."); } using DBImpl::Flush; - virtual Status Flush(const FlushOptions& options, - ColumnFamilyHandle* column_family) override { + virtual Status Flush(const FlushOptions& /*options*/, + ColumnFamilyHandle* /*column_family*/) override { return Status::NotSupported("Not supported in compacted db mode."); } using DB::IngestExternalFile; virtual Status IngestExternalFile( - ColumnFamilyHandle* column_family, - const std::vector& external_files, - const IngestExternalFileOptions& ingestion_options) override { + ColumnFamilyHandle* /*column_family*/, + const std::vector& /*external_files*/, + const IngestExternalFileOptions& /*ingestion_options*/) override { return Status::NotSupported("Not supported in compacted db mode."); } diff --git a/db/compaction_iterator.cc b/db/compaction_iterator.cc index 79348fb6e..45d786f0d 100644 --- a/db/compaction_iterator.cc +++ b/db/compaction_iterator.cc @@ -31,15 +31,14 @@ CompactionIterator::CompactionIterator( CompactionIterator::CompactionIterator( InternalIterator* input, const Comparator* cmp, MergeHelper* merge_helper, - SequenceNumber last_sequence, std::vector* snapshots, + SequenceNumber /*last_sequence*/, std::vector* snapshots, SequenceNumber earliest_write_conflict_snapshot, const SnapshotChecker* snapshot_checker, Env* env, bool expect_valid_internal_key, RangeDelAggregator* range_del_agg, std::unique_ptr compaction, const CompactionFilter* compaction_filter, const std::atomic* shutting_down, - const SequenceNumber preserve_deletes_seqnum - ) + const SequenceNumber preserve_deletes_seqnum) : input_(input), cmp_(cmp), merge_helper_(merge_helper), diff --git a/db/compaction_iterator.h b/db/compaction_iterator.h index cc5cf0cfd..7732e08ae 100644 --- a/db/compaction_iterator.h +++ b/db/compaction_iterator.h @@ -30,7 +30,7 @@ class CompactionIterator { : compaction_(compaction) {} virtual ~CompactionProxy() = default; - virtual int level(size_t compaction_input_level = 0) const { + virtual int level(size_t /*compaction_input_level*/ = 0) const { return compaction_->level(); } virtual bool KeyNotExistsBeyondOutputLevel( diff --git a/db/compaction_iterator_test.cc b/db/compaction_iterator_test.cc index 6e653a9c0..1402c358e 100644 --- a/db/compaction_iterator_test.cc +++ b/db/compaction_iterator_test.cc @@ -19,15 +19,15 @@ namespace rocksdb { // Expects no merging attempts. class NoMergingMergeOp : public MergeOperator { public: - bool FullMergeV2(const MergeOperationInput& merge_in, - MergeOperationOutput* merge_out) const override { + bool FullMergeV2(const MergeOperationInput& /*merge_in*/, + MergeOperationOutput* /*merge_out*/) const override { ADD_FAILURE(); return false; } - bool PartialMergeMulti(const Slice& key, - const std::deque& operand_list, - std::string* new_value, - Logger* logger) const override { + bool PartialMergeMulti(const Slice& /*key*/, + const std::deque& /*operand_list*/, + std::string* /*new_value*/, + Logger* /*logger*/) const override { ADD_FAILURE(); return false; } @@ -126,7 +126,7 @@ class LoggingForwardVectorIterator : public InternalIterator { keys_.begin(); } - virtual void SeekForPrev(const Slice& target) override { assert(false); } + virtual void SeekForPrev(const Slice& /*target*/) override { assert(false); } virtual void Next() override { assert(Valid()); @@ -158,9 +158,12 @@ class FakeCompaction : public CompactionIterator::CompactionProxy { public: FakeCompaction() = default; - virtual int level(size_t compaction_input_level) const override { return 0; } + virtual int level(size_t /*compaction_input_level*/) const override { + return 0; + } virtual bool KeyNotExistsBeyondOutputLevel( - const Slice& user_key, std::vector* level_ptrs) const override { + const Slice& /*user_key*/, + std::vector* /*level_ptrs*/) const override { return is_bottommost_level || key_not_exists_beyond_output_level; } virtual bool bottommost_level() const override { return is_bottommost_level; } @@ -365,9 +368,9 @@ TEST_P(CompactionIteratorTest, RangeDeletionWithSnapshots) { TEST_P(CompactionIteratorTest, CompactionFilterSkipUntil) { class Filter : public CompactionFilter { - virtual Decision FilterV2(int level, const Slice& key, ValueType t, + virtual Decision FilterV2(int /*level*/, const Slice& key, ValueType t, const Slice& existing_value, - std::string* new_value, + std::string* /*new_value*/, std::string* skip_until) const override { std::string k = key.ToString(); std::string v = existing_value.ToString(); @@ -548,10 +551,10 @@ TEST_P(CompactionIteratorTest, ShuttingDownInMerge) { TEST_P(CompactionIteratorTest, SingleMergeOperand) { class Filter : public CompactionFilter { - virtual Decision FilterV2(int level, const Slice& key, ValueType t, + virtual Decision FilterV2(int /*level*/, const Slice& key, ValueType t, const Slice& existing_value, - std::string* new_value, - std::string* skip_until) const override { + std::string* /*new_value*/, + std::string* /*skip_until*/) const override { std::string k = key.ToString(); std::string v = existing_value.ToString(); @@ -602,7 +605,7 @@ TEST_P(CompactionIteratorTest, SingleMergeOperand) { bool PartialMergeMulti(const Slice& key, const std::deque& operand_list, std::string* new_value, - Logger* logger) const override { + Logger* /*logger*/) const override { std::string string_key = key.ToString(); EXPECT_TRUE(string_key == "a" || string_key == "b"); diff --git a/db/compaction_job_stats_test.cc b/db/compaction_job_stats_test.cc index 9a8372f57..afcf6d533 100644 --- a/db/compaction_job_stats_test.cc +++ b/db/compaction_job_stats_test.cc @@ -426,7 +426,7 @@ class CompactionJobStatsChecker : public EventListener { // Once a compaction completed, this function will verify the returned // CompactionJobInfo with the oldest CompactionJobInfo added earlier // in "expected_stats_" which has not yet being used for verification. - virtual void OnCompactionCompleted(DB *db, const CompactionJobInfo& ci) { + virtual void OnCompactionCompleted(DB* /*db*/, const CompactionJobInfo& ci) { if (verify_next_comp_io_stats_) { ASSERT_GT(ci.stats.file_write_nanos, 0); ASSERT_GT(ci.stats.file_range_sync_nanos, 0); diff --git a/db/compaction_picker.cc b/db/compaction_picker.cc index 0e4d5627a..353dc2985 100644 --- a/db/compaction_picker.cc +++ b/db/compaction_picker.cc @@ -199,7 +199,7 @@ void CompactionPicker::GetRange(const std::vector& inputs, assert(initialized); } -bool CompactionPicker::ExpandInputsToCleanCut(const std::string& cf_name, +bool CompactionPicker::ExpandInputsToCleanCut(const std::string& /*cf_name*/, VersionStorageInfo* vstorage, CompactionInputFiles* inputs) { // This isn't good compaction @@ -309,7 +309,7 @@ Compaction* CompactionPicker::CompactFiles( Status CompactionPicker::GetCompactionInputsFromFileNumbers( std::vector* input_files, std::unordered_set* input_set, const VersionStorageInfo* vstorage, - const CompactionOptions& compact_options) const { + const CompactionOptions& /*compact_options*/) const { if (input_set->size() == 0U) { return Status::InvalidArgument( "Compaction must include at least one file."); @@ -1612,8 +1612,9 @@ Compaction* FIFOCompactionPicker::PickCompaction( Compaction* FIFOCompactionPicker::CompactRange( const std::string& cf_name, const MutableCFOptions& mutable_cf_options, VersionStorageInfo* vstorage, int input_level, int output_level, - uint32_t output_path_id, const InternalKey* begin, const InternalKey* end, - InternalKey** compaction_end, bool* manual_conflict) { + uint32_t /*output_path_id*/, const InternalKey* /*begin*/, + const InternalKey* /*end*/, InternalKey** compaction_end, + bool* /*manual_conflict*/) { assert(input_level == 0); assert(output_level == 0); *compaction_end = nullptr; diff --git a/db/compaction_picker.h b/db/compaction_picker.h index 3172a68e8..a6a551881 100644 --- a/db/compaction_picker.h +++ b/db/compaction_picker.h @@ -267,27 +267,29 @@ class NullCompactionPicker : public CompactionPicker { virtual ~NullCompactionPicker() {} // Always return "nullptr" - Compaction* PickCompaction(const std::string& cf_name, - const MutableCFOptions& mutable_cf_options, - VersionStorageInfo* vstorage, - LogBuffer* log_buffer) override { + Compaction* PickCompaction(const std::string& /*cf_name*/, + const MutableCFOptions& /*mutable_cf_options*/, + VersionStorageInfo* /*vstorage*/, + LogBuffer* /*log_buffer*/) override { return nullptr; } // Always return "nullptr" - Compaction* CompactRange(const std::string& cf_name, - const MutableCFOptions& mutable_cf_options, - VersionStorageInfo* vstorage, int input_level, - int output_level, uint32_t output_path_id, - const InternalKey* begin, const InternalKey* end, - InternalKey** compaction_end, - bool* manual_conflict) override { + Compaction* CompactRange(const std::string& /*cf_name*/, + const MutableCFOptions& /*mutable_cf_options*/, + VersionStorageInfo* /*vstorage*/, + int /*input_level*/, int /*output_level*/, + uint32_t /*output_path_id*/, + const InternalKey* /*begin*/, + const InternalKey* /*end*/, + InternalKey** /*compaction_end*/, + bool* /*manual_conflict*/) override { return nullptr; } // Always returns false. virtual bool NeedsCompaction( - const VersionStorageInfo* vstorage) const override { + const VersionStorageInfo* /*vstorage*/) const override { return false; } }; diff --git a/db/compaction_picker_test.cc b/db/compaction_picker_test.cc index 4752d3428..297949070 100644 --- a/db/compaction_picker_test.cc +++ b/db/compaction_picker_test.cc @@ -20,7 +20,9 @@ namespace rocksdb { class CountingLogger : public Logger { public: using Logger::Logv; - virtual void Logv(const char* format, va_list ap) override { log_count++; } + virtual void Logv(const char* /*format*/, va_list /*ap*/) override { + log_count++; + } size_t log_count; }; diff --git a/db/compaction_picker_universal.cc b/db/compaction_picker_universal.cc index 960c65d2b..a0cbdea6e 100644 --- a/db/compaction_picker_universal.cc +++ b/db/compaction_picker_universal.cc @@ -204,7 +204,7 @@ void UniversalCompactionPicker::SortedRun::DumpSizeInfo( std::vector UniversalCompactionPicker::CalculateSortedRuns( - const VersionStorageInfo& vstorage, const ImmutableCFOptions& ioptions, + const VersionStorageInfo& vstorage, const ImmutableCFOptions& /*ioptions*/, const MutableCFOptions& mutable_cf_options) { std::vector ret; for (FileMetaData* f : vstorage.LevelFiles(0)) { diff --git a/db/comparator_db_test.cc b/db/comparator_db_test.cc index 28a2a5658..83740ffda 100644 --- a/db/comparator_db_test.cc +++ b/db/comparator_db_test.cc @@ -188,10 +188,10 @@ class DoubleComparator : public Comparator { return -1; } } - virtual void FindShortestSeparator(std::string* start, - const Slice& limit) const override {} + virtual void FindShortestSeparator(std::string* /*start*/, + const Slice& /*limit*/) const override {} - virtual void FindShortSuccessor(std::string* key) const override {} + virtual void FindShortSuccessor(std::string* /*key*/) const override {} }; class HashComparator : public Comparator { @@ -211,10 +211,10 @@ class HashComparator : public Comparator { return -1; } } - virtual void FindShortestSeparator(std::string* start, - const Slice& limit) const override {} + virtual void FindShortestSeparator(std::string* /*start*/, + const Slice& /*limit*/) const override {} - virtual void FindShortSuccessor(std::string* key) const override {} + virtual void FindShortSuccessor(std::string* /*key*/) const override {} }; class TwoStrComparator : public Comparator { @@ -243,10 +243,10 @@ class TwoStrComparator : public Comparator { } return a2.compare(b2); } - virtual void FindShortestSeparator(std::string* start, - const Slice& limit) const override {} + virtual void FindShortestSeparator(std::string* /*start*/, + const Slice& /*limit*/) const override {} - virtual void FindShortSuccessor(std::string* key) const override {} + virtual void FindShortSuccessor(std::string* /*key*/) const override {} }; } // namespace diff --git a/db/db_basic_test.cc b/db/db_basic_test.cc index c54768167..264a4ac2c 100644 --- a/db/db_basic_test.cc +++ b/db/db_basic_test.cc @@ -862,8 +862,9 @@ class TestEnv : public EnvWrapper { CloseHelper(); } } - virtual void Logv(const char *format, va_list ap) override { }; - protected: + virtual void Logv(const char* /*format*/, va_list /*ap*/) override{}; + + protected: virtual Status CloseImpl() override { return CloseHelper(); } @@ -879,7 +880,7 @@ class TestEnv : public EnvWrapper { int GetCloseCount() { return close_count; } - virtual Status NewLogger(const std::string& fname, + virtual Status NewLogger(const std::string& /*fname*/, shared_ptr* result) { result->reset(new TestLogger(this)); return Status::OK(); diff --git a/db/db_block_cache_test.cc b/db/db_block_cache_test.cc index 82c420c70..5149a90c4 100644 --- a/db/db_block_cache_test.cc +++ b/db/db_block_cache_test.cc @@ -47,7 +47,7 @@ class DBBlockCacheTest : public DBTestBase { return options; } - void InitTable(const Options& options) { + void InitTable(const Options& /*options*/) { std::string value(kValueSize, 'a'); for (size_t i = 0; i < kNumBlocks; i++) { ASSERT_OK(Put(ToString(i), value.c_str())); diff --git a/db/db_compaction_filter_test.cc b/db/db_compaction_filter_test.cc index 0837d8fee..c2ee78a33 100644 --- a/db/db_compaction_filter_test.cc +++ b/db/db_compaction_filter_test.cc @@ -56,9 +56,9 @@ INSTANTIATE_TEST_CASE_P( class KeepFilter : public CompactionFilter { public: - virtual bool Filter(int level, const Slice& key, const Slice& value, - std::string* new_value, bool* value_changed) const - override { + virtual bool Filter(int /*level*/, const Slice& /*key*/, + const Slice& /*value*/, std::string* /*new_value*/, + bool* /*value_changed*/) const override { cfilter_count++; return false; } @@ -68,9 +68,9 @@ class KeepFilter : public CompactionFilter { class DeleteFilter : public CompactionFilter { public: - virtual bool Filter(int level, const Slice& key, const Slice& value, - std::string* new_value, bool* value_changed) const - override { + virtual bool Filter(int /*level*/, const Slice& /*key*/, + const Slice& /*value*/, std::string* /*new_value*/, + bool* /*value_changed*/) const override { cfilter_count++; return true; } @@ -80,9 +80,9 @@ class DeleteFilter : public CompactionFilter { class DeleteISFilter : public CompactionFilter { public: - virtual bool Filter(int level, const Slice& key, const Slice& value, - std::string* new_value, - bool* value_changed) const override { + virtual bool Filter(int /*level*/, const Slice& key, const Slice& /*value*/, + std::string* /*new_value*/, + bool* /*value_changed*/) const override { cfilter_count++; int i = std::stoi(key.ToString()); if (i > 5 && i <= 105) { @@ -100,8 +100,10 @@ class DeleteISFilter : public CompactionFilter { // zero-padded to length 10. class SkipEvenFilter : public CompactionFilter { public: - virtual Decision FilterV2(int level, const Slice& key, ValueType value_type, - const Slice& existing_value, std::string* new_value, + virtual Decision FilterV2(int /*level*/, const Slice& key, + ValueType /*value_type*/, + const Slice& /*existing_value*/, + std::string* /*new_value*/, std::string* skip_until) const override { cfilter_count++; int i = std::stoi(key.ToString()); @@ -123,9 +125,9 @@ class SkipEvenFilter : public CompactionFilter { class DelayFilter : public CompactionFilter { public: explicit DelayFilter(DBTestBase* d) : db_test(d) {} - virtual bool Filter(int level, const Slice& key, const Slice& value, - std::string* new_value, - bool* value_changed) const override { + virtual bool Filter(int /*level*/, const Slice& /*key*/, + const Slice& /*value*/, std::string* /*new_value*/, + bool* /*value_changed*/) const override { db_test->env_->addon_time_.fetch_add(1000); return true; } @@ -140,9 +142,9 @@ class ConditionalFilter : public CompactionFilter { public: explicit ConditionalFilter(const std::string* filtered_value) : filtered_value_(filtered_value) {} - virtual bool Filter(int level, const Slice& key, const Slice& value, - std::string* new_value, - bool* value_changed) const override { + virtual bool Filter(int /*level*/, const Slice& /*key*/, const Slice& value, + std::string* /*new_value*/, + bool* /*value_changed*/) const override { return value.ToString() == *filtered_value_; } @@ -156,9 +158,9 @@ class ChangeFilter : public CompactionFilter { public: explicit ChangeFilter() {} - virtual bool Filter(int level, const Slice& key, const Slice& value, - std::string* new_value, bool* value_changed) const - override { + virtual bool Filter(int /*level*/, const Slice& /*key*/, + const Slice& /*value*/, std::string* new_value, + bool* value_changed) const override { assert(new_value != nullptr); *new_value = NEW_VALUE; *value_changed = true; @@ -247,7 +249,7 @@ class DelayFilterFactory : public CompactionFilterFactory { public: explicit DelayFilterFactory(DBTestBase* d) : db_test(d) {} virtual std::unique_ptr CreateCompactionFilter( - const CompactionFilter::Context& context) override { + const CompactionFilter::Context& /*context*/) override { return std::unique_ptr(new DelayFilter(db_test)); } @@ -263,7 +265,7 @@ class ConditionalFilterFactory : public CompactionFilterFactory { : filtered_value_(filtered_value.ToString()) {} virtual std::unique_ptr CreateCompactionFilter( - const CompactionFilter::Context& context) override { + const CompactionFilter::Context& /*context*/) override { return std::unique_ptr( new ConditionalFilter(&filtered_value_)); } @@ -281,7 +283,7 @@ class ChangeFilterFactory : public CompactionFilterFactory { explicit ChangeFilterFactory() {} virtual std::unique_ptr CreateCompactionFilter( - const CompactionFilter::Context& context) override { + const CompactionFilter::Context& /*context*/) override { return std::unique_ptr(new ChangeFilter()); } diff --git a/db/db_compaction_test.cc b/db/db_compaction_test.cc index 654922b6e..a729623ee 100644 --- a/db/db_compaction_test.cc +++ b/db/db_compaction_test.cc @@ -53,7 +53,7 @@ class FlushedFileCollector : public EventListener { FlushedFileCollector() {} ~FlushedFileCollector() {} - virtual void OnFlushCompleted(DB* db, const FlushJobInfo& info) override { + virtual void OnFlushCompleted(DB* /*db*/, const FlushJobInfo& info) override { std::lock_guard lock(mutex_); flushed_files_.push_back(info.file_path); } diff --git a/db/db_impl.cc b/db/db_impl.cc index 1188a0f34..6bf9a92bf 100644 --- a/db/db_impl.cc +++ b/db/db_impl.cc @@ -675,8 +675,9 @@ Status DBImpl::SetDBOptions( } // return the same level if it cannot be moved -int DBImpl::FindMinimumEmptyLevelFitting(ColumnFamilyData* cfd, - const MutableCFOptions& mutable_cf_options, int level) { +int DBImpl::FindMinimumEmptyLevelFitting( + ColumnFamilyData* cfd, const MutableCFOptions& /*mutable_cf_options*/, + int level) { mutex_.AssertHeld(); const auto* vstorage = cfd->current()->storage_info(); int minimum_level = level; @@ -897,7 +898,7 @@ struct IterState { bool background_purge; }; -static void CleanupIteratorState(void* arg1, void* arg2) { +static void CleanupIteratorState(void* arg1, void* /*arg2*/) { IterState* state = reinterpret_cast(arg1); if (state->super_version->Unref()) { @@ -2335,31 +2336,31 @@ Status DBImpl::GetDbIdentity(std::string& identity) const { } // Default implementation -- returns not supported status -Status DB::CreateColumnFamily(const ColumnFamilyOptions& cf_options, - const std::string& column_family_name, - ColumnFamilyHandle** handle) { +Status DB::CreateColumnFamily(const ColumnFamilyOptions& /*cf_options*/, + const std::string& /*column_family_name*/, + ColumnFamilyHandle** /*handle*/) { return Status::NotSupported(""); } Status DB::CreateColumnFamilies( - const ColumnFamilyOptions& cf_options, - const std::vector& column_family_names, - std::vector* handles) { + const ColumnFamilyOptions& /*cf_options*/, + const std::vector& /*column_family_names*/, + std::vector* /*handles*/) { return Status::NotSupported(""); } Status DB::CreateColumnFamilies( - const std::vector& column_families, - std::vector* handles) { + const std::vector& /*column_families*/, + std::vector* /*handles*/) { return Status::NotSupported(""); } -Status DB::DropColumnFamily(ColumnFamilyHandle* column_family) { +Status DB::DropColumnFamily(ColumnFamilyHandle* /*column_family*/) { return Status::NotSupported(""); } Status DB::DropColumnFamilies( - const std::vector& column_families) { + const std::vector& /*column_families*/) { return Status::NotSupported(""); } diff --git a/db/db_impl_compaction_flush.cc b/db/db_impl_compaction_flush.cc index 178f9a217..47eed51fa 100644 --- a/db/db_impl_compaction_flush.cc +++ b/db/db_impl_compaction_flush.cc @@ -864,7 +864,7 @@ int DBImpl::NumberLevels(ColumnFamilyHandle* column_family) { return cfh->cfd()->NumberLevels(); } -int DBImpl::MaxMemCompactionLevel(ColumnFamilyHandle* column_family) { +int DBImpl::MaxMemCompactionLevel(ColumnFamilyHandle* /*column_family*/) { return 0; } diff --git a/db/db_impl_readonly.cc b/db/db_impl_readonly.cc index b7ebaa53f..d77e1d8b9 100644 --- a/db/db_impl_readonly.cc +++ b/db/db_impl_readonly.cc @@ -107,7 +107,7 @@ Status DBImplReadOnly::NewIterators( } Status DB::OpenForReadOnly(const Options& options, const std::string& dbname, - DB** dbptr, bool error_if_log_file_exist) { + DB** dbptr, bool /*error_if_log_file_exist*/) { *dbptr = nullptr; // Try to first open DB as fully compacted DB diff --git a/db/db_impl_readonly.h b/db/db_impl_readonly.h index 9bdc95cc8..35f2d1c85 100644 --- a/db/db_impl_readonly.h +++ b/db/db_impl_readonly.h @@ -36,46 +36,47 @@ class DBImplReadOnly : public DBImpl { std::vector* iterators) override; using DBImpl::Put; - virtual Status Put(const WriteOptions& options, - ColumnFamilyHandle* column_family, const Slice& key, - const Slice& value) override { + virtual Status Put(const WriteOptions& /*options*/, + ColumnFamilyHandle* /*column_family*/, + const Slice& /*key*/, const Slice& /*value*/) override { return Status::NotSupported("Not supported operation in read only mode."); } using DBImpl::Merge; - virtual Status Merge(const WriteOptions& options, - ColumnFamilyHandle* column_family, const Slice& key, - const Slice& value) override { + virtual Status Merge(const WriteOptions& /*options*/, + ColumnFamilyHandle* /*column_family*/, + const Slice& /*key*/, const Slice& /*value*/) override { return Status::NotSupported("Not supported operation in read only mode."); } using DBImpl::Delete; - virtual Status Delete(const WriteOptions& options, - ColumnFamilyHandle* column_family, - const Slice& key) override { + virtual Status Delete(const WriteOptions& /*options*/, + ColumnFamilyHandle* /*column_family*/, + const Slice& /*key*/) override { return Status::NotSupported("Not supported operation in read only mode."); } using DBImpl::SingleDelete; - virtual Status SingleDelete(const WriteOptions& options, - ColumnFamilyHandle* column_family, - const Slice& key) override { + virtual Status SingleDelete(const WriteOptions& /*options*/, + ColumnFamilyHandle* /*column_family*/, + const Slice& /*key*/) override { return Status::NotSupported("Not supported operation in read only mode."); } - virtual Status Write(const WriteOptions& options, - WriteBatch* updates) override { + virtual Status Write(const WriteOptions& /*options*/, + WriteBatch* /*updates*/) override { return Status::NotSupported("Not supported operation in read only mode."); } using DBImpl::CompactRange; - virtual Status CompactRange(const CompactRangeOptions& options, - ColumnFamilyHandle* column_family, - const Slice* begin, const Slice* end) override { + virtual Status CompactRange(const CompactRangeOptions& /*options*/, + ColumnFamilyHandle* /*column_family*/, + const Slice* /*begin*/, + const Slice* /*end*/) override { return Status::NotSupported("Not supported operation in read only mode."); } using DBImpl::CompactFiles; virtual Status CompactFiles( - const CompactionOptions& compact_options, - ColumnFamilyHandle* column_family, - const std::vector& input_file_names, - const int output_level, const int output_path_id = -1) override { + const CompactionOptions& /*compact_options*/, + ColumnFamilyHandle* /*column_family*/, + const std::vector& /*input_file_names*/, + const int /*output_level*/, const int /*output_path_id*/ = -1) override { return Status::NotSupported("Not supported operation in read only mode."); } @@ -83,18 +84,18 @@ class DBImplReadOnly : public DBImpl { return Status::NotSupported("Not supported operation in read only mode."); } - virtual Status EnableFileDeletions(bool force) override { + virtual Status EnableFileDeletions(bool /*force*/) override { return Status::NotSupported("Not supported operation in read only mode."); } virtual Status GetLiveFiles(std::vector&, - uint64_t* manifest_file_size, - bool flush_memtable = true) override { + uint64_t* /*manifest_file_size*/, + bool /*flush_memtable*/ = true) override { return Status::NotSupported("Not supported operation in read only mode."); } using DBImpl::Flush; - virtual Status Flush(const FlushOptions& options, - ColumnFamilyHandle* column_family) override { + virtual Status Flush(const FlushOptions& /*options*/, + ColumnFamilyHandle* /*column_family*/) override { return Status::NotSupported("Not supported operation in read only mode."); } @@ -105,9 +106,9 @@ class DBImplReadOnly : public DBImpl { using DB::IngestExternalFile; virtual Status IngestExternalFile( - ColumnFamilyHandle* column_family, - const std::vector& external_files, - const IngestExternalFileOptions& ingestion_options) override { + ColumnFamilyHandle* /*column_family*/, + const std::vector& /*external_files*/, + const IngestExternalFileOptions& /*ingestion_options*/) override { return Status::NotSupported("Not supported operation in read only mode."); } diff --git a/db/db_impl_write.cc b/db/db_impl_write.cc index 9e83df861..34ecad360 100644 --- a/db/db_impl_write.cc +++ b/db/db_impl_write.cc @@ -1175,7 +1175,7 @@ Status DBImpl::ScheduleFlushes(WriteContext* context) { } #ifndef ROCKSDB_LITE -void DBImpl::NotifyOnMemTableSealed(ColumnFamilyData* cfd, +void DBImpl::NotifyOnMemTableSealed(ColumnFamilyData* /*cfd*/, const MemTableInfo& mem_table_info) { if (immutable_db_options_.listeners.size() == 0U) { return; diff --git a/db/db_iterator_test.cc b/db/db_iterator_test.cc index a0ecbb681..24dbac41b 100644 --- a/db/db_iterator_test.cc +++ b/db/db_iterator_test.cc @@ -50,7 +50,7 @@ class DBIteratorTest : public DBTestBase, class FlushBlockEveryKeyPolicy : public FlushBlockPolicy { public: - virtual bool Update(const Slice& key, const Slice& value) override { + virtual bool Update(const Slice& /*key*/, const Slice& /*value*/) override { if (!start_) { start_ = true; return false; @@ -70,8 +70,8 @@ class FlushBlockEveryKeyPolicyFactory : public FlushBlockPolicyFactory { } FlushBlockPolicy* NewFlushBlockPolicy( - const BlockBasedTableOptions& table_options, - const BlockBuilder& data_block_builder) const override { + const BlockBasedTableOptions& /*table_options*/, + const BlockBuilder& /*data_block_builder*/) const override { return new FlushBlockEveryKeyPolicy; } }; diff --git a/db/db_memtable_test.cc b/db/db_memtable_test.cc index 92109c6ca..5f47a9481 100644 --- a/db/db_memtable_test.cc +++ b/db/db_memtable_test.cc @@ -119,7 +119,7 @@ class TestPrefixExtractor : public SliceTransform { return separator(key) != nullptr; } - virtual bool InRange(const Slice& key) const override { return false; } + virtual bool InRange(const Slice& /*key*/) const override { return false; } private: const char* separator(const Slice& key) const { diff --git a/db/db_properties_test.cc b/db/db_properties_test.cc index 9bd587f12..f8b35b2c7 100644 --- a/db/db_properties_test.cc +++ b/db/db_properties_test.cc @@ -986,8 +986,9 @@ class CountingUserTblPropCollector : public TablePropertiesCollector { return Status::OK(); } - Status AddUserKey(const Slice& user_key, const Slice& value, EntryType type, - SequenceNumber seq, uint64_t file_size) override { + Status AddUserKey(const Slice& /*user_key*/, const Slice& /*value*/, + EntryType /*type*/, SequenceNumber /*seq*/, + uint64_t /*file_size*/) override { ++count_; return Status::OK(); } @@ -1028,8 +1029,9 @@ class CountingDeleteTabPropCollector : public TablePropertiesCollector { public: const char* Name() const override { return "CountingDeleteTabPropCollector"; } - Status AddUserKey(const Slice& user_key, const Slice& value, EntryType type, - SequenceNumber seq, uint64_t file_size) override { + Status AddUserKey(const Slice& /*user_key*/, const Slice& /*value*/, + EntryType type, SequenceNumber /*seq*/, + uint64_t /*file_size*/) override { if (type == kEntryDelete) { num_deletes_++; } @@ -1056,7 +1058,7 @@ class CountingDeleteTabPropCollectorFactory : public TablePropertiesCollectorFactory { public: virtual TablePropertiesCollector* CreateTablePropertiesCollector( - TablePropertiesCollectorFactory::Context context) override { + TablePropertiesCollectorFactory::Context /*context*/) override { return new CountingDeleteTabPropCollector(); } const char* Name() const override { diff --git a/db/db_test.cc b/db/db_test.cc index b21150c66..d342b8355 100644 --- a/db/db_test.cc +++ b/db/db_test.cc @@ -750,9 +750,9 @@ TEST_F(DBTest, FlushSchedule) { namespace { class KeepFilter : public CompactionFilter { public: - virtual bool Filter(int level, const Slice& key, const Slice& value, - std::string* new_value, - bool* value_changed) const override { + virtual bool Filter(int /*level*/, const Slice& /*key*/, + const Slice& /*value*/, std::string* /*new_value*/, + bool* /*value_changed*/) const override { return false; } @@ -782,9 +782,9 @@ class KeepFilterFactory : public CompactionFilterFactory { class DelayFilter : public CompactionFilter { public: explicit DelayFilter(DBTestBase* d) : db_test(d) {} - virtual bool Filter(int level, const Slice& key, const Slice& value, - std::string* new_value, - bool* value_changed) const override { + virtual bool Filter(int /*level*/, const Slice& /*key*/, + const Slice& /*value*/, std::string* /*new_value*/, + bool* /*value_changed*/) const override { db_test->env_->addon_time_.fetch_add(1000); return true; } @@ -799,7 +799,7 @@ class DelayFilterFactory : public CompactionFilterFactory { public: explicit DelayFilterFactory(DBTestBase* d) : db_test(d) {} virtual std::unique_ptr CreateCompactionFilter( - const CompactionFilter::Context& context) override { + const CompactionFilter::Context& /*context*/) override { return std::unique_ptr(new DelayFilter(db_test)); } @@ -2247,17 +2247,17 @@ class ModelDB : public DB { return Write(o, &batch); } using DB::Get; - virtual Status Get(const ReadOptions& options, ColumnFamilyHandle* cf, - const Slice& key, PinnableSlice* value) override { + virtual Status Get(const ReadOptions& /*options*/, ColumnFamilyHandle* /*cf*/, + const Slice& key, PinnableSlice* /*value*/) override { return Status::NotSupported(key); } using DB::MultiGet; virtual std::vector MultiGet( - const ReadOptions& options, - const std::vector& column_family, + const ReadOptions& /*options*/, + const std::vector& /*column_family*/, const std::vector& keys, - std::vector* values) override { + std::vector* /*values*/) override { std::vector s(keys.size(), Status::NotSupported("Not implemented.")); return s; @@ -2266,9 +2266,9 @@ class ModelDB : public DB { #ifndef ROCKSDB_LITE using DB::IngestExternalFile; virtual Status IngestExternalFile( - ColumnFamilyHandle* column_family, - const std::vector& external_files, - const IngestExternalFileOptions& options) override { + ColumnFamilyHandle* /*column_family*/, + const std::vector& /*external_files*/, + const IngestExternalFileOptions& /*options*/) override { return Status::NotSupported("Not implemented."); } @@ -2278,22 +2278,22 @@ class ModelDB : public DB { using DB::GetPropertiesOfAllTables; virtual Status GetPropertiesOfAllTables( - ColumnFamilyHandle* column_family, - TablePropertiesCollection* props) override { + ColumnFamilyHandle* /*column_family*/, + TablePropertiesCollection* /*props*/) override { return Status(); } virtual Status GetPropertiesOfTablesInRange( - ColumnFamilyHandle* column_family, const Range* range, std::size_t n, - TablePropertiesCollection* props) override { + ColumnFamilyHandle* /*column_family*/, const Range* /*range*/, + std::size_t /*n*/, TablePropertiesCollection* /*props*/) override { return Status(); } #endif // ROCKSDB_LITE using DB::KeyMayExist; - virtual bool KeyMayExist(const ReadOptions& options, - ColumnFamilyHandle* column_family, const Slice& key, - std::string* value, + virtual bool KeyMayExist(const ReadOptions& /*options*/, + ColumnFamilyHandle* /*column_family*/, + const Slice& /*key*/, std::string* /*value*/, bool* value_found = nullptr) override { if (value_found != nullptr) { *value_found = false; @@ -2301,8 +2301,9 @@ class ModelDB : public DB { return true; // Not Supported directly } using DB::NewIterator; - virtual Iterator* NewIterator(const ReadOptions& options, - ColumnFamilyHandle* column_family) override { + virtual Iterator* NewIterator( + const ReadOptions& options, + ColumnFamilyHandle* /*column_family*/) override { if (options.snapshot == nullptr) { KVMap* saved = new KVMap; *saved = map_; @@ -2314,9 +2315,9 @@ class ModelDB : public DB { } } virtual Status NewIterators( - const ReadOptions& options, - const std::vector& column_family, - std::vector* iterators) override { + const ReadOptions& /*options*/, + const std::vector& /*column_family*/, + std::vector* /*iterators*/) override { return Status::NotSupported("Not supported yet"); } virtual const Snapshot* GetSnapshot() override { @@ -2329,7 +2330,7 @@ class ModelDB : public DB { delete reinterpret_cast(snapshot); } - virtual Status Write(const WriteOptions& options, + virtual Status Write(const WriteOptions& /*options*/, WriteBatch* batch) override { class Handler : public WriteBatch::Handler { public: @@ -2337,7 +2338,8 @@ class ModelDB : public DB { virtual void Put(const Slice& key, const Slice& value) override { (*map_)[key.ToString()] = value.ToString(); } - virtual void Merge(const Slice& key, const Slice& value) override { + virtual void Merge(const Slice& /*key*/, + const Slice& /*value*/) override { // ignore merge for now // (*map_)[key.ToString()] = value.ToString(); } @@ -2351,62 +2353,65 @@ class ModelDB : public DB { } using DB::GetProperty; - virtual bool GetProperty(ColumnFamilyHandle* column_family, - const Slice& property, std::string* value) override { + virtual bool GetProperty(ColumnFamilyHandle* /*column_family*/, + const Slice& /*property*/, + std::string* /*value*/) override { return false; } using DB::GetIntProperty; - virtual bool GetIntProperty(ColumnFamilyHandle* column_family, - const Slice& property, uint64_t* value) override { + virtual bool GetIntProperty(ColumnFamilyHandle* /*column_family*/, + const Slice& /*property*/, + uint64_t* /*value*/) override { return false; } using DB::GetMapProperty; virtual bool GetMapProperty( - ColumnFamilyHandle* column_family, const Slice& property, - std::map* value) override { + ColumnFamilyHandle* /*column_family*/, const Slice& /*property*/, + std::map* /*value*/) override { return false; } using DB::GetAggregatedIntProperty; - virtual bool GetAggregatedIntProperty(const Slice& property, - uint64_t* value) override { + virtual bool GetAggregatedIntProperty(const Slice& /*property*/, + uint64_t* /*value*/) override { return false; } using DB::GetApproximateSizes; - virtual void GetApproximateSizes(ColumnFamilyHandle* column_family, - const Range* range, int n, uint64_t* sizes, - uint8_t include_flags + virtual void GetApproximateSizes(ColumnFamilyHandle* /*column_family*/, + const Range* /*range*/, int n, + uint64_t* sizes, + uint8_t /*include_flags*/ = INCLUDE_FILES) override { for (int i = 0; i < n; i++) { sizes[i] = 0; } } using DB::GetApproximateMemTableStats; - virtual void GetApproximateMemTableStats(ColumnFamilyHandle* column_family, - const Range& range, - uint64_t* const count, - uint64_t* const size) override { + virtual void GetApproximateMemTableStats( + ColumnFamilyHandle* /*column_family*/, const Range& /*range*/, + uint64_t* const count, uint64_t* const size) override { *count = 0; *size = 0; } using DB::CompactRange; - virtual Status CompactRange(const CompactRangeOptions& options, - ColumnFamilyHandle* column_family, - const Slice* start, const Slice* end) override { + virtual Status CompactRange(const CompactRangeOptions& /*options*/, + ColumnFamilyHandle* /*column_family*/, + const Slice* /*start*/, + const Slice* /*end*/) override { return Status::NotSupported("Not supported operation."); } virtual Status SetDBOptions( - const std::unordered_map& new_options) + const std::unordered_map& /*new_options*/) override { return Status::NotSupported("Not supported operation."); } using DB::CompactFiles; - virtual Status CompactFiles(const CompactionOptions& compact_options, - ColumnFamilyHandle* column_family, - const std::vector& input_file_names, - const int output_level, - const int output_path_id = -1) override { + virtual Status CompactFiles( + const CompactionOptions& /*compact_options*/, + ColumnFamilyHandle* /*column_family*/, + const std::vector& /*input_file_names*/, + const int /*output_level*/, const int /*output_path_id*/ = -1) override { return Status::NotSupported("Not supported operation."); } @@ -2419,24 +2424,25 @@ class ModelDB : public DB { } Status EnableAutoCompaction( - const std::vector& column_family_handles) override { + const std::vector& /*column_family_handles*/) + override { return Status::NotSupported("Not supported operation."); } using DB::NumberLevels; - virtual int NumberLevels(ColumnFamilyHandle* column_family) override { + virtual int NumberLevels(ColumnFamilyHandle* /*column_family*/) override { return 1; } using DB::MaxMemCompactionLevel; virtual int MaxMemCompactionLevel( - ColumnFamilyHandle* column_family) override { + ColumnFamilyHandle* /*column_family*/) override { return 1; } using DB::Level0StopWriteTrigger; virtual int Level0StopWriteTrigger( - ColumnFamilyHandle* column_family) override { + ColumnFamilyHandle* /*column_family*/) override { return -1; } @@ -2445,7 +2451,8 @@ class ModelDB : public DB { virtual Env* GetEnv() const override { return nullptr; } using DB::GetOptions; - virtual Options GetOptions(ColumnFamilyHandle* column_family) const override { + virtual Options GetOptions( + ColumnFamilyHandle* /*column_family*/) const override { return options_; } @@ -2453,8 +2460,8 @@ class ModelDB : public DB { virtual DBOptions GetDBOptions() const override { return options_; } using DB::Flush; - virtual Status Flush(const rocksdb::FlushOptions& options, - ColumnFamilyHandle* column_family) override { + virtual Status Flush(const rocksdb::FlushOptions& /*options*/, + ColumnFamilyHandle* /*column_family*/) override { Status ret; return ret; } @@ -2464,39 +2471,42 @@ class ModelDB : public DB { #ifndef ROCKSDB_LITE virtual Status DisableFileDeletions() override { return Status::OK(); } - virtual Status EnableFileDeletions(bool force) override { + virtual Status EnableFileDeletions(bool /*force*/) override { return Status::OK(); } - virtual Status GetLiveFiles(std::vector&, uint64_t* size, - bool flush_memtable = true) override { + virtual Status GetLiveFiles(std::vector&, uint64_t* /*size*/, + bool /*flush_memtable*/ = true) override { return Status::OK(); } - virtual Status GetSortedWalFiles(VectorLogPtr& files) override { + virtual Status GetSortedWalFiles(VectorLogPtr& /*files*/) override { return Status::OK(); } - virtual Status DeleteFile(std::string name) override { return Status::OK(); } + virtual Status DeleteFile(std::string /*name*/) override { + return Status::OK(); + } virtual Status GetUpdatesSince( rocksdb::SequenceNumber, unique_ptr*, - const TransactionLogIterator::ReadOptions& read_options = + const TransactionLogIterator::ReadOptions& /*read_options*/ = TransactionLogIterator::ReadOptions()) override { return Status::NotSupported("Not supported in Model DB"); } virtual void GetColumnFamilyMetaData( - ColumnFamilyHandle* column_family, - ColumnFamilyMetaData* metadata) override {} + ColumnFamilyHandle* /*column_family*/, + ColumnFamilyMetaData* /*metadata*/) override {} #endif // ROCKSDB_LITE - virtual Status GetDbIdentity(std::string& identity) const override { + virtual Status GetDbIdentity(std::string& /*identity*/) const override { return Status::OK(); } virtual SequenceNumber GetLatestSequenceNumber() const override { return 0; } - virtual bool SetPreserveDeletesSequenceNumber(SequenceNumber seqnum) override { + virtual bool SetPreserveDeletesSequenceNumber( + SequenceNumber /*seqnum*/) override { return true; } @@ -4776,7 +4786,7 @@ class DelayedMergeOperator : public MergeOperator { public: explicit DelayedMergeOperator(DBTest* d) : db_test_(d) {} - virtual bool FullMergeV2(const MergeOperationInput& merge_in, + virtual bool FullMergeV2(const MergeOperationInput& /*merge_in*/, MergeOperationOutput* merge_out) const override { db_test_->env_->addon_time_.fetch_add(1000); merge_out->new_value = ""; diff --git a/db/db_test2.cc b/db/db_test2.cc index ee591d3bb..4628d7660 100644 --- a/db/db_test2.cc +++ b/db/db_test2.cc @@ -498,9 +498,9 @@ TEST_F(DBTest2, WalFilterTest) { apply_option_at_record_index_(apply_option_for_record_index), current_record_index_(0) {} - virtual WalProcessingOption LogRecord(const WriteBatch& batch, - WriteBatch* new_batch, - bool* batch_changed) const override { + virtual WalProcessingOption LogRecord( + const WriteBatch& /*batch*/, WriteBatch* /*new_batch*/, + bool* /*batch_changed*/) const override { WalFilter::WalProcessingOption option_to_return; if (current_record_index_ == apply_option_at_record_index_) { @@ -874,11 +874,10 @@ TEST_F(DBTest2, WalFilterTestWithColumnFamilies) { cf_name_id_map_ = cf_name_id_map; } - virtual WalProcessingOption LogRecordFound(unsigned long long log_number, - const std::string& log_file_name, - const WriteBatch& batch, - WriteBatch* new_batch, - bool* batch_changed) override { + virtual WalProcessingOption LogRecordFound( + unsigned long long log_number, const std::string& /*log_file_name*/, + const WriteBatch& batch, WriteBatch* /*new_batch*/, + bool* /*batch_changed*/) override { class LogRecordBatchHandler : public WriteBatch::Handler { private: const std::map & cf_log_number_map_; @@ -1231,7 +1230,7 @@ class CompactionStallTestListener : public EventListener { public: CompactionStallTestListener() : compacted_files_cnt_(0) {} - void OnCompactionCompleted(DB* db, const CompactionJobInfo& ci) override { + void OnCompactionCompleted(DB* /*db*/, const CompactionJobInfo& ci) override { ASSERT_EQ(ci.cf_name, "default"); ASSERT_EQ(ci.base_input_level, 0); ASSERT_EQ(ci.compaction_reason, CompactionReason::kLevelL0FilesNum); diff --git a/db/db_test_util.cc b/db/db_test_util.cc index 6bdc5b9a8..79f364159 100644 --- a/db/db_test_util.cc +++ b/db/db_test_util.cc @@ -1143,17 +1143,18 @@ UpdateStatus DBTestBase::updateInPlaceSmallerVarintSize(char* prevValue, } } -UpdateStatus DBTestBase::updateInPlaceLargerSize(char* prevValue, - uint32_t* prevSize, +UpdateStatus DBTestBase::updateInPlaceLargerSize(char* /*prevValue*/, + uint32_t* /*prevSize*/, Slice delta, std::string* newValue) { *newValue = std::string(delta.size(), 'c'); return UpdateStatus::UPDATED; } -UpdateStatus DBTestBase::updateInPlaceNoAction(char* prevValue, - uint32_t* prevSize, Slice delta, - std::string* newValue) { +UpdateStatus DBTestBase::updateInPlaceNoAction(char* /*prevValue*/, + uint32_t* /*prevSize*/, + Slice /*delta*/, + std::string* /*newValue*/) { return UpdateStatus::UPDATE_FAILED; } diff --git a/db/db_test_util.h b/db/db_test_util.h index 9f6345835..936823eff 100644 --- a/db/db_test_util.h +++ b/db/db_test_util.h @@ -187,7 +187,7 @@ class SpecialSkipListFactory : public MemTableRepFactory { using MemTableRepFactory::CreateMemTableRep; virtual MemTableRep* CreateMemTableRep( const MemTableRep::KeyComparator& compare, Allocator* allocator, - const SliceTransform* transform, Logger* logger) override { + const SliceTransform* transform, Logger* /*logger*/) override { return new SpecialMemTableRep( allocator, factory_.CreateMemTableRep(compare, allocator, transform, 0), num_entries_flush_); diff --git a/db/db_universal_compaction_test.cc b/db/db_universal_compaction_test.cc index 2bc78475e..80d17de21 100644 --- a/db/db_universal_compaction_test.cc +++ b/db/db_universal_compaction_test.cc @@ -56,9 +56,9 @@ void VerifyCompactionResult( class KeepFilter : public CompactionFilter { public: - virtual bool Filter(int level, const Slice& key, const Slice& value, - std::string* new_value, bool* value_changed) const - override { + virtual bool Filter(int /*level*/, const Slice& /*key*/, + const Slice& /*value*/, std::string* /*new_value*/, + bool* /*value_changed*/) const override { return false; } @@ -88,9 +88,9 @@ class KeepFilterFactory : public CompactionFilterFactory { class DelayFilter : public CompactionFilter { public: explicit DelayFilter(DBTestBase* d) : db_test(d) {} - virtual bool Filter(int level, const Slice& key, const Slice& value, - std::string* new_value, - bool* value_changed) const override { + virtual bool Filter(int /*level*/, const Slice& /*key*/, + const Slice& /*value*/, std::string* /*new_value*/, + bool* /*value_changed*/) const override { db_test->env_->addon_time_.fetch_add(1000); return true; } @@ -105,7 +105,7 @@ class DelayFilterFactory : public CompactionFilterFactory { public: explicit DelayFilterFactory(DBTestBase* d) : db_test(d) {} virtual std::unique_ptr CreateCompactionFilter( - const CompactionFilter::Context& context) override { + const CompactionFilter::Context& /*context*/) override { return std::unique_ptr(new DelayFilter(db_test)); } diff --git a/db/deletefile_test.cc b/db/deletefile_test.cc index 989c0c411..7a480fc46 100644 --- a/db/deletefile_test.cc +++ b/db/deletefile_test.cc @@ -159,7 +159,7 @@ class DeleteFileTest : public testing::Test { } // An empty job to guard all jobs are processed - static void GuardFinish(void* arg) { + static void GuardFinish(void* /*arg*/) { TEST_SYNC_POINT("DeleteFileTest::GuardFinish"); } }; diff --git a/db/external_sst_file_test.cc b/db/external_sst_file_test.cc index 8f7c86839..fcdf07adc 100644 --- a/db/external_sst_file_test.cc +++ b/db/external_sst_file_test.cc @@ -396,8 +396,9 @@ class SstFileWriterCollector : public TablePropertiesCollector { return Status::OK(); } - Status AddUserKey(const Slice& user_key, const Slice& value, EntryType type, - SequenceNumber seq, uint64_t file_size) override { + Status AddUserKey(const Slice& /*user_key*/, const Slice& /*value*/, + EntryType /*type*/, SequenceNumber /*seq*/, + uint64_t /*file_size*/) override { ++count_; return Status::OK(); } @@ -417,7 +418,7 @@ class SstFileWriterCollectorFactory : public TablePropertiesCollectorFactory { explicit SstFileWriterCollectorFactory(std::string prefix) : prefix_(prefix), num_created_(0) {} virtual TablePropertiesCollector* CreateTablePropertiesCollector( - TablePropertiesCollectorFactory::Context context) override { + TablePropertiesCollectorFactory::Context /*context*/) override { num_created_++; return new SstFileWriterCollector(prefix_); } @@ -1798,7 +1799,7 @@ TEST_F(ExternalSSTFileTest, FileWithCFInfo) { class TestIngestExternalFileListener : public EventListener { public: - void OnExternalFileIngested(DB* db, + void OnExternalFileIngested(DB* /*db*/, const ExternalFileIngestionInfo& info) override { ingested_files.push_back(info); } diff --git a/db/file_indexer_test.cc b/db/file_indexer_test.cc index 5cd8c2d2c..b424f91ea 100644 --- a/db/file_indexer_test.cc +++ b/db/file_indexer_test.cc @@ -36,10 +36,10 @@ class IntComparator : public Comparator { const char* Name() const override { return "IntComparator"; } - void FindShortestSeparator(std::string* start, - const Slice& limit) const override {} + void FindShortestSeparator(std::string* /*start*/, + const Slice& /*limit*/) const override {} - void FindShortSuccessor(std::string* key) const override {} + void FindShortSuccessor(std::string* /*key*/) const override {} }; class FileIndexerTest : public testing::Test { diff --git a/db/forward_iterator.cc b/db/forward_iterator.cc index e00e1d6d7..471d7c0b7 100644 --- a/db/forward_iterator.cc +++ b/db/forward_iterator.cc @@ -104,7 +104,7 @@ class ForwardLevelIterator : public InternalIterator { file_iter_->Seek(internal_key); valid_ = file_iter_->Valid(); } - void SeekForPrev(const Slice& internal_key) override { + void SeekForPrev(const Slice& /*internal_key*/) override { status_ = Status::NotSupported("ForwardLevelIterator::SeekForPrev()"); valid_ = false; } diff --git a/db/forward_iterator.h b/db/forward_iterator.h index c576a9d83..146588d96 100644 --- a/db/forward_iterator.h +++ b/db/forward_iterator.h @@ -55,7 +55,7 @@ class ForwardIterator : public InternalIterator { ColumnFamilyData* cfd, SuperVersion* current_sv = nullptr); virtual ~ForwardIterator(); - void SeekForPrev(const Slice& target) override { + void SeekForPrev(const Slice& /*target*/) override { status_ = Status::NotSupported("ForwardIterator::SeekForPrev()"); valid_ = false; } diff --git a/db/internal_stats.cc b/db/internal_stats.cc index 359e52c30..b3cf23808 100644 --- a/db/internal_stats.cc +++ b/db/internal_stats.cc @@ -447,7 +447,7 @@ bool InternalStats::GetStringProperty(const DBPropertyInfo& property_info, } bool InternalStats::GetMapProperty(const DBPropertyInfo& property_info, - const Slice& property, + const Slice& /*property*/, std::map* value) { assert(value != nullptr); assert(property_info.handle_map != nullptr); @@ -499,7 +499,7 @@ bool InternalStats::HandleCompressionRatioAtLevelPrefix(std::string* value, return true; } -bool InternalStats::HandleLevelStats(std::string* value, Slice suffix) { +bool InternalStats::HandleLevelStats(std::string* value, Slice /*suffix*/) { char buf[1000]; const auto* vstorage = cfd_->current()->storage_info(); snprintf(buf, sizeof(buf), @@ -532,35 +532,36 @@ bool InternalStats::HandleCFMapStats( return true; } -bool InternalStats::HandleCFStats(std::string* value, Slice suffix) { +bool InternalStats::HandleCFStats(std::string* value, Slice /*suffix*/) { DumpCFStats(value); return true; } bool InternalStats::HandleCFStatsNoFileHistogram(std::string* value, - Slice suffix) { + Slice /*suffix*/) { DumpCFStatsNoFileHistogram(value); return true; } -bool InternalStats::HandleCFFileHistogram(std::string* value, Slice suffix) { +bool InternalStats::HandleCFFileHistogram(std::string* value, + Slice /*suffix*/) { DumpCFFileHistogram(value); return true; } -bool InternalStats::HandleDBStats(std::string* value, Slice suffix) { +bool InternalStats::HandleDBStats(std::string* value, Slice /*suffix*/) { DumpDBStats(value); return true; } -bool InternalStats::HandleSsTables(std::string* value, Slice suffix) { +bool InternalStats::HandleSsTables(std::string* value, Slice /*suffix*/) { auto* current = cfd_->current(); *value = current->DebugString(true, true); return true; } bool InternalStats::HandleAggregatedTableProperties(std::string* value, - Slice suffix) { + Slice /*suffix*/) { std::shared_ptr tp; auto s = cfd_->current()->GetAggregatedTableProperties(&tp); if (!s.ok()) { @@ -587,34 +588,34 @@ bool InternalStats::HandleAggregatedTablePropertiesAtLevel(std::string* value, return true; } -bool InternalStats::HandleNumImmutableMemTable(uint64_t* value, DBImpl* db, - Version* version) { +bool InternalStats::HandleNumImmutableMemTable(uint64_t* value, DBImpl* /*db*/, + Version* /*version*/) { *value = cfd_->imm()->NumNotFlushed(); return true; } bool InternalStats::HandleNumImmutableMemTableFlushed(uint64_t* value, - DBImpl* db, - Version* version) { + DBImpl* /*db*/, + Version* /*version*/) { *value = cfd_->imm()->NumFlushed(); return true; } -bool InternalStats::HandleMemTableFlushPending(uint64_t* value, DBImpl* db, - Version* version) { +bool InternalStats::HandleMemTableFlushPending(uint64_t* value, DBImpl* /*db*/, + Version* /*version*/) { // Return number of mem tables that are ready to flush (made immutable) *value = (cfd_->imm()->IsFlushPending() ? 1 : 0); return true; } bool InternalStats::HandleNumRunningFlushes(uint64_t* value, DBImpl* db, - Version* version) { + Version* /*version*/) { *value = db->num_running_flushes(); return true; } -bool InternalStats::HandleCompactionPending(uint64_t* value, DBImpl* db, - Version* version) { +bool InternalStats::HandleCompactionPending(uint64_t* value, DBImpl* /*db*/, + Version* /*version*/) { // 1 if the system already determines at least one compaction is needed. // 0 otherwise, const auto* vstorage = cfd_->current()->storage_info(); @@ -623,70 +624,74 @@ bool InternalStats::HandleCompactionPending(uint64_t* value, DBImpl* db, } bool InternalStats::HandleNumRunningCompactions(uint64_t* value, DBImpl* db, - Version* version) { + Version* /*version*/) { *value = db->num_running_compactions_; return true; } -bool InternalStats::HandleBackgroundErrors(uint64_t* value, DBImpl* db, - Version* version) { +bool InternalStats::HandleBackgroundErrors(uint64_t* value, DBImpl* /*db*/, + Version* /*version*/) { // Accumulated number of errors in background flushes or compactions. *value = GetBackgroundErrorCount(); return true; } -bool InternalStats::HandleCurSizeActiveMemTable(uint64_t* value, DBImpl* db, - Version* version) { +bool InternalStats::HandleCurSizeActiveMemTable(uint64_t* value, DBImpl* /*db*/, + Version* /*version*/) { // Current size of the active memtable *value = cfd_->mem()->ApproximateMemoryUsage(); return true; } -bool InternalStats::HandleCurSizeAllMemTables(uint64_t* value, DBImpl* db, - Version* version) { +bool InternalStats::HandleCurSizeAllMemTables(uint64_t* value, DBImpl* /*db*/, + Version* /*version*/) { // Current size of the active memtable + immutable memtables *value = cfd_->mem()->ApproximateMemoryUsage() + cfd_->imm()->ApproximateUnflushedMemTablesMemoryUsage(); return true; } -bool InternalStats::HandleSizeAllMemTables(uint64_t* value, DBImpl* db, - Version* version) { +bool InternalStats::HandleSizeAllMemTables(uint64_t* value, DBImpl* /*db*/, + Version* /*version*/) { *value = cfd_->mem()->ApproximateMemoryUsage() + cfd_->imm()->ApproximateMemoryUsage(); return true; } -bool InternalStats::HandleNumEntriesActiveMemTable(uint64_t* value, DBImpl* db, - Version* version) { +bool InternalStats::HandleNumEntriesActiveMemTable(uint64_t* value, + DBImpl* /*db*/, + Version* /*version*/) { // Current number of entires in the active memtable *value = cfd_->mem()->num_entries(); return true; } -bool InternalStats::HandleNumEntriesImmMemTables(uint64_t* value, DBImpl* db, - Version* version) { +bool InternalStats::HandleNumEntriesImmMemTables(uint64_t* value, + DBImpl* /*db*/, + Version* /*version*/) { // Current number of entries in the immutable memtables *value = cfd_->imm()->current()->GetTotalNumEntries(); return true; } -bool InternalStats::HandleNumDeletesActiveMemTable(uint64_t* value, DBImpl* db, - Version* version) { +bool InternalStats::HandleNumDeletesActiveMemTable(uint64_t* value, + DBImpl* /*db*/, + Version* /*version*/) { // Current number of entires in the active memtable *value = cfd_->mem()->num_deletes(); return true; } -bool InternalStats::HandleNumDeletesImmMemTables(uint64_t* value, DBImpl* db, - Version* version) { +bool InternalStats::HandleNumDeletesImmMemTables(uint64_t* value, + DBImpl* /*db*/, + Version* /*version*/) { // Current number of entries in the immutable memtables *value = cfd_->imm()->current()->GetTotalNumDeletes(); return true; } -bool InternalStats::HandleEstimateNumKeys(uint64_t* value, DBImpl* db, - Version* version) { +bool InternalStats::HandleEstimateNumKeys(uint64_t* value, DBImpl* /*db*/, + Version* /*version*/) { // Estimate number of entries in the column family: // Use estimated entries in tables + total entries in memtables. const auto* vstorage = cfd_->current()->storage_info(); @@ -702,37 +707,38 @@ bool InternalStats::HandleEstimateNumKeys(uint64_t* value, DBImpl* db, } bool InternalStats::HandleNumSnapshots(uint64_t* value, DBImpl* db, - Version* version) { + Version* /*version*/) { *value = db->snapshots().count(); return true; } bool InternalStats::HandleOldestSnapshotTime(uint64_t* value, DBImpl* db, - Version* version) { + Version* /*version*/) { *value = static_cast(db->snapshots().GetOldestSnapshotTime()); return true; } -bool InternalStats::HandleNumLiveVersions(uint64_t* value, DBImpl* db, - Version* version) { +bool InternalStats::HandleNumLiveVersions(uint64_t* value, DBImpl* /*db*/, + Version* /*version*/) { *value = cfd_->GetNumLiveVersions(); return true; } -bool InternalStats::HandleCurrentSuperVersionNumber(uint64_t* value, DBImpl* db, - Version* version) { +bool InternalStats::HandleCurrentSuperVersionNumber(uint64_t* value, + DBImpl* /*db*/, + Version* /*version*/) { *value = cfd_->GetSuperVersionNumber(); return true; } bool InternalStats::HandleIsFileDeletionsEnabled(uint64_t* value, DBImpl* db, - Version* version) { + Version* /*version*/) { *value = db->IsFileDeletionsEnabled(); return true; } -bool InternalStats::HandleBaseLevel(uint64_t* value, DBImpl* db, - Version* version) { +bool InternalStats::HandleBaseLevel(uint64_t* value, DBImpl* /*db*/, + Version* /*version*/) { const auto* vstorage = cfd_->current()->storage_info(); *value = vstorage->base_level(); return true; @@ -751,34 +757,35 @@ bool InternalStats::HandleLiveSstFilesSize(uint64_t* value, DBImpl* /*db*/, } bool InternalStats::HandleEstimatePendingCompactionBytes(uint64_t* value, - DBImpl* db, - Version* version) { + DBImpl* /*db*/, + Version* /*version*/) { const auto* vstorage = cfd_->current()->storage_info(); *value = vstorage->estimated_compaction_needed_bytes(); return true; } -bool InternalStats::HandleEstimateTableReadersMem(uint64_t* value, DBImpl* db, +bool InternalStats::HandleEstimateTableReadersMem(uint64_t* value, + DBImpl* /*db*/, Version* version) { *value = (version == nullptr) ? 0 : version->GetMemoryUsageByTableReaders(); return true; } -bool InternalStats::HandleEstimateLiveDataSize(uint64_t* value, DBImpl* db, - Version* version) { +bool InternalStats::HandleEstimateLiveDataSize(uint64_t* value, DBImpl* /*db*/, + Version* /*version*/) { const auto* vstorage = cfd_->current()->storage_info(); *value = vstorage->EstimateLiveDataSize(); return true; } bool InternalStats::HandleMinLogNumberToKeep(uint64_t* value, DBImpl* db, - Version* version) { + Version* /*version*/) { *value = db->MinLogNumberToKeep(); return true; } bool InternalStats::HandleActualDelayedWriteRate(uint64_t* value, DBImpl* db, - Version* version) { + Version* /*version*/) { const WriteController& wc = db->write_controller(); if (!wc.NeedsDelay()) { *value = 0; @@ -789,7 +796,7 @@ bool InternalStats::HandleActualDelayedWriteRate(uint64_t* value, DBImpl* db, } bool InternalStats::HandleIsWriteStopped(uint64_t* value, DBImpl* db, - Version* version) { + Version* /*version*/) { *value = db->write_controller().IsStopped() ? 1 : 0; return true; } diff --git a/db/listener_test.cc b/db/listener_test.cc index 86646fdde..204c9216e 100644 --- a/db/listener_test.cc +++ b/db/listener_test.cc @@ -46,11 +46,11 @@ class EventListenerTest : public DBTestBase { }; struct TestPropertiesCollector : public rocksdb::TablePropertiesCollector { - virtual rocksdb::Status AddUserKey(const rocksdb::Slice& key, - const rocksdb::Slice& value, - rocksdb::EntryType type, - rocksdb::SequenceNumber seq, - uint64_t file_size) override { + virtual rocksdb::Status AddUserKey(const rocksdb::Slice& /*key*/, + const rocksdb::Slice& /*value*/, + rocksdb::EntryType /*type*/, + rocksdb::SequenceNumber /*seq*/, + uint64_t /*file_size*/) override { return Status::OK(); } virtual rocksdb::Status Finish( @@ -73,7 +73,7 @@ struct TestPropertiesCollector : public rocksdb::TablePropertiesCollector { class TestPropertiesCollectorFactory : public TablePropertiesCollectorFactory { public: virtual TablePropertiesCollector* CreateTablePropertiesCollector( - TablePropertiesCollectorFactory::Context context) override { + TablePropertiesCollectorFactory::Context /*context*/) override { return new TestPropertiesCollector; } const char* Name() const override { return "TestTablePropertiesCollector"; } @@ -425,7 +425,7 @@ TEST_F(EventListenerTest, DisableBGCompaction) { class TestCompactionReasonListener : public EventListener { public: - void OnCompactionCompleted(DB* db, const CompactionJobInfo& ci) override { + void OnCompactionCompleted(DB* /*db*/, const CompactionJobInfo& ci) override { std::lock_guard lock(mutex_); compaction_reasons_.push_back(ci.compaction_reason); } @@ -807,7 +807,8 @@ class BackgroundErrorListener : public EventListener { public: BackgroundErrorListener(SpecialEnv* env) : env_(env), counter_(0) {} - void OnBackgroundError(BackgroundErrorReason reason, Status* bg_error) override { + void OnBackgroundError(BackgroundErrorReason /*reason*/, + Status* bg_error) override { if (counter_ == 0) { // suppress the first error and disable write-dropping such that a retry // can succeed. diff --git a/db/manual_compaction_test.cc b/db/manual_compaction_test.cc index 039b9080e..f31a50b81 100644 --- a/db/manual_compaction_test.cc +++ b/db/manual_compaction_test.cc @@ -46,9 +46,9 @@ class DestroyAllCompactionFilter : public CompactionFilter { public: DestroyAllCompactionFilter() {} - virtual bool Filter(int level, const Slice& key, const Slice& existing_value, - std::string* new_value, - bool* value_changed) const override { + virtual bool Filter(int /*level*/, const Slice& /*key*/, + const Slice& existing_value, std::string* /*new_value*/, + bool* /*value_changed*/) const override { return existing_value.ToString() == "destroy"; } diff --git a/db/memtable.cc b/db/memtable.cc index 6cf4c2a03..384275c3d 100644 --- a/db/memtable.cc +++ b/db/memtable.cc @@ -236,7 +236,7 @@ int MemTable::KeyComparator::operator()(const char* prefix_len_key, return comparator.CompareKeySeq(a, key); } -void MemTableRep::InsertConcurrently(KeyHandle handle) { +void MemTableRep::InsertConcurrently(KeyHandle /*handle*/) { #ifndef ROCKSDB_LITE throw std::runtime_error("concurrent insert not supported"); #else diff --git a/db/memtable_list.cc b/db/memtable_list.cc index a09a118b9..e3cd64cfe 100644 --- a/db/memtable_list.cc +++ b/db/memtable_list.cc @@ -154,7 +154,7 @@ bool MemTableListVersion::GetFromList( } Status MemTableListVersion::AddRangeTombstoneIterators( - const ReadOptions& read_opts, Arena* arena, + const ReadOptions& read_opts, Arena* /*arena*/, RangeDelAggregator* range_del_agg) { assert(range_del_agg != nullptr); for (auto& m : memlist_) { @@ -300,7 +300,7 @@ void MemTableList::PickMemtablesToFlush(autovector* ret) { } void MemTableList::RollbackMemtableFlush(const autovector& mems, - uint64_t file_number) { + uint64_t /*file_number*/) { AutoThreadOperationStageUpdater stage_updater( ThreadStatus::STAGE_MEMTABLE_ROLLBACK); assert(!mems.empty()); diff --git a/db/merge_test.cc b/db/merge_test.cc index b6582b7a5..c1b0cbfae 100644 --- a/db/merge_test.cc +++ b/db/merge_test.cc @@ -504,7 +504,7 @@ void runTest(int argc, const std::string& dbname, const bool use_ttl = false) { } } // namespace -int main(int argc, char *argv[]) { +int main(int argc, char* /*argv*/ []) { //TODO: Make this test like a general rocksdb unit-test rocksdb::port::InstallStackTraceHandler(); runTest(argc, test::TmpDir() + "/merge_testdb"); diff --git a/db/plain_table_db_test.cc b/db/plain_table_db_test.cc index 0b60332e5..8fae9746d 100644 --- a/db/plain_table_db_test.cc +++ b/db/plain_table_db_test.cc @@ -327,7 +327,7 @@ class TestPlainTableFactory : public PlainTableFactory { const TableReaderOptions& table_reader_options, unique_ptr&& file, uint64_t file_size, unique_ptr* table, - bool prefetch_index_and_filter_in_cache) const override { + bool /*prefetch_index_and_filter_in_cache*/) const override { TableProperties* props = nullptr; auto s = ReadTableProperties(file.get(), file_size, kPlainTableMagicNumber, diff --git a/db/prefix_test.cc b/db/prefix_test.cc index c3dfdea2e..398d31893 100644 --- a/db/prefix_test.cc +++ b/db/prefix_test.cc @@ -126,10 +126,10 @@ class TestKeyComparator : public Comparator { return "TestKeyComparator"; } - virtual void FindShortestSeparator(std::string* start, - const Slice& limit) const override {} + virtual void FindShortestSeparator(std::string* /*start*/, + const Slice& /*limit*/) const override {} - virtual void FindShortSuccessor(std::string* key) const override {} + virtual void FindShortSuccessor(std::string* /*key*/) const override {} }; namespace { diff --git a/db/snapshot_checker.h b/db/snapshot_checker.h index 8a8738a5a..3bc8bc3c5 100644 --- a/db/snapshot_checker.h +++ b/db/snapshot_checker.h @@ -19,8 +19,8 @@ class SnapshotChecker { class DisableGCSnapshotChecker : public SnapshotChecker { public: virtual ~DisableGCSnapshotChecker() {} - virtual bool IsInSnapshot(SequenceNumber sequence, - SequenceNumber snapshot_sequence) const { + virtual bool IsInSnapshot(SequenceNumber /*sequence*/, + SequenceNumber /*snapshot_sequence*/) const { // By returning false, we prevent all the values from being GCed return false; } diff --git a/db/table_cache.cc b/db/table_cache.cc index 56b8272d4..a4f2b2ceb 100644 --- a/db/table_cache.cc +++ b/db/table_cache.cc @@ -30,7 +30,7 @@ namespace rocksdb { namespace { template -static void DeleteEntry(const Slice& key, void* value) { +static void DeleteEntry(const Slice& /*key*/, void* value) { T* typed_value = reinterpret_cast(value); delete typed_value; } @@ -41,7 +41,7 @@ static void UnrefEntry(void* arg1, void* arg2) { cache->Release(h); } -static void DeleteTableReader(void* arg1, void* arg2) { +static void DeleteTableReader(void* arg1, void* /*arg2*/) { TableReader* table_reader = reinterpret_cast(arg1); delete table_reader; } diff --git a/db/table_properties_collector.cc b/db/table_properties_collector.cc index fc27844b8..084cf139d 100644 --- a/db/table_properties_collector.cc +++ b/db/table_properties_collector.cc @@ -12,8 +12,8 @@ namespace rocksdb { Status InternalKeyPropertiesCollector::InternalAdd(const Slice& key, - const Slice& value, - uint64_t file_size) { + const Slice& /*value*/, + uint64_t /*file_size*/) { ParsedInternalKey ikey; if (!ParseInternalKey(key, &ikey)) { return Status::InvalidArgument("Invalid internal key"); diff --git a/db/table_properties_collector.h b/db/table_properties_collector.h index d8cd75689..7216ec319 100644 --- a/db/table_properties_collector.h +++ b/db/table_properties_collector.h @@ -73,7 +73,7 @@ class InternalKeyPropertiesCollectorFactory : public IntTblPropCollectorFactory { public: virtual IntTblPropCollector* CreateIntTblPropCollector( - uint32_t column_family_id) override { + uint32_t /*column_family_id*/) override { return new InternalKeyPropertiesCollector(); } diff --git a/db/table_properties_collector_test.cc b/db/table_properties_collector_test.cc index 66c66c025..bf382b4fd 100644 --- a/db/table_properties_collector_test.cc +++ b/db/table_properties_collector_test.cc @@ -82,8 +82,9 @@ class RegularKeysStartWithA: public TablePropertiesCollector { return Status::OK(); } - Status AddUserKey(const Slice& user_key, const Slice& value, EntryType type, - SequenceNumber seq, uint64_t file_size) override { + Status AddUserKey(const Slice& user_key, const Slice& /*value*/, + EntryType type, SequenceNumber /*seq*/, + uint64_t file_size) override { // simply asssume all user keys are not empty. if (user_key.data()[0] == 'A') { ++count_; @@ -133,7 +134,7 @@ class RegularKeysStartWithABackwardCompatible return Status::OK(); } - Status Add(const Slice& user_key, const Slice& value) override { + Status Add(const Slice& user_key, const Slice& /*value*/) override { // simply asssume all user keys are not empty. if (user_key.data()[0] == 'A') { ++count_; @@ -161,8 +162,8 @@ class RegularKeysStartWithAInternal : public IntTblPropCollector { return Status::OK(); } - Status InternalAdd(const Slice& user_key, const Slice& value, - uint64_t file_size) override { + Status InternalAdd(const Slice& user_key, const Slice& /*value*/, + uint64_t /*file_size*/) override { // simply asssume all user keys are not empty. if (user_key.data()[0] == 'A') { ++count_; @@ -193,7 +194,7 @@ class RegularKeysStartWithAFactory : public IntTblPropCollectorFactory, } } virtual IntTblPropCollector* CreateIntTblPropCollector( - uint32_t column_family_id) override { + uint32_t /*column_family_id*/) override { return new RegularKeysStartWithAInternal(); } const char* Name() const override { return "RegularKeysStartWithA"; } @@ -203,7 +204,7 @@ class RegularKeysStartWithAFactory : public IntTblPropCollectorFactory, class FlushBlockEveryThreePolicy : public FlushBlockPolicy { public: - virtual bool Update(const Slice& key, const Slice& value) override { + virtual bool Update(const Slice& /*key*/, const Slice& /*value*/) override { return (++count_ % 3U == 0); } @@ -220,8 +221,8 @@ class FlushBlockEveryThreePolicyFactory : public FlushBlockPolicyFactory { } FlushBlockPolicy* NewFlushBlockPolicy( - const BlockBasedTableOptions& table_options, - const BlockBuilder& data_block_builder) const override { + const BlockBasedTableOptions& /*table_options*/, + const BlockBuilder& /*data_block_builder*/) const override { return new FlushBlockEveryThreePolicy; } }; diff --git a/db/transaction_log_impl.cc b/db/transaction_log_impl.cc index 1dbba7de5..011673892 100644 --- a/db/transaction_log_impl.cc +++ b/db/transaction_log_impl.cc @@ -269,16 +269,18 @@ void TransactionLogIteratorImpl::UpdateCurrentWriteBatch(const Slice& record) { return Status::OK(); } - Status PutCF(uint32_t cf, const Slice& key, const Slice& val) override { + Status PutCF(uint32_t /*cf*/, const Slice& /*key*/, + const Slice& /*val*/) override { return Status::OK(); } - Status DeleteCF(uint32_t cf, const Slice& key) override { + Status DeleteCF(uint32_t /*cf*/, const Slice& /*key*/) override { return Status::OK(); } - Status SingleDeleteCF(uint32_t cf, const Slice& key) override { + Status SingleDeleteCF(uint32_t /*cf*/, const Slice& /*key*/) override { return Status::OK(); } - Status MergeCF(uint32_t cf, const Slice& key, const Slice& val) override { + Status MergeCF(uint32_t /*cf*/, const Slice& /*key*/, + const Slice& /*val*/) override { return Status::OK(); } Status MarkBeginPrepare() override { return Status::OK(); } diff --git a/db/version_builder.cc b/db/version_builder.cc index 00972d4e5..68a62fd51 100644 --- a/db/version_builder.cc +++ b/db/version_builder.cc @@ -199,7 +199,7 @@ class VersionBuilder::Rep { } } - void CheckConsistencyForDeletes(VersionEdit* edit, uint64_t number, + void CheckConsistencyForDeletes(VersionEdit* /*edit*/, uint64_t number, int level) { #ifdef NDEBUG if (!base_vstorage_->force_consistency_checks()) { diff --git a/db/version_edit.cc b/db/version_edit.cc index b01f7bbdf..ebfc10584 100644 --- a/db/version_edit.cc +++ b/db/version_edit.cc @@ -198,7 +198,7 @@ static bool GetInternalKey(Slice* input, InternalKey* dst) { } } -bool VersionEdit::GetLevel(Slice* input, int* level, const char** msg) { +bool VersionEdit::GetLevel(Slice* input, int* level, const char** /*msg*/) { uint32_t v; if (GetVarint32(input, &v)) { *level = v; diff --git a/db/version_set.cc b/db/version_set.cc index 2b6c4c629..b2ad4f817 100644 --- a/db/version_set.cc +++ b/db/version_set.cc @@ -2907,7 +2907,7 @@ void VersionSet::LogAndApplyCFHelper(VersionEdit* edit) { } void VersionSet::LogAndApplyHelper(ColumnFamilyData* cfd, - VersionBuilder* builder, Version* v, + VersionBuilder* builder, Version* /*v*/, VersionEdit* edit, InstrumentedMutex* mu) { mu->AssertHeld(); assert(!edit->IsColumnFamilyManipulation()); diff --git a/db/version_set.h b/db/version_set.h index 688bf1183..a080bb1e7 100644 --- a/db/version_set.h +++ b/db/version_set.h @@ -872,7 +872,7 @@ class VersionSet { struct LogReporter : public log::Reader::Reporter { Status* status; - virtual void Corruption(size_t bytes, const Status& s) override { + virtual void Corruption(size_t /*bytes*/, const Status& s) override { if (this->status->ok()) *this->status = s; } }; diff --git a/db/version_set_test.cc b/db/version_set_test.cc index 625d45922..090e074cf 100644 --- a/db/version_set_test.cc +++ b/db/version_set_test.cc @@ -76,7 +76,9 @@ class CountingLogger : public Logger { public: CountingLogger() : log_count(0) {} using Logger::Logv; - virtual void Logv(const char* format, va_list ap) override { log_count++; } + virtual void Logv(const char* /*format*/, va_list /*ap*/) override { + log_count++; + } int log_count; }; diff --git a/db/wal_manager_test.cc b/db/wal_manager_test.cc index fe54b84cb..224defe26 100644 --- a/db/wal_manager_test.cc +++ b/db/wal_manager_test.cc @@ -73,7 +73,7 @@ class WalManagerTest : public testing::Test { } // NOT thread safe - void RollTheLog(bool archived) { + void RollTheLog(bool /*archived*/) { current_log_number_++; std::string fname = ArchivedLogFileName(dbname_, current_log_number_); unique_ptr file; diff --git a/db/write_batch.cc b/db/write_batch.cc index 4e257b319..c01649b87 100644 --- a/db/write_batch.cc +++ b/db/write_batch.cc @@ -186,7 +186,7 @@ WriteBatch::~WriteBatch() { delete save_points_; } WriteBatch::Handler::~Handler() { } -void WriteBatch::Handler::LogData(const Slice& blob) { +void WriteBatch::Handler::LogData(const Slice& /*blob*/) { // If the user has not specified something to do with blobs, then we ignore // them. } @@ -569,7 +569,7 @@ void WriteBatchInternal::SetSequence(WriteBatch* b, SequenceNumber seq) { EncodeFixed64(&b->rep_[0], seq); } -size_t WriteBatchInternal::GetFirstOffset(WriteBatch* b) { +size_t WriteBatchInternal::GetFirstOffset(WriteBatch* /*b*/) { return WriteBatchInternal::kHeader; } @@ -1228,7 +1228,7 @@ class MemTableInserter : public WriteBatch::Handler { return PutCFImpl(column_family_id, key, value, kTypeValue); } - Status DeleteImpl(uint32_t column_family_id, const Slice& key, + Status DeleteImpl(uint32_t /*column_family_id*/, const Slice& key, const Slice& value, ValueType delete_type) { Status ret_status; MemTable* mem = cf_mems_->GetMemTable(); diff --git a/db/write_batch_test.cc b/db/write_batch_test.cc index 4511f015b..cf2a121e4 100644 --- a/db/write_batch_test.cc +++ b/db/write_batch_test.cc @@ -437,7 +437,7 @@ TEST_F(WriteBatchTest, DISABLED_ManyUpdates) { struct NoopHandler : public WriteBatch::Handler { uint32_t num_seen = 0; char expected_char = 'A'; - virtual Status PutCF(uint32_t column_family_id, const Slice& key, + virtual Status PutCF(uint32_t /*column_family_id*/, const Slice& key, const Slice& value) override { EXPECT_EQ(kKeyValueSize, key.size()); EXPECT_EQ(kKeyValueSize, value.size()); @@ -452,22 +452,22 @@ TEST_F(WriteBatchTest, DISABLED_ManyUpdates) { ++num_seen; return Status::OK(); } - virtual Status DeleteCF(uint32_t column_family_id, - const Slice& key) override { + virtual Status DeleteCF(uint32_t /*column_family_id*/, + const Slice& /*key*/) override { ADD_FAILURE(); return Status::OK(); } - virtual Status SingleDeleteCF(uint32_t column_family_id, - const Slice& key) override { + virtual Status SingleDeleteCF(uint32_t /*column_family_id*/, + const Slice& /*key*/) override { ADD_FAILURE(); return Status::OK(); } - virtual Status MergeCF(uint32_t column_family_id, const Slice& key, - const Slice& value) override { + virtual Status MergeCF(uint32_t /*column_family_id*/, const Slice& /*key*/, + const Slice& /*value*/) override { ADD_FAILURE(); return Status::OK(); } - virtual void LogData(const Slice& blob) override { ADD_FAILURE(); } + virtual void LogData(const Slice& /*blob*/) override { ADD_FAILURE(); } virtual bool Continue() override { return num_seen < kNumUpdates; } } handler; @@ -492,7 +492,7 @@ TEST_F(WriteBatchTest, DISABLED_LargeKeyValue) { struct NoopHandler : public WriteBatch::Handler { int num_seen = 0; - virtual Status PutCF(uint32_t column_family_id, const Slice& key, + virtual Status PutCF(uint32_t /*column_family_id*/, const Slice& key, const Slice& value) override { EXPECT_EQ(kKeyValueSize, key.size()); EXPECT_EQ(kKeyValueSize, value.size()); @@ -503,22 +503,22 @@ TEST_F(WriteBatchTest, DISABLED_LargeKeyValue) { ++num_seen; return Status::OK(); } - virtual Status DeleteCF(uint32_t column_family_id, - const Slice& key) override { + virtual Status DeleteCF(uint32_t /*column_family_id*/, + const Slice& /*key*/) override { ADD_FAILURE(); return Status::OK(); } - virtual Status SingleDeleteCF(uint32_t column_family_id, - const Slice& key) override { + virtual Status SingleDeleteCF(uint32_t /*column_family_id*/, + const Slice& /*key*/) override { ADD_FAILURE(); return Status::OK(); } - virtual Status MergeCF(uint32_t column_family_id, const Slice& key, - const Slice& value) override { + virtual Status MergeCF(uint32_t /*column_family_id*/, const Slice& /*key*/, + const Slice& /*value*/) override { ADD_FAILURE(); return Status::OK(); } - virtual void LogData(const Slice& blob) override { ADD_FAILURE(); } + virtual void LogData(const Slice& /*blob*/) override { ADD_FAILURE(); } virtual bool Continue() override { return num_seen < 2; } } handler; diff --git a/db/write_callback_test.cc b/db/write_callback_test.cc index 7d04d5017..c4f0e35dc 100644 --- a/db/write_callback_test.cc +++ b/db/write_callback_test.cc @@ -54,9 +54,7 @@ class WriteCallbackTestWriteCallback1 : public WriteCallback { class WriteCallbackTestWriteCallback2 : public WriteCallback { public: - Status Callback(DB *db) override { - return Status::Busy(); - } + Status Callback(DB* /*db*/) override { return Status::Busy(); } bool AllowWriteBatching() override { return true; } }; @@ -74,7 +72,7 @@ class MockWriteCallback : public WriteCallback { was_called_.store(other.was_called_.load()); } - Status Callback(DB* db) override { + Status Callback(DB* /*db*/) override { was_called_.store(true); if (should_fail_) { return Status::Busy(); diff --git a/db/write_thread.cc b/db/write_thread.cc index e115ba539..a44f028ce 100644 --- a/db/write_thread.cc +++ b/db/write_thread.cc @@ -456,7 +456,8 @@ void WriteThread::EnterAsMemTableWriter(Writer* leader, last_writer->sequence + WriteBatchInternal::Count(last_writer->batch) - 1; } -void WriteThread::ExitAsMemTableWriter(Writer* self, WriteGroup& write_group) { +void WriteThread::ExitAsMemTableWriter(Writer* /*self*/, + WriteGroup& write_group) { Writer* leader = write_group.leader; Writer* last_writer = write_group.last_writer; diff --git a/env/env_encryption.cc b/env/env_encryption.cc index 6b688a660..ff7f08107 100644 --- a/env/env_encryption.cc +++ b/env/env_encryption.cc @@ -844,7 +844,9 @@ static void decodeCTRParameters(const char *prefix, size_t blockSize, uint64_t & // CreateNewPrefix initialized an allocated block of prefix memory // for a new file. -Status CTREncryptionProvider::CreateNewPrefix(const std::string& fname, char *prefix, size_t prefixLength) { +Status CTREncryptionProvider::CreateNewPrefix(const std::string& /*fname*/, + char* prefix, + size_t prefixLength) { // Create & seed rnd. Random rnd((uint32_t)Env::Default()->NowMicros()); // Fill entire prefix block with random values. @@ -873,7 +875,9 @@ Status CTREncryptionProvider::CreateNewPrefix(const std::string& fname, char *pr // in plain text. // Returns the amount of space (starting from the start of the prefix) // that has been initialized. -size_t CTREncryptionProvider::PopulateSecretPrefixPart(char *prefix, size_t prefixLength, size_t blockSize) { +size_t CTREncryptionProvider::PopulateSecretPrefixPart(char* /*prefix*/, + size_t /*prefixLength*/, + size_t /*blockSize*/) { // Nothing to do here, put in custom data in override when needed. return 0; } @@ -898,8 +902,10 @@ Status CTREncryptionProvider::CreateCipherStream(const std::string& fname, const // CreateCipherStreamFromPrefix creates a block access cipher stream for a file given // given name and options. The given prefix is already decrypted. -Status CTREncryptionProvider::CreateCipherStreamFromPrefix(const std::string& fname, const EnvOptions& options, - uint64_t initialCounter, const Slice& iv, const Slice& prefix, unique_ptr* result) { +Status CTREncryptionProvider::CreateCipherStreamFromPrefix( + const std::string& /*fname*/, const EnvOptions& /*options*/, + uint64_t initialCounter, const Slice& iv, const Slice& /*prefix*/, + unique_ptr* result) { (*result) = unique_ptr(new CTRCipherStream(cipher_, iv.data(), initialCounter)); return Status::OK(); } diff --git a/env/env_hdfs.cc b/env/env_hdfs.cc index c29eb7a16..c686d0824 100644 --- a/env/env_hdfs.cc +++ b/env/env_hdfs.cc @@ -611,13 +611,13 @@ Status NewHdfsEnv(Env** hdfs_env, const std::string& fsname) { // dummy placeholders used when HDFS is not available namespace rocksdb { - Status HdfsEnv::NewSequentialFile(const std::string& fname, - unique_ptr* result, - const EnvOptions& options) { - return Status::NotSupported("Not compiled with hdfs support"); +Status HdfsEnv::NewSequentialFile(const std::string& /*fname*/, + unique_ptr* /*result*/, + const EnvOptions& /*options*/) { + return Status::NotSupported("Not compiled with hdfs support"); } - Status NewHdfsEnv(Env** hdfs_env, const std::string& fsname) { + Status NewHdfsEnv(Env** /*hdfs_env*/, const std::string& /*fsname*/) { return Status::NotSupported("Not compiled with hdfs support"); } } diff --git a/env/env_test.cc b/env/env_test.cc index 2360a5e8b..1bf613995 100644 --- a/env/env_test.cc +++ b/env/env_test.cc @@ -1255,33 +1255,36 @@ TEST_P(EnvPosixTestWithParam, WritableFileWrapper) { inc(0); } - Status Append(const Slice& data) override { inc(1); return Status::OK(); } - Status Truncate(uint64_t size) override { return Status::OK(); } + Status Append(const Slice& /*data*/) override { + inc(1); + return Status::OK(); + } + Status Truncate(uint64_t /*size*/) override { return Status::OK(); } Status Close() override { inc(2); return Status::OK(); } Status Flush() override { inc(3); return Status::OK(); } Status Sync() override { inc(4); return Status::OK(); } Status Fsync() override { inc(5); return Status::OK(); } - void SetIOPriority(Env::IOPriority pri) override { inc(6); } + void SetIOPriority(Env::IOPriority /*pri*/) override { inc(6); } uint64_t GetFileSize() override { inc(7); return 0; } - void GetPreallocationStatus(size_t* block_size, - size_t* last_allocated_block) override { + void GetPreallocationStatus(size_t* /*block_size*/, + size_t* /*last_allocated_block*/) override { inc(8); } - size_t GetUniqueId(char* id, size_t max_size) const override { + size_t GetUniqueId(char* /*id*/, size_t /*max_size*/) const override { inc(9); return 0; } - Status InvalidateCache(size_t offset, size_t length) override { + Status InvalidateCache(size_t /*offset*/, size_t /*length*/) override { inc(10); return Status::OK(); } protected: - Status Allocate(uint64_t offset, uint64_t len) override { + Status Allocate(uint64_t /*offset*/, uint64_t /*len*/) override { inc(11); return Status::OK(); } - Status RangeSync(uint64_t offset, uint64_t nbytes) override { + Status RangeSync(uint64_t /*offset*/, uint64_t /*nbytes*/) override { inc(12); return Status::OK(); } @@ -1489,8 +1492,9 @@ class TestEnv : public EnvWrapper { CloseHelper(); } } - virtual void Logv(const char *format, va_list ap) override { }; - protected: + virtual void Logv(const char* /*format*/, va_list /*ap*/) override{}; + + protected: virtual Status CloseImpl() override { return CloseHelper(); } @@ -1506,7 +1510,7 @@ class TestEnv : public EnvWrapper { int GetCloseCount() { return close_count; } - virtual Status NewLogger(const std::string& fname, + virtual Status NewLogger(const std::string& /*fname*/, shared_ptr* result) { result->reset(new TestLogger(this)); return Status::OK(); diff --git a/env/io_posix.cc b/env/io_posix.cc index e2190670a..b4f06c228 100644 --- a/env/io_posix.cc +++ b/env/io_posix.cc @@ -448,7 +448,7 @@ PosixMmapReadableFile::~PosixMmapReadableFile() { } Status PosixMmapReadableFile::Read(uint64_t offset, size_t n, Slice* result, - char* scratch) const { + char* /*scratch*/) const { Status s; if (offset > length_) { *result = Slice(); @@ -941,7 +941,7 @@ size_t PosixWritableFile::GetUniqueId(char* id, size_t max_size) const { */ PosixRandomRWFile::PosixRandomRWFile(const std::string& fname, int fd, - const EnvOptions& options) + const EnvOptions& /*options*/) : filename_(fname), fd_(fd) {} PosixRandomRWFile::~PosixRandomRWFile() { diff --git a/env/io_posix.h b/env/io_posix.h index 804864cd1..f29a159ae 100644 --- a/env/io_posix.h +++ b/env/io_posix.h @@ -202,7 +202,7 @@ class PosixMmapFile : public WritableFile { // Means Close() will properly take care of truncate // and it does not need any additional information - virtual Status Truncate(uint64_t size) override { return Status::OK(); } + virtual Status Truncate(uint64_t /*size*/) override { return Status::OK(); } virtual Status Close() override; virtual Status Append(const Slice& data) override; virtual Status Flush() override; diff --git a/env/mock_env.cc b/env/mock_env.cc index 4e46b467f..30aaeadb7 100644 --- a/env/mock_env.cc +++ b/env/mock_env.cc @@ -447,8 +447,8 @@ MockEnv::~MockEnv() { // Partial implementation of the Env interface. Status MockEnv::NewSequentialFile(const std::string& fname, - unique_ptr* result, - const EnvOptions& soptions) { + unique_ptr* result, + const EnvOptions& /*soptions*/) { auto fn = NormalizePath(fname); MutexLock lock(&mutex_); if (file_map_.find(fn) == file_map_.end()) { @@ -464,8 +464,8 @@ Status MockEnv::NewSequentialFile(const std::string& fname, } Status MockEnv::NewRandomAccessFile(const std::string& fname, - unique_ptr* result, - const EnvOptions& soptions) { + unique_ptr* result, + const EnvOptions& /*soptions*/) { auto fn = NormalizePath(fname); MutexLock lock(&mutex_); if (file_map_.find(fn) == file_map_.end()) { @@ -482,7 +482,7 @@ Status MockEnv::NewRandomAccessFile(const std::string& fname, Status MockEnv::NewRandomRWFile(const std::string& fname, unique_ptr* result, - const EnvOptions& soptions) { + const EnvOptions& /*soptions*/) { auto fn = NormalizePath(fname); MutexLock lock(&mutex_); if (file_map_.find(fn) == file_map_.end()) { @@ -525,8 +525,8 @@ Status MockEnv::NewWritableFile(const std::string& fname, return Status::OK(); } -Status MockEnv::NewDirectory(const std::string& name, - unique_ptr* result) { +Status MockEnv::NewDirectory(const std::string& /*name*/, + unique_ptr* result) { result->reset(new MockEnvDirectory()); return Status::OK(); } diff --git a/hdfs/env_hdfs.h b/hdfs/env_hdfs.h index 3a62bc8cb..2ed6ba6d8 100644 --- a/hdfs/env_hdfs.h +++ b/hdfs/env_hdfs.h @@ -245,7 +245,7 @@ static const Status notsup; class HdfsEnv : public Env { public: - explicit HdfsEnv(const std::string& fsname) { + explicit HdfsEnv(const std::string& /*fsname*/) { fprintf(stderr, "You have not build rocksdb with HDFS support\n"); fprintf(stderr, "Please see hdfs/README for details\n"); abort(); @@ -258,112 +258,125 @@ class HdfsEnv : public Env { unique_ptr* result, const EnvOptions& options) override; - virtual Status NewRandomAccessFile(const std::string& fname, - unique_ptr* result, - const EnvOptions& options) override { + virtual Status NewRandomAccessFile(const std::string& /*fname*/, + unique_ptr* /*result*/, + const EnvOptions& /*options*/) override { return notsup; } - virtual Status NewWritableFile(const std::string& fname, - unique_ptr* result, - const EnvOptions& options) override { + virtual Status NewWritableFile(const std::string& /*fname*/, + unique_ptr* /*result*/, + const EnvOptions& /*options*/) override { return notsup; } - virtual Status NewDirectory(const std::string& name, - unique_ptr* result) override { + virtual Status NewDirectory(const std::string& /*name*/, + unique_ptr* /*result*/) override { return notsup; } - virtual Status FileExists(const std::string& fname) override { + virtual Status FileExists(const std::string& /*fname*/) override { return notsup; } - virtual Status GetChildren(const std::string& path, - std::vector* result) override { + virtual Status GetChildren(const std::string& /*path*/, + std::vector* /*result*/) override { return notsup; } - virtual Status DeleteFile(const std::string& fname) override { + virtual Status DeleteFile(const std::string& /*fname*/) override { return notsup; } - virtual Status CreateDir(const std::string& name) override { return notsup; } - - virtual Status CreateDirIfMissing(const std::string& name) override { + virtual Status CreateDir(const std::string& /*name*/) override { return notsup; } - virtual Status DeleteDir(const std::string& name) override { return notsup; } - - virtual Status GetFileSize(const std::string& fname, - uint64_t* size) override { + virtual Status CreateDirIfMissing(const std::string& /*name*/) override { return notsup; } - virtual Status GetFileModificationTime(const std::string& fname, - uint64_t* time) override { + virtual Status DeleteDir(const std::string& /*name*/) override { return notsup; } - virtual Status RenameFile(const std::string& src, - const std::string& target) override { + virtual Status GetFileSize(const std::string& /*fname*/, + uint64_t* /*size*/) override { return notsup; } - virtual Status LinkFile(const std::string& src, - const std::string& target) override { + virtual Status GetFileModificationTime(const std::string& /*fname*/, + uint64_t* /*time*/) override { return notsup; } - virtual Status LockFile(const std::string& fname, FileLock** lock) override { + virtual Status RenameFile(const std::string& /*src*/, + const std::string& /*target*/) override { return notsup; } - virtual Status UnlockFile(FileLock* lock) override { return notsup; } - - virtual Status NewLogger(const std::string& fname, - shared_ptr* result) override { + virtual Status LinkFile(const std::string& /*src*/, + const std::string& /*target*/) override { return notsup; } - virtual void Schedule(void (*function)(void* arg), void* arg, - Priority pri = LOW, void* tag = nullptr, - void (*unschedFunction)(void* arg) = 0) override {} + virtual Status LockFile(const std::string& /*fname*/, + FileLock** /*lock*/) override { + return notsup; + } - virtual int UnSchedule(void* tag, Priority pri) override { return 0; } + virtual Status UnlockFile(FileLock* /*lock*/) override { return notsup; } - virtual void StartThread(void (*function)(void* arg), void* arg) override {} + virtual Status NewLogger(const std::string& /*fname*/, + shared_ptr* /*result*/) override { + return notsup; + } + + virtual void Schedule(void (*/*function*/)(void* arg), void* /*arg*/, + Priority /*pri*/ = LOW, void* /*tag*/ = nullptr, + void (*/*unschedFunction*/)(void* arg) = 0) override {} + + virtual int UnSchedule(void* /*tag*/, Priority /*pri*/) override { return 0; } + + virtual void StartThread(void (*/*function*/)(void* arg), + void* /*arg*/) override {} virtual void WaitForJoin() override {} virtual unsigned int GetThreadPoolQueueLen( - Priority pri = LOW) const override { + Priority /*pri*/ = LOW) const override { return 0; } - virtual Status GetTestDirectory(std::string* path) override { return notsup; } + virtual Status GetTestDirectory(std::string* /*path*/) override { + return notsup; + } virtual uint64_t NowMicros() override { return 0; } - virtual void SleepForMicroseconds(int micros) override {} + virtual void SleepForMicroseconds(int /*micros*/) override {} - virtual Status GetHostName(char* name, uint64_t len) override { + virtual Status GetHostName(char* /*name*/, uint64_t /*len*/) override { return notsup; } - virtual Status GetCurrentTime(int64_t* unix_time) override { return notsup; } - - virtual Status GetAbsolutePath(const std::string& db_path, - std::string* outputpath) override { + virtual Status GetCurrentTime(int64_t* /*unix_time*/) override { return notsup; } - virtual void SetBackgroundThreads(int number, Priority pri = LOW) override {} - virtual int GetBackgroundThreads(Priority pri = LOW) override { return 0; } - virtual void IncBackgroundThreadsIfNeeded(int number, Priority pri) override { + virtual Status GetAbsolutePath(const std::string& /*db_path*/, + std::string* /*outputpath*/) override { + return notsup; } - virtual std::string TimeToString(uint64_t number) override { return ""; } + + virtual void SetBackgroundThreads(int /*number*/, + Priority /*pri*/ = LOW) override {} + virtual int GetBackgroundThreads(Priority /*pri*/ = LOW) override { + return 0; + } + virtual void IncBackgroundThreadsIfNeeded(int /*number*/, + Priority /*pri*/) override {} + virtual std::string TimeToString(uint64_t /*number*/) override { return ""; } virtual uint64_t GetThreadID() const override { return 0; diff --git a/include/rocksdb/cache.h b/include/rocksdb/cache.h index c9efd5fcf..86dafe395 100644 --- a/include/rocksdb/cache.h +++ b/include/rocksdb/cache.h @@ -216,7 +216,8 @@ class Cache { // Mark the last inserted object as being a raw data block. This will be used // in tests. The default implementation does nothing. - virtual void TEST_mark_as_data_block(const Slice& key, size_t charge) {} + virtual void TEST_mark_as_data_block(const Slice& /*key*/, + size_t /*charge*/) {} private: // No copying allowed diff --git a/include/rocksdb/compaction_filter.h b/include/rocksdb/compaction_filter.h index 344b1001e..29b7e5077 100644 --- a/include/rocksdb/compaction_filter.h +++ b/include/rocksdb/compaction_filter.h @@ -94,8 +94,10 @@ class CompactionFilter { // be used by a single thread that is doing the compaction run, and this // call does not need to be thread-safe. However, multiple filters may be // in existence and operating concurrently. - virtual bool Filter(int level, const Slice& key, const Slice& existing_value, - std::string* new_value, bool* value_changed) const { + virtual bool Filter(int /*level*/, const Slice& /*key*/, + const Slice& /*existing_value*/, + std::string* /*new_value*/, + bool* /*value_changed*/) const { return false; } @@ -108,8 +110,8 @@ class CompactionFilter { // may not realize there is a write conflict and may allow a Transaction to // Commit that should have failed. Instead, it is better to implement any // Merge filtering inside the MergeOperator. - virtual bool FilterMergeOperand(int level, const Slice& key, - const Slice& operand) const { + virtual bool FilterMergeOperand(int /*level*/, const Slice& /*key*/, + const Slice& /*operand*/) const { return false; } @@ -154,7 +156,7 @@ class CompactionFilter { // MergeOperator. virtual Decision FilterV2(int level, const Slice& key, ValueType value_type, const Slice& existing_value, std::string* new_value, - std::string* skip_until) const { + std::string* /*skip_until*/) const { switch (value_type) { case ValueType::kValue: { bool value_changed = false; diff --git a/include/rocksdb/db.h b/include/rocksdb/db.h index 94f72786a..c9ba467bc 100644 --- a/include/rocksdb/db.h +++ b/include/rocksdb/db.h @@ -886,7 +886,7 @@ class DB { // Flush the WAL memory buffer to the file. If sync is true, it calls SyncWAL // afterwards. - virtual Status FlushWAL(bool sync) { + virtual Status FlushWAL(bool /*sync*/) { return Status::NotSupported("FlushWAL not implemented"); } // Sync the wal. Note that Write() followed by SyncWAL() is not exactly the @@ -1140,13 +1140,14 @@ class DB { ColumnFamilyHandle* column_family, const Range* range, std::size_t n, TablePropertiesCollection* props) = 0; - virtual Status SuggestCompactRange(ColumnFamilyHandle* column_family, - const Slice* begin, const Slice* end) { + virtual Status SuggestCompactRange(ColumnFamilyHandle* /*column_family*/, + const Slice* /*begin*/, + const Slice* /*end*/) { return Status::NotSupported("SuggestCompactRange() is not implemented."); } - virtual Status PromoteL0(ColumnFamilyHandle* column_family, - int target_level) { + virtual Status PromoteL0(ColumnFamilyHandle* /*column_family*/, + int /*target_level*/) { return Status::NotSupported("PromoteL0() is not implemented."); } diff --git a/include/rocksdb/env.h b/include/rocksdb/env.h index 3f0d4bf67..ef5702269 100644 --- a/include/rocksdb/env.h +++ b/include/rocksdb/env.h @@ -181,9 +181,9 @@ class Env { // returns non-OK. // // The returned file will only be accessed by one thread at a time. - virtual Status ReopenWritableFile(const std::string& fname, - unique_ptr* result, - const EnvOptions& options) { + virtual Status ReopenWritableFile(const std::string& /*fname*/, + unique_ptr* /*result*/, + const EnvOptions& /*options*/) { return Status::NotSupported(); } @@ -198,9 +198,9 @@ class Env { // *result and returns OK. On failure returns non-OK. // // The returned file will only be accessed by one thread at a time. - virtual Status NewRandomRWFile(const std::string& fname, - unique_ptr* result, - const EnvOptions& options) { + virtual Status NewRandomRWFile(const std::string& /*fname*/, + unique_ptr* /*result*/, + const EnvOptions& /*options*/) { return Status::NotSupported("RandomRWFile is not implemented in this Env"); } @@ -268,12 +268,13 @@ class Env { const std::string& target) = 0; // Hard Link file src to target. - virtual Status LinkFile(const std::string& src, const std::string& target) { + virtual Status LinkFile(const std::string& /*src*/, + const std::string& /*target*/) { return Status::NotSupported("LinkFile is not supported for this Env"); } - virtual Status AreFilesSame(const std::string& first, - const std::string& second, bool* res) { + virtual Status AreFilesSame(const std::string& /*first*/, + const std::string& /*second*/, bool* /*res*/) { return Status::NotSupported("AreFilesSame is not supported for this Env"); } @@ -324,7 +325,7 @@ class Env { // Arrange to remove jobs for given arg from the queue_ if they are not // already scheduled. Caller is expected to have exclusive lock on arg. - virtual int UnSchedule(void* arg, Priority pri) { return 0; } + virtual int UnSchedule(void* /*arg*/, Priority /*pri*/) { return 0; } // Start a new thread, invoking "function(arg)" within the new thread. // When "function(arg)" returns, the thread will be destroyed. @@ -334,7 +335,7 @@ class Env { virtual void WaitForJoin() {} // Get thread pool queue length for specific thread pool. - virtual unsigned int GetThreadPoolQueueLen(Priority pri = LOW) const { + virtual unsigned int GetThreadPoolQueueLen(Priority /*pri*/ = LOW) const { return 0; } @@ -388,7 +389,7 @@ class Env { virtual void IncBackgroundThreadsIfNeeded(int number, Priority pri) = 0; // Lower IO priority for threads from the specified pool. - virtual void LowerThreadPoolIOPriority(Priority pool = LOW) {} + virtual void LowerThreadPoolIOPriority(Priority /*pool*/ = LOW) {} // Converts seconds-since-Jan-01-1970 to a printable string virtual std::string TimeToString(uint64_t time) = 0; @@ -432,7 +433,7 @@ class Env { const ImmutableDBOptions& db_options) const; // Returns the status of all threads that belong to the current Env. - virtual Status GetThreadList(std::vector* thread_list) { + virtual Status GetThreadList(std::vector* /*thread_list*/) { return Status::NotSupported("Not supported."); } @@ -498,14 +499,14 @@ class SequentialFile { // Remove any kind of caching of data from the offset to offset+length // of this file. If the length is 0, then it refers to the end of file. // If the system is not caching the file contents, then this is a noop. - virtual Status InvalidateCache(size_t offset, size_t length) { + virtual Status InvalidateCache(size_t /*offset*/, size_t /*length*/) { return Status::NotSupported("InvalidateCache not supported."); } // Positioned Read for direct I/O // If Direct I/O enabled, offset, n, and scratch should be properly aligned - virtual Status PositionedRead(uint64_t offset, size_t n, Slice* result, - char* scratch) { + virtual Status PositionedRead(uint64_t /*offset*/, size_t /*n*/, + Slice* /*result*/, char* /*scratch*/) { return Status::NotSupported(); } }; @@ -531,7 +532,7 @@ class RandomAccessFile { char* scratch) const = 0; // Readahead the file starting from offset by n bytes for caching. - virtual Status Prefetch(uint64_t offset, size_t n) { + virtual Status Prefetch(uint64_t /*offset*/, size_t /*n*/) { return Status::OK(); } @@ -550,14 +551,14 @@ class RandomAccessFile { // a single varint. // // Note: these IDs are only valid for the duration of the process. - virtual size_t GetUniqueId(char* id, size_t max_size) const { + virtual size_t GetUniqueId(char* /*id*/, size_t /*max_size*/) const { return 0; // Default implementation to prevent issues with backwards // compatibility. }; enum AccessPattern { NORMAL, RANDOM, SEQUENTIAL, WILLNEED, DONTNEED }; - virtual void Hint(AccessPattern pattern) {} + virtual void Hint(AccessPattern /*pattern*/) {} // Indicates the upper layers if the current RandomAccessFile implementation // uses direct IO. @@ -570,7 +571,7 @@ class RandomAccessFile { // Remove any kind of caching of data from the offset to offset+length // of this file. If the length is 0, then it refers to the end of file. // If the system is not caching the file contents, then this is a noop. - virtual Status InvalidateCache(size_t offset, size_t length) { + virtual Status InvalidateCache(size_t /*offset*/, size_t /*length*/) { return Status::NotSupported("InvalidateCache not supported."); } }; @@ -621,9 +622,7 @@ class WritableFile { // before closing. It is not always possible to keep track of the file // size due to whole pages writes. The behavior is undefined if called // with other writes to follow. - virtual Status Truncate(uint64_t size) { - return Status::OK(); - } + virtual Status Truncate(uint64_t /*size*/) { return Status::OK(); } virtual Status Close() = 0; virtual Status Flush() = 0; virtual Status Sync() = 0; // sync data @@ -690,7 +689,7 @@ class WritableFile { } // For documentation, refer to RandomAccessFile::GetUniqueId() - virtual size_t GetUniqueId(char* id, size_t max_size) const { + virtual size_t GetUniqueId(char* /*id*/, size_t /*max_size*/) const { return 0; // Default implementation to prevent issues with backwards } @@ -698,7 +697,7 @@ class WritableFile { // of this file. If the length is 0, then it refers to the end of file. // If the system is not caching the file contents, then this is a noop. // This call has no effect on dirty pages in the cache. - virtual Status InvalidateCache(size_t offset, size_t length) { + virtual Status InvalidateCache(size_t /*offset*/, size_t /*length*/) { return Status::NotSupported("InvalidateCache not supported."); } @@ -708,7 +707,9 @@ class WritableFile { // This asks the OS to initiate flushing the cached data to disk, // without waiting for completion. // Default implementation does nothing. - virtual Status RangeSync(uint64_t offset, uint64_t nbytes) { return Status::OK(); } + virtual Status RangeSync(uint64_t /*offset*/, uint64_t /*nbytes*/) { + return Status::OK(); + } // PrepareWrite performs any necessary preparation for a write // before the write actually occurs. This allows for pre-allocation @@ -735,7 +736,7 @@ class WritableFile { } // Pre-allocates space for a file. - virtual Status Allocate(uint64_t offset, uint64_t len) { + virtual Status Allocate(uint64_t /*offset*/, uint64_t /*len*/) { return Status::OK(); } diff --git a/include/rocksdb/filter_policy.h b/include/rocksdb/filter_policy.h index 452d1913e..4706f38c3 100644 --- a/include/rocksdb/filter_policy.h +++ b/include/rocksdb/filter_policy.h @@ -50,7 +50,7 @@ class FilterBitsBuilder { #pragma warning(push) #pragma warning(disable : 4702) // unreachable code #endif - virtual int CalculateNumEntry(const uint32_t space) { + virtual int CalculateNumEntry(const uint32_t /*space*/) { #ifndef ROCKSDB_LITE throw std::runtime_error("CalculateNumEntry not Implemented"); #else @@ -122,7 +122,8 @@ class FilterPolicy { // Get the FilterBitsReader, which is ONLY used for full filter block // It contains interface to tell if key can be in filter // The input slice should NOT be deleted by FilterPolicy - virtual FilterBitsReader* GetFilterBitsReader(const Slice& contents) const { + virtual FilterBitsReader* GetFilterBitsReader( + const Slice& /*contents*/) const { return nullptr; } }; diff --git a/include/rocksdb/listener.h b/include/rocksdb/listener.h index d17d71c5f..80d20537f 100644 --- a/include/rocksdb/listener.h +++ b/include/rocksdb/listener.h @@ -355,8 +355,8 @@ class EventListener { // returns. Otherwise, RocksDB may be blocked. // @param handle is a pointer to the column family handle to be deleted // which will become a dangling pointer after the deletion. - virtual void OnColumnFamilyHandleDeletionStarted(ColumnFamilyHandle* handle) { - } + virtual void OnColumnFamilyHandleDeletionStarted( + ColumnFamilyHandle* /*handle*/) {} // A call-back function for RocksDB which will be called after an external // file is ingested using IngestExternalFile. diff --git a/include/rocksdb/memtablerep.h b/include/rocksdb/memtablerep.h index 1e8f41a45..f3f69a088 100644 --- a/include/rocksdb/memtablerep.h +++ b/include/rocksdb/memtablerep.h @@ -97,7 +97,7 @@ class MemTableRep { // // Currently only skip-list based memtable implement the interface. Other // implementations will fallback to Insert() by default. - virtual void InsertWithHint(KeyHandle handle, void** hint) { + virtual void InsertWithHint(KeyHandle handle, void** /*hint*/) { // Ignore the hint by default. Insert(handle); } @@ -149,8 +149,8 @@ class MemTableRep { virtual void Get(const LookupKey& k, void* callback_args, bool (*callback_func)(void* arg, const char* entry)); - virtual uint64_t ApproximateNumEntries(const Slice& start_ikey, - const Slice& end_key) { + virtual uint64_t ApproximateNumEntries(const Slice& /*start_ikey*/, + const Slice& /*end_key*/) { return 0; } diff --git a/include/rocksdb/merge_operator.h b/include/rocksdb/merge_operator.h index d263ae88b..c98d0f231 100644 --- a/include/rocksdb/merge_operator.h +++ b/include/rocksdb/merge_operator.h @@ -66,11 +66,9 @@ class MergeOperator { // internal corruption. This will be treated as an error by the library. // // Also make use of the *logger for error messages. - virtual bool FullMerge(const Slice& key, - const Slice* existing_value, - const std::deque& operand_list, - std::string* new_value, - Logger* logger) const { + virtual bool FullMerge(const Slice& /*key*/, const Slice* /*existing_value*/, + const std::deque& /*operand_list*/, + std::string* /*new_value*/, Logger* /*logger*/) const { // deprecated, please use FullMergeV2() assert(false); return false; @@ -145,9 +143,10 @@ class MergeOperator { // If there is corruption in the data, handle it in the FullMergeV2() function // and return false there. The default implementation of PartialMerge will // always return false. - virtual bool PartialMerge(const Slice& key, const Slice& left_operand, - const Slice& right_operand, std::string* new_value, - Logger* logger) const { + virtual bool PartialMerge(const Slice& /*key*/, const Slice& /*left_operand*/, + const Slice& /*right_operand*/, + std::string* /*new_value*/, + Logger* /*logger*/) const { return false; } @@ -196,7 +195,7 @@ class MergeOperator { // during a point lookup, thereby helping in limiting the number of levels to // read from. // Doesn't help with iterators. - virtual bool ShouldMerge(const std::vector& operands) const { + virtual bool ShouldMerge(const std::vector& /*operands*/) const { return false; } }; diff --git a/include/rocksdb/rate_limiter.h b/include/rocksdb/rate_limiter.h index 841838035..a81a3ac91 100644 --- a/include/rocksdb/rate_limiter.h +++ b/include/rocksdb/rate_limiter.h @@ -45,7 +45,7 @@ class RateLimiter { // Request for token for bytes. If this request can not be satisfied, the call // is blocked. Caller is responsible to make sure // bytes <= GetSingleBurstBytes() - virtual void Request(const int64_t bytes, const Env::IOPriority pri) { + virtual void Request(const int64_t /*bytes*/, const Env::IOPriority /*pri*/) { assert(false); } diff --git a/include/rocksdb/slice.h b/include/rocksdb/slice.h index 4f24c8a22..0f99c9090 100644 --- a/include/rocksdb/slice.h +++ b/include/rocksdb/slice.h @@ -177,7 +177,7 @@ class PinnableSlice : public Slice, public Cleanable { } } - void remove_prefix(size_t n) { + void remove_prefix(size_t /*n*/) { assert(0); // Not implemented } diff --git a/include/rocksdb/slice_transform.h b/include/rocksdb/slice_transform.h index fc82bf584..2143057df 100644 --- a/include/rocksdb/slice_transform.h +++ b/include/rocksdb/slice_transform.h @@ -58,7 +58,7 @@ class SliceTransform { virtual bool InDomain(const Slice& key) const = 0; // This is currently not used and remains here for backward compatibility. - virtual bool InRange(const Slice& dst) const { return false; } + virtual bool InRange(const Slice& /*dst*/) const { return false; } // Transform(s)=Transform(`prefix`) for any s with `prefix` as a prefix. // @@ -83,7 +83,7 @@ class SliceTransform { // "abcd,e", the file can be filtered out and the key will be invisible. // // i.e., an implementation always returning false is safe. - virtual bool SameResultWhenAppended(const Slice& prefix) const { + virtual bool SameResultWhenAppended(const Slice& /*prefix*/) const { return false; } }; diff --git a/include/rocksdb/statistics.h b/include/rocksdb/statistics.h index 2dd0db5ca..57c8daf33 100644 --- a/include/rocksdb/statistics.h +++ b/include/rocksdb/statistics.h @@ -597,7 +597,7 @@ class Statistics { virtual uint64_t getTickerCount(uint32_t tickerType) const = 0; virtual void histogramData(uint32_t type, HistogramData* const data) const = 0; - virtual std::string getHistogramString(uint32_t type) const { return ""; } + virtual std::string getHistogramString(uint32_t /*type*/) const { return ""; } virtual void recordTick(uint32_t tickerType, uint64_t count = 0) = 0; virtual void setTickerCount(uint32_t tickerType, uint64_t count) = 0; virtual uint64_t getAndResetTickerCount(uint32_t tickerType) = 0; diff --git a/include/rocksdb/table.h b/include/rocksdb/table.h index 8703a0eb5..e56d6d838 100644 --- a/include/rocksdb/table.h +++ b/include/rocksdb/table.h @@ -467,8 +467,8 @@ class TableFactory { // RocksDB prints configurations at DB Open(). virtual std::string GetPrintableTableOptions() const = 0; - virtual Status GetOptionString(std::string* opt_string, - const std::string& delimiter) const { + virtual Status GetOptionString(std::string* /*opt_string*/, + const std::string& /*delimiter*/) const { return Status::NotSupported( "The table factory doesn't implement GetOptionString()."); } diff --git a/include/rocksdb/utilities/geo_db.h b/include/rocksdb/utilities/geo_db.h index 408774c59..ec3cbdf26 100644 --- a/include/rocksdb/utilities/geo_db.h +++ b/include/rocksdb/utilities/geo_db.h @@ -80,7 +80,7 @@ class GeoDB : public StackableDB { // GeoDB owns the pointer `DB* db` now. You should not delete it or // use it after the invocation of GeoDB // GeoDB(DB* db, const GeoDBOptions& options) : StackableDB(db) {} - GeoDB(DB* db, const GeoDBOptions& options) : StackableDB(db) {} + GeoDB(DB* db, const GeoDBOptions& /*options*/) : StackableDB(db) {} virtual ~GeoDB() {} // Insert a new object into the location database. The object is diff --git a/include/rocksdb/utilities/optimistic_transaction_db.h b/include/rocksdb/utilities/optimistic_transaction_db.h index 02917ff58..518bc610c 100644 --- a/include/rocksdb/utilities/optimistic_transaction_db.h +++ b/include/rocksdb/utilities/optimistic_transaction_db.h @@ -62,7 +62,7 @@ class OptimisticTransactionDB { protected: // To Create an OptimisticTransactionDB, call Open() - explicit OptimisticTransactionDB(DB* db) {} + explicit OptimisticTransactionDB(DB* /*db*/) {} OptimisticTransactionDB() {} private: diff --git a/include/rocksdb/utilities/transaction.h b/include/rocksdb/utilities/transaction.h index 11317540a..34563043e 100644 --- a/include/rocksdb/utilities/transaction.h +++ b/include/rocksdb/utilities/transaction.h @@ -233,9 +233,9 @@ class Transaction { // An overload of the the above method that receives a PinnableSlice // For backward compatiblity a default implementation is provided virtual Status GetForUpdate(const ReadOptions& options, - ColumnFamilyHandle* column_family, + ColumnFamilyHandle* /*column_family*/, const Slice& key, PinnableSlice* pinnable_val, - bool exclusive = true) { + bool /*exclusive*/ = true) { if (pinnable_val == nullptr) { std::string* null_str = nullptr; return GetForUpdate(options, key, null_str); @@ -440,8 +440,8 @@ class Transaction { virtual bool IsDeadlockDetect() const { return false; } - virtual std::vector GetWaitingTxns(uint32_t* column_family_id, - std::string* key) const { + virtual std::vector GetWaitingTxns( + uint32_t* /*column_family_id*/, std::string* /*key*/) const { assert(false); return std::vector(); } @@ -469,7 +469,7 @@ class Transaction { uint64_t GetId() { return id_; } protected: - explicit Transaction(const TransactionDB* db) {} + explicit Transaction(const TransactionDB* /*db*/) {} Transaction() : log_number_(0), txn_state_(STARTED) {} // the log in which the prepared section for this txn resides diff --git a/include/rocksdb/wal_filter.h b/include/rocksdb/wal_filter.h index 686fa4998..a22dca923 100644 --- a/include/rocksdb/wal_filter.h +++ b/include/rocksdb/wal_filter.h @@ -44,8 +44,8 @@ class WalFilter { // @params cf_name_id_map column_family_name to column_family_id map virtual void ColumnFamilyLogNumberMap( - const std::map& cf_lognumber_map, - const std::map& cf_name_id_map) {} + const std::map& /*cf_lognumber_map*/, + const std::map& /*cf_name_id_map*/) {} // LogRecord is invoked for each log record encountered for all the logs // during replay on logs on recovery. This method can be used to: @@ -75,11 +75,9 @@ class WalFilter { // @returns Processing option for the current record. // Please see WalProcessingOption enum above for // details. - virtual WalProcessingOption LogRecordFound(unsigned long long log_number, - const std::string& log_file_name, - const WriteBatch& batch, - WriteBatch* new_batch, - bool* batch_changed) { + virtual WalProcessingOption LogRecordFound( + unsigned long long /*log_number*/, const std::string& /*log_file_name*/, + const WriteBatch& batch, WriteBatch* new_batch, bool* batch_changed) { // Default implementation falls back to older function for compatibility return LogRecord(batch, new_batch, batch_changed); } @@ -87,9 +85,9 @@ class WalFilter { // Please see the comments for LogRecord above. This function is for // compatibility only and contains a subset of parameters. // New code should use the function above. - virtual WalProcessingOption LogRecord(const WriteBatch& batch, - WriteBatch* new_batch, - bool* batch_changed) const { + virtual WalProcessingOption LogRecord(const WriteBatch& /*batch*/, + WriteBatch* /*new_batch*/, + bool* /*batch_changed*/) const { return WalProcessingOption::kContinueProcessing; } diff --git a/include/rocksdb/write_batch.h b/include/rocksdb/write_batch.h index dd7386163..59407c45c 100644 --- a/include/rocksdb/write_batch.h +++ b/include/rocksdb/write_batch.h @@ -217,8 +217,9 @@ class WriteBatch : public WriteBatchBase { } virtual void SingleDelete(const Slice& /*key*/) {} - virtual Status DeleteRangeCF(uint32_t column_family_id, - const Slice& begin_key, const Slice& end_key) { + virtual Status DeleteRangeCF(uint32_t /*column_family_id*/, + const Slice& /*begin_key*/, + const Slice& /*end_key*/) { return Status::InvalidArgument("DeleteRangeCF not implemented"); } @@ -246,20 +247,20 @@ class WriteBatch : public WriteBatchBase { return Status::InvalidArgument("MarkBeginPrepare() handler not defined."); } - virtual Status MarkEndPrepare(const Slice& xid) { + virtual Status MarkEndPrepare(const Slice& /*xid*/) { return Status::InvalidArgument("MarkEndPrepare() handler not defined."); } - virtual Status MarkNoop(bool empty_batch) { + virtual Status MarkNoop(bool /*empty_batch*/) { return Status::InvalidArgument("MarkNoop() handler not defined."); } - virtual Status MarkRollback(const Slice& xid) { + virtual Status MarkRollback(const Slice& /*xid*/) { return Status::InvalidArgument( "MarkRollbackPrepare() handler not defined."); } - virtual Status MarkCommit(const Slice& xid) { + virtual Status MarkCommit(const Slice& /*xid*/) { return Status::InvalidArgument("MarkCommit() handler not defined."); } diff --git a/memtable/hash_cuckoo_rep.cc b/memtable/hash_cuckoo_rep.cc index 034bf5858..39078633f 100644 --- a/memtable/hash_cuckoo_rep.cc +++ b/memtable/hash_cuckoo_rep.cc @@ -597,8 +597,8 @@ void HashCuckooRep::Iterator::Seek(const Slice& user_key, } // Retreat to the last entry with a key <= target -void HashCuckooRep::Iterator::SeekForPrev(const Slice& user_key, - const char* memtable_key) { +void HashCuckooRep::Iterator::SeekForPrev(const Slice& /*user_key*/, + const char* /*memtable_key*/) { assert(false); } @@ -623,7 +623,7 @@ void HashCuckooRep::Iterator::SeekToLast() { MemTableRep* HashCuckooRepFactory::CreateMemTableRep( const MemTableRep::KeyComparator& compare, Allocator* allocator, - const SliceTransform* transform, Logger* logger) { + const SliceTransform* /*transform*/, Logger* /*logger*/) { // The estimated average fullness. The write performance of any close hash // degrades as the fullness of the mem-table increases. Setting kFullness // to a value around 0.7 can better avoid write performance degradation while diff --git a/memtable/hash_linklist_rep.cc b/memtable/hash_linklist_rep.cc index 932b62a34..b23a9f5e5 100644 --- a/memtable/hash_linklist_rep.cc +++ b/memtable/hash_linklist_rep.cc @@ -362,14 +362,14 @@ class HashLinkListRep : public MemTableRep { // Advance to the first entry with a key >= target virtual void Seek(const Slice& internal_key, - const char* memtable_key) override { + const char* /*memtable_key*/) override { node_ = hash_link_list_rep_->FindGreaterOrEqualInBucket(head_, internal_key); } // Retreat to the last entry with a key <= target - virtual void SeekForPrev(const Slice& internal_key, - const char* memtable_key) override { + virtual void SeekForPrev(const Slice& /*internal_key*/, + const char* /*memtable_key*/) override { // Since we do not support Prev() // We simply do not support SeekForPrev Reset(nullptr); @@ -483,10 +483,10 @@ class HashLinkListRep : public MemTableRep { } virtual void Next() override {} virtual void Prev() override {} - virtual void Seek(const Slice& user_key, - const char* memtable_key) override {} - virtual void SeekForPrev(const Slice& user_key, - const char* memtable_key) override {} + virtual void Seek(const Slice& /*user_key*/, + const char* /*memtable_key*/) override {} + virtual void SeekForPrev(const Slice& /*user_key*/, + const char* /*memtable_key*/) override {} virtual void SeekToFirst() override {} virtual void SeekToLast() override {} diff --git a/memtable/hash_skiplist_rep.cc b/memtable/hash_skiplist_rep.cc index e34743eb2..93082b1ec 100644 --- a/memtable/hash_skiplist_rep.cc +++ b/memtable/hash_skiplist_rep.cc @@ -131,8 +131,8 @@ class HashSkipListRep : public MemTableRep { } // Retreat to the last entry with a key <= target - virtual void SeekForPrev(const Slice& internal_key, - const char* memtable_key) override { + virtual void SeekForPrev(const Slice& /*internal_key*/, + const char* /*memtable_key*/) override { // not supported assert(false); } @@ -219,10 +219,10 @@ class HashSkipListRep : public MemTableRep { } virtual void Next() override {} virtual void Prev() override {} - virtual void Seek(const Slice& internal_key, - const char* memtable_key) override {} - virtual void SeekForPrev(const Slice& internal_key, - const char* memtable_key) override {} + virtual void Seek(const Slice& /*internal_key*/, + const char* /*memtable_key*/) override {} + virtual void SeekForPrev(const Slice& /*internal_key*/, + const char* /*memtable_key*/) override {} virtual void SeekToFirst() override {} virtual void SeekToLast() override {} @@ -335,7 +335,7 @@ MemTableRep::Iterator* HashSkipListRep::GetDynamicPrefixIterator(Arena* arena) { MemTableRep* HashSkipListRepFactory::CreateMemTableRep( const MemTableRep::KeyComparator& compare, Allocator* allocator, - const SliceTransform* transform, Logger* logger) { + const SliceTransform* transform, Logger* /*logger*/) { return new HashSkipListRep(compare, allocator, transform, bucket_count_, skiplist_height_, skiplist_branching_factor_); } diff --git a/memtable/skiplistrep.cc b/memtable/skiplistrep.cc index 63f7a4246..1e56e1a98 100644 --- a/memtable/skiplistrep.cc +++ b/memtable/skiplistrep.cc @@ -282,7 +282,7 @@ public: MemTableRep* SkipListFactory::CreateMemTableRep( const MemTableRep::KeyComparator& compare, Allocator* allocator, - const SliceTransform* transform, Logger* logger) { + const SliceTransform* transform, Logger* /*logger*/) { return new SkipListRep(compare, allocator, transform, lookahead_); } diff --git a/memtable/vectorrep.cc b/memtable/vectorrep.cc index e54025c2d..378b29624 100644 --- a/memtable/vectorrep.cc +++ b/memtable/vectorrep.cc @@ -227,8 +227,8 @@ void VectorRep::Iterator::Seek(const Slice& user_key, } // Advance to the first entry with a key <= target -void VectorRep::Iterator::SeekForPrev(const Slice& user_key, - const char* memtable_key) { +void VectorRep::Iterator::SeekForPrev(const Slice& /*user_key*/, + const char* /*memtable_key*/) { assert(false); } @@ -296,7 +296,7 @@ MemTableRep::Iterator* VectorRep::GetIterator(Arena* arena) { MemTableRep* VectorRepFactory::CreateMemTableRep( const MemTableRep::KeyComparator& compare, Allocator* allocator, - const SliceTransform*, Logger* logger) { + const SliceTransform*, Logger* /*logger*/) { return new VectorRep(compare, allocator, count_); } } // namespace rocksdb diff --git a/options/options_parser.cc b/options/options_parser.cc index 0095c3ab7..c7a7c6d37 100644 --- a/options/options_parser.cc +++ b/options/options_parser.cc @@ -735,7 +735,7 @@ Status RocksDBOptionsParser::VerifyRocksDBOptionsFromFile( Status RocksDBOptionsParser::VerifyDBOptions( const DBOptions& base_opt, const DBOptions& persisted_opt, - const std::unordered_map* opt_map, + const std::unordered_map* /*opt_map*/, OptionsSanityCheckLevel sanity_check_level) { for (auto pair : db_options_type_info) { if (pair.second.verification == OptionVerificationType::kDeprecated) { diff --git a/port/port_posix.cc b/port/port_posix.cc index 129933bb1..9d3a9e6eb 100644 --- a/port/port_posix.cc +++ b/port/port_posix.cc @@ -35,7 +35,7 @@ static int PthreadCall(const char* label, int result) { return result; } -Mutex::Mutex(bool adaptive) { +Mutex::Mutex(bool /*adaptive*/) { #ifdef ROCKSDB_PTHREAD_ADAPTIVE_MUTEX if (!adaptive) { PthreadCall("init mutex", pthread_mutex_init(&mu_, nullptr)); diff --git a/port/stack_trace.cc b/port/stack_trace.cc index 2ed0016db..8f8135a44 100644 --- a/port/stack_trace.cc +++ b/port/stack_trace.cc @@ -13,7 +13,7 @@ namespace rocksdb { namespace port { void InstallStackTraceHandler() {} -void PrintStack(int first_frames_to_skip) {} +void PrintStack(int /*first_frames_to_skip*/) {} } // namespace port } // namespace rocksdb diff --git a/table/adaptive_table_factory.cc b/table/adaptive_table_factory.cc index 47069f866..0a3e9415a 100644 --- a/table/adaptive_table_factory.cc +++ b/table/adaptive_table_factory.cc @@ -44,7 +44,7 @@ Status AdaptiveTableFactory::NewTableReader( const TableReaderOptions& table_reader_options, unique_ptr&& file, uint64_t file_size, unique_ptr* table, - bool prefetch_index_and_filter_in_cache) const { + bool /*prefetch_index_and_filter_in_cache*/) const { Footer footer; auto s = ReadFooterFromFile(file.get(), nullptr /* prefetch_buffer */, file_size, &footer); diff --git a/table/adaptive_table_factory.h b/table/adaptive_table_factory.h index b7b52ba96..00af6a76e 100644 --- a/table/adaptive_table_factory.h +++ b/table/adaptive_table_factory.h @@ -44,8 +44,9 @@ class AdaptiveTableFactory : public TableFactory { uint32_t column_family_id, WritableFileWriter* file) const override; // Sanitizes the specified DB Options. - Status SanitizeOptions(const DBOptions& db_opts, - const ColumnFamilyOptions& cf_opts) const override { + Status SanitizeOptions( + const DBOptions& /*db_opts*/, + const ColumnFamilyOptions& /*cf_opts*/) const override { return Status::OK(); } diff --git a/table/block_based_filter_block.cc b/table/block_based_filter_block.cc index 6e300e810..2121ff828 100644 --- a/table/block_based_filter_block.cc +++ b/table/block_based_filter_block.cc @@ -113,7 +113,7 @@ inline void BlockBasedFilterBlockBuilder::AddPrefix(const Slice& key) { } } -Slice BlockBasedFilterBlockBuilder::Finish(const BlockHandle& tmp, +Slice BlockBasedFilterBlockBuilder::Finish(const BlockHandle& /*tmp*/, Status* status) { // In this impl we ignore BlockHandle *status = Status::OK(); @@ -185,8 +185,8 @@ BlockBasedFilterBlockReader::BlockBasedFilterBlockReader( } bool BlockBasedFilterBlockReader::KeyMayMatch( - const Slice& key, uint64_t block_offset, const bool no_io, - const Slice* const const_ikey_ptr) { + const Slice& key, uint64_t block_offset, const bool /*no_io*/, + const Slice* const /*const_ikey_ptr*/) { assert(block_offset != kNotValid); if (!whole_key_filtering_) { return true; @@ -195,8 +195,8 @@ bool BlockBasedFilterBlockReader::KeyMayMatch( } bool BlockBasedFilterBlockReader::PrefixMayMatch( - const Slice& prefix, uint64_t block_offset, const bool no_io, - const Slice* const const_ikey_ptr) { + const Slice& prefix, uint64_t block_offset, const bool /*no_io*/, + const Slice* const /*const_ikey_ptr*/) { assert(block_offset != kNotValid); if (!prefix_extractor_) { return true; diff --git a/table/block_based_table_builder.cc b/table/block_based_table_builder.cc index 71f01b9b0..eaeca52ea 100644 --- a/table/block_based_table_builder.cc +++ b/table/block_based_table_builder.cc @@ -208,8 +208,8 @@ class BlockBasedTableBuilder::BlockBasedTablePropertiesCollector whole_key_filtering_(whole_key_filtering), prefix_filtering_(prefix_filtering) {} - virtual Status InternalAdd(const Slice& key, const Slice& value, - uint64_t file_size) override { + virtual Status InternalAdd(const Slice& /*key*/, const Slice& /*value*/, + uint64_t /*file_size*/) override { // Intentionally left blank. Have no interest in collecting stats for // individual key/value pairs. return Status::OK(); @@ -589,7 +589,7 @@ Status BlockBasedTableBuilder::status() const { return rep_->status; } -static void DeleteCachedBlock(const Slice& key, void* value) { +static void DeleteCachedBlock(const Slice& /*key*/, void* value) { Block* block = reinterpret_cast(value); delete block; } diff --git a/table/block_based_table_factory.cc b/table/block_based_table_factory.cc index 5c83b3d13..7a74bcd5b 100644 --- a/table/block_based_table_factory.cc +++ b/table/block_based_table_factory.cc @@ -92,8 +92,7 @@ TableBuilder* BlockBasedTableFactory::NewTableBuilder( } Status BlockBasedTableFactory::SanitizeOptions( - const DBOptions& db_opts, - const ColumnFamilyOptions& cf_opts) const { + const DBOptions& /*db_opts*/, const ColumnFamilyOptions& cf_opts) const { if (table_options_.index_type == BlockBasedTableOptions::kHashSearch && cf_opts.prefix_extractor == nullptr) { return Status::InvalidArgument("Hash index is specified for block-based " diff --git a/table/block_based_table_reader.cc b/table/block_based_table_reader.cc index da9b856e4..1095b4649 100644 --- a/table/block_based_table_reader.cc +++ b/table/block_based_table_reader.cc @@ -95,13 +95,13 @@ Status ReadBlockFromFile( // Delete the resource that is held by the iterator. template -void DeleteHeldResource(void* arg, void* ignored) { +void DeleteHeldResource(void* arg, void* /*ignored*/) { delete reinterpret_cast(arg); } // Delete the entry resided in the cache. template -void DeleteCachedEntry(const Slice& key, void* value) { +void DeleteCachedEntry(const Slice& /*key*/, void* value) { auto entry = reinterpret_cast(value); delete entry; } @@ -207,8 +207,8 @@ class PartitionIndexReader : public IndexReader, public Cleanable { } // return a two-level iterator: first level is on the partition index - virtual InternalIterator* NewIterator(BlockIter* iter = nullptr, - bool dont_care = true) override { + virtual InternalIterator* NewIterator(BlockIter* /*iter*/ = nullptr, + bool /*dont_care*/ = true) override { // Filters are already checked before seeking the index if (!partition_map_.empty()) { return NewTwoLevelIterator( @@ -319,7 +319,7 @@ class PartitionIndexReader : public IndexReader, public Cleanable { PartitionIndexReader(BlockBasedTable* table, const InternalKeyComparator* icomparator, std::unique_ptr&& index_block, Statistics* stats, - const int level) + const int /*level*/) : IndexReader(icomparator, stats), table_(table), index_block_(std::move(index_block)) { @@ -363,7 +363,7 @@ class BinarySearchIndexReader : public IndexReader { } virtual InternalIterator* NewIterator(BlockIter* iter = nullptr, - bool dont_care = true) override { + bool /*dont_care*/ = true) override { return index_block_->NewIterator(icomparator_, iter, true); } @@ -399,7 +399,7 @@ class HashIndexReader : public IndexReader { const BlockHandle& index_handle, InternalIterator* meta_index_iter, IndexReader** index_reader, - bool hash_index_allow_collision, + bool /*hash_index_allow_collision*/, const PersistentCacheOptions& cache_options) { std::unique_ptr index_block; auto s = ReadBlockFromFile( @@ -1109,7 +1109,7 @@ Status BlockBasedTable::GetDataBlockFromCache( Status BlockBasedTable::PutDataBlockToCache( const Slice& block_cache_key, const Slice& compressed_block_cache_key, Cache* block_cache, Cache* block_cache_compressed, - const ReadOptions& read_options, const ImmutableCFOptions& ioptions, + const ReadOptions& /*read_options*/, const ImmutableCFOptions& ioptions, CachableEntry* block, Block* raw_block, uint32_t format_version, const Slice& compression_dict, size_t read_amp_bytes_per_bit, bool is_index, Cache::Priority priority, GetContext* get_context) { @@ -2774,7 +2774,7 @@ void BlockBasedTable::DumpKeyValue(const Slice& key, const Slice& value, namespace { -void DeleteCachedFilterEntry(const Slice& key, void* value) { +void DeleteCachedFilterEntry(const Slice& /*key*/, void* value) { FilterBlockReader* filter = reinterpret_cast(value); if (filter->statistics() != nullptr) { RecordTick(filter->statistics(), BLOCK_CACHE_FILTER_BYTES_EVICT, @@ -2783,7 +2783,7 @@ void DeleteCachedFilterEntry(const Slice& key, void* value) { delete filter; } -void DeleteCachedIndexEntry(const Slice& key, void* value) { +void DeleteCachedIndexEntry(const Slice& /*key*/, void* value) { IndexReader* index_reader = reinterpret_cast(value); if (index_reader->statistics() != nullptr) { RecordTick(index_reader->statistics(), BLOCK_CACHE_INDEX_BYTES_EVICT, diff --git a/table/block_test.cc b/table/block_test.cc index 45e454c74..968951e6c 100644 --- a/table/block_test.cc +++ b/table/block_test.cc @@ -133,7 +133,7 @@ TEST_F(BlockTest, SimpleTest) { BlockContents GetBlockContents(std::unique_ptr *builder, const std::vector &keys, const std::vector &values, - const int prefix_group_size = 1) { + const int /*prefix_group_size*/ = 1) { builder->reset(new BlockBuilder(1 /* restart interval */)); // Add only half of the keys diff --git a/table/cuckoo_table_builder_test.cc b/table/cuckoo_table_builder_test.cc index d896ed4b1..8f77b515c 100644 --- a/table/cuckoo_table_builder_test.cc +++ b/table/cuckoo_table_builder_test.cc @@ -23,7 +23,7 @@ namespace { std::unordered_map> hash_map; uint64_t GetSliceHash(const Slice& s, uint32_t index, - uint64_t max_num_buckets) { + uint64_t /*max_num_buckets*/) { return hash_map[s.ToString()][index]; } } // namespace diff --git a/table/cuckoo_table_factory.cc b/table/cuckoo_table_factory.cc index 2325bcf77..84d22468e 100644 --- a/table/cuckoo_table_factory.cc +++ b/table/cuckoo_table_factory.cc @@ -16,7 +16,7 @@ Status CuckooTableFactory::NewTableReader( const TableReaderOptions& table_reader_options, unique_ptr&& file, uint64_t file_size, std::unique_ptr* table, - bool prefetch_index_and_filter_in_cache) const { + bool /*prefetch_index_and_filter_in_cache*/) const { std::unique_ptr new_reader(new CuckooTableReader( table_reader_options.ioptions, std::move(file), file_size, table_reader_options.internal_comparator.user_comparator(), nullptr)); diff --git a/table/cuckoo_table_factory.h b/table/cuckoo_table_factory.h index db860c3d0..fba0903d7 100644 --- a/table/cuckoo_table_factory.h +++ b/table/cuckoo_table_factory.h @@ -67,8 +67,9 @@ class CuckooTableFactory : public TableFactory { uint32_t column_family_id, WritableFileWriter* file) const override; // Sanitizes the specified DB Options. - Status SanitizeOptions(const DBOptions& db_opts, - const ColumnFamilyOptions& cf_opts) const override { + Status SanitizeOptions( + const DBOptions& /*db_opts*/, + const ColumnFamilyOptions& /*cf_opts*/) const override { return Status::OK(); } @@ -76,8 +77,8 @@ class CuckooTableFactory : public TableFactory { void* GetOptions() override { return &table_options_; } - Status GetOptionString(std::string* opt_string, - const std::string& delimiter) const override { + Status GetOptionString(std::string* /*opt_string*/, + const std::string& /*delimiter*/) const override { return Status::OK(); } diff --git a/table/cuckoo_table_reader.cc b/table/cuckoo_table_reader.cc index 937f598d1..d48290900 100644 --- a/table/cuckoo_table_reader.cc +++ b/table/cuckoo_table_reader.cc @@ -139,8 +139,9 @@ CuckooTableReader::CuckooTableReader( status_ = file_->Read(0, file_size, &file_data_, nullptr); } -Status CuckooTableReader::Get(const ReadOptions& readOptions, const Slice& key, - GetContext* get_context, bool skip_filters) { +Status CuckooTableReader::Get(const ReadOptions& /*readOptions*/, + const Slice& key, GetContext* get_context, + bool /*skip_filters*/) { assert(key.size() == key_length_ + (is_last_level_ ? 8 : 0)); Slice user_key = ExtractUserKey(key); for (uint32_t hash_cnt = 0; hash_cnt < num_hash_func_; ++hash_cnt) { @@ -311,7 +312,7 @@ void CuckooTableIterator::Seek(const Slice& target) { PrepareKVAtCurrIdx(); } -void CuckooTableIterator::SeekForPrev(const Slice& target) { +void CuckooTableIterator::SeekForPrev(const Slice& /*target*/) { // Not supported assert(false); } @@ -376,7 +377,7 @@ extern InternalIterator* NewErrorInternalIterator(const Status& status, Arena* arena); InternalIterator* CuckooTableReader::NewIterator( - const ReadOptions& read_options, Arena* arena, bool skip_filters) { + const ReadOptions& /*read_options*/, Arena* arena, bool /*skip_filters*/) { if (!status().ok()) { return NewErrorInternalIterator( Status::Corruption("CuckooTableReader status is not okay."), arena); diff --git a/table/cuckoo_table_reader.h b/table/cuckoo_table_reader.h index 4beac8f9d..2988c88e0 100644 --- a/table/cuckoo_table_reader.h +++ b/table/cuckoo_table_reader.h @@ -54,7 +54,7 @@ class CuckooTableReader: public TableReader { size_t ApproximateMemoryUsage() const override; // Following methods are not implemented for Cuckoo Table Reader - uint64_t ApproximateOffsetOf(const Slice& key) override { return 0; } + uint64_t ApproximateOffsetOf(const Slice& /*key*/) override { return 0; } void SetupForCompaction() override {} // End of methods not implemented. diff --git a/table/cuckoo_table_reader_test.cc b/table/cuckoo_table_reader_test.cc index 981b9804c..aeb08a308 100644 --- a/table/cuckoo_table_reader_test.cc +++ b/table/cuckoo_table_reader_test.cc @@ -61,7 +61,7 @@ void AddHashLookups(const std::string& s, uint64_t bucket_id, } uint64_t GetSliceHash(const Slice& s, uint32_t index, - uint64_t max_num_buckets) { + uint64_t /*max_num_buckets*/) { return hash_map[s.ToString()][index]; } } // namespace diff --git a/table/filter_block.h b/table/filter_block.h index 7bf3b3132..feaf0c9f0 100644 --- a/table/filter_block.h +++ b/table/filter_block.h @@ -114,7 +114,7 @@ class FilterBlockReader { return error_msg; } - virtual void CacheDependencies(bool pin) {} + virtual void CacheDependencies(bool /*pin*/) {} protected: bool whole_key_filtering_; diff --git a/table/full_filter_block.cc b/table/full_filter_block.cc index 5739494e8..448b82784 100644 --- a/table/full_filter_block.cc +++ b/table/full_filter_block.cc @@ -43,7 +43,8 @@ inline void FullFilterBlockBuilder::AddPrefix(const Slice& key) { AddKey(prefix); } -Slice FullFilterBlockBuilder::Finish(const BlockHandle& tmp, Status* status) { +Slice FullFilterBlockBuilder::Finish(const BlockHandle& /*tmp*/, + Status* status) { // In this impl we ignore BlockHandle *status = Status::OK(); if (num_added_ != 0) { @@ -74,8 +75,8 @@ FullFilterBlockReader::FullFilterBlockReader( } bool FullFilterBlockReader::KeyMayMatch(const Slice& key, uint64_t block_offset, - const bool no_io, - const Slice* const const_ikey_ptr) { + const bool /*no_io*/, + const Slice* const /*const_ikey_ptr*/) { assert(block_offset == kNotValid); if (!whole_key_filtering_) { return true; @@ -83,10 +84,9 @@ bool FullFilterBlockReader::KeyMayMatch(const Slice& key, uint64_t block_offset, return MayMatch(key); } -bool FullFilterBlockReader::PrefixMayMatch(const Slice& prefix, - uint64_t block_offset, - const bool no_io, - const Slice* const const_ikey_ptr) { +bool FullFilterBlockReader::PrefixMayMatch( + const Slice& prefix, uint64_t block_offset, const bool /*no_io*/, + const Slice* const /*const_ikey_ptr*/) { assert(block_offset == kNotValid); if (!prefix_extractor_) { return true; diff --git a/table/full_filter_block.h b/table/full_filter_block.h index be27c58b6..e161d079e 100644 --- a/table/full_filter_block.h +++ b/table/full_filter_block.h @@ -43,7 +43,7 @@ class FullFilterBlockBuilder : public FilterBlockBuilder { ~FullFilterBlockBuilder() {} virtual bool IsBlockBased() override { return false; } - virtual void StartBlock(uint64_t block_offset) override {} + virtual void StartBlock(uint64_t /*block_offset*/) override {} virtual void Add(const Slice& key) override; virtual Slice Finish(const BlockHandle& tmp, Status* status) override; using FilterBlockBuilder::Finish; diff --git a/table/get_context.cc b/table/get_context.cc index 692857da5..0003385a9 100644 --- a/table/get_context.cc +++ b/table/get_context.cc @@ -77,7 +77,7 @@ void GetContext::MarkKeyMayExist() { } } -void GetContext::SaveValue(const Slice& value, SequenceNumber seq) { +void GetContext::SaveValue(const Slice& value, SequenceNumber /*seq*/) { assert(state_ == kNotFound); appendToReplayLog(replay_log_, kTypeValue, value); diff --git a/table/index_builder.h b/table/index_builder.h index d591e0e53..3793cebc2 100644 --- a/table/index_builder.h +++ b/table/index_builder.h @@ -69,7 +69,7 @@ class IndexBuilder { // This method will be called whenever a key is added. The subclasses may // override OnKeyAdded() if they need to collect additional information. - virtual void OnKeyAdded(const Slice& key) {} + virtual void OnKeyAdded(const Slice& /*key*/) {} // Inform the index builder that all entries has been written. Block builder // may therefore perform any operation required for block finalization. @@ -137,7 +137,7 @@ class ShortenedIndexBuilder : public IndexBuilder { using IndexBuilder::Finish; virtual Status Finish( IndexBlocks* index_blocks, - const BlockHandle& last_partition_block_handle) override { + const BlockHandle& /*last_partition_block_handle*/) override { index_blocks->index_block_contents = index_block_builder_.Finish(); return Status::OK(); } diff --git a/table/internal_iterator.h b/table/internal_iterator.h index 705044a3a..ff7b4d2cb 100644 --- a/table/internal_iterator.h +++ b/table/internal_iterator.h @@ -78,7 +78,8 @@ class InternalIterator : public Cleanable { // but for Iterators that need to communicate with PinnedIteratorsManager // they will implement this function and use the passed pointer to communicate // with PinnedIteratorsManager. - virtual void SetPinnedItersMgr(PinnedIteratorsManager* pinned_iters_mgr) {} + virtual void SetPinnedItersMgr(PinnedIteratorsManager* /*pinned_iters_mgr*/) { + } // If true, this means that the Slice returned by key() is valid as long as // PinnedIteratorsManager::ReleasePinnedData is not called and the @@ -95,7 +96,7 @@ class InternalIterator : public Cleanable { // Iterator is not deleted. virtual bool IsValuePinned() const { return false; } - virtual Status GetProperty(std::string prop_name, std::string* prop) { + virtual Status GetProperty(std::string /*prop_name*/, std::string* /*prop*/) { return Status::NotSupported(""); } diff --git a/table/iterator.cc b/table/iterator.cc index ed6a2cdea..0411b374a 100644 --- a/table/iterator.cc +++ b/table/iterator.cc @@ -111,8 +111,8 @@ class EmptyIterator : public Iterator { public: explicit EmptyIterator(const Status& s) : status_(s) { } virtual bool Valid() const override { return false; } - virtual void Seek(const Slice& target) override {} - virtual void SeekForPrev(const Slice& target) override {} + virtual void Seek(const Slice& /*target*/) override {} + virtual void SeekForPrev(const Slice& /*target*/) override {} virtual void SeekToFirst() override {} virtual void SeekToLast() override {} virtual void Next() override { assert(false); } @@ -135,8 +135,8 @@ class EmptyInternalIterator : public InternalIterator { public: explicit EmptyInternalIterator(const Status& s) : status_(s) {} virtual bool Valid() const override { return false; } - virtual void Seek(const Slice& target) override {} - virtual void SeekForPrev(const Slice& target) override {} + virtual void Seek(const Slice& /*target*/) override {} + virtual void SeekForPrev(const Slice& /*target*/) override {} virtual void SeekToFirst() override {} virtual void SeekToLast() override {} virtual void Next() override { assert(false); } diff --git a/table/mock_table.cc b/table/mock_table.cc index 86c380865..f03ab3521 100644 --- a/table/mock_table.cc +++ b/table/mock_table.cc @@ -27,13 +27,13 @@ stl_wrappers::KVMap MakeMockFile( } InternalIterator* MockTableReader::NewIterator(const ReadOptions&, - Arena* arena, - bool skip_filters) { + Arena* /*arena*/, + bool /*skip_filters*/) { return new MockTableIterator(table_); } Status MockTableReader::Get(const ReadOptions&, const Slice& key, - GetContext* get_context, bool skip_filters) { + GetContext* get_context, bool /*skip_filters*/) { std::unique_ptr iter(new MockTableIterator(table_)); for (iter->Seek(key); iter->Valid(); iter->Next()) { ParsedInternalKey parsed_key; @@ -56,10 +56,10 @@ std::shared_ptr MockTableReader::GetTableProperties() MockTableFactory::MockTableFactory() : next_id_(1) {} Status MockTableFactory::NewTableReader( - const TableReaderOptions& table_reader_options, - unique_ptr&& file, uint64_t file_size, + const TableReaderOptions& /*table_reader_options*/, + unique_ptr&& file, uint64_t /*file_size*/, unique_ptr* table_reader, - bool prefetch_index_and_filter_in_cache) const { + bool /*prefetch_index_and_filter_in_cache*/) const { uint32_t id = GetIDFromFile(file.get()); MutexLock lock_guard(&file_system_.mutex); @@ -75,8 +75,8 @@ Status MockTableFactory::NewTableReader( } TableBuilder* MockTableFactory::NewTableBuilder( - const TableBuilderOptions& table_builder_options, uint32_t column_family_id, - WritableFileWriter* file) const { + const TableBuilderOptions& /*table_builder_options*/, + uint32_t /*column_family_id*/, WritableFileWriter* file) const { uint32_t id = GetAndWriteNextID(file); return new MockTableBuilder(id, &file_system_); diff --git a/table/mock_table.h b/table/mock_table.h index 71609a173..f5fb4009e 100644 --- a/table/mock_table.h +++ b/table/mock_table.h @@ -45,7 +45,7 @@ class MockTableReader : public TableReader { Status Get(const ReadOptions&, const Slice& key, GetContext* get_context, bool skip_filters = false) override; - uint64_t ApproximateOffsetOf(const Slice& key) override { return 0; } + uint64_t ApproximateOffsetOf(const Slice& /*key*/) override { return 0; } virtual size_t ApproximateMemoryUsage() const override { return 0; } @@ -168,8 +168,8 @@ class MockTableFactory : public TableFactory { stl_wrappers::KVMap file_contents); virtual Status SanitizeOptions( - const DBOptions& db_opts, - const ColumnFamilyOptions& cf_opts) const override { + const DBOptions& /*db_opts*/, + const ColumnFamilyOptions& /*cf_opts*/) const override { return Status::OK(); } diff --git a/table/partitioned_filter_block.cc b/table/partitioned_filter_block.cc index 8d6df35e1..7fd59b437 100644 --- a/table/partitioned_filter_block.cc +++ b/table/partitioned_filter_block.cc @@ -88,7 +88,7 @@ Slice PartitionedFilterBlockBuilder::Finish( PartitionedFilterBlockReader::PartitionedFilterBlockReader( const SliceTransform* prefix_extractor, bool _whole_key_filtering, - BlockContents&& contents, FilterBitsReader* filter_bits_reader, + BlockContents&& contents, FilterBitsReader* /*filter_bits_reader*/, Statistics* stats, const Comparator& comparator, const BlockBasedTable* table) : FilterBlockReader(contents.data.size(), stats, _whole_key_filtering), diff --git a/table/plain_table_factory.cc b/table/plain_table_factory.cc index 7cf71b0e5..ac0c4c80f 100644 --- a/table/plain_table_factory.cc +++ b/table/plain_table_factory.cc @@ -21,7 +21,7 @@ Status PlainTableFactory::NewTableReader( const TableReaderOptions& table_reader_options, unique_ptr&& file, uint64_t file_size, unique_ptr* table, - bool prefetch_index_and_filter_in_cache) const { + bool /*prefetch_index_and_filter_in_cache*/) const { return PlainTableReader::Open( table_reader_options.ioptions, table_reader_options.env_options, table_reader_options.internal_comparator, std::move(file), file_size, @@ -195,7 +195,7 @@ Status GetPlainTableOptionsFromMap( const PlainTableOptions& table_options, const std::unordered_map& opts_map, PlainTableOptions* new_table_options, bool input_strings_escaped, - bool ignore_unknown_options) { + bool /*ignore_unknown_options*/) { assert(new_table_options); *new_table_options = table_options; for (const auto& o : opts_map) { diff --git a/table/plain_table_factory.h b/table/plain_table_factory.h index e86f6dc8e..f540a92b8 100644 --- a/table/plain_table_factory.h +++ b/table/plain_table_factory.h @@ -164,15 +164,16 @@ class PlainTableFactory : public TableFactory { static const char kValueTypeSeqId0 = char(~0); // Sanitizes the specified DB Options. - Status SanitizeOptions(const DBOptions& db_opts, - const ColumnFamilyOptions& cf_opts) const override { + Status SanitizeOptions( + const DBOptions& /*db_opts*/, + const ColumnFamilyOptions& /*cf_opts*/) const override { return Status::OK(); } void* GetOptions() override { return &table_options_; } - Status GetOptionString(std::string* opt_string, - const std::string& delimiter) const override { + Status GetOptionString(std::string* /*opt_string*/, + const std::string& /*delimiter*/) const override { return Status::OK(); } diff --git a/table/plain_table_key_coding.cc b/table/plain_table_key_coding.cc index 3e87c03d1..6f5ee9b4a 100644 --- a/table/plain_table_key_coding.cc +++ b/table/plain_table_key_coding.cc @@ -288,7 +288,7 @@ Status PlainTableKeyDecoder::NextPlainEncodingKey(uint32_t start_offset, ParsedInternalKey* parsed_key, Slice* internal_key, uint32_t* bytes_read, - bool* seekable) { + bool* /*seekable*/) { uint32_t user_key_size = 0; Status s; if (fixed_user_key_len_ != kPlainTableVariableLength) { diff --git a/table/plain_table_reader.cc b/table/plain_table_reader.cc index d4d9edb74..9c9f82ee4 100644 --- a/table/plain_table_reader.cc +++ b/table/plain_table_reader.cc @@ -191,7 +191,7 @@ void PlainTableReader::SetupForCompaction() { InternalIterator* PlainTableReader::NewIterator(const ReadOptions& options, Arena* arena, - bool skip_filters) { + bool /*skip_filters*/) { bool use_prefix_seek = !IsTotalOrderMode() && !options.total_order_seek; if (arena == nullptr) { return new PlainTableIterator(this, use_prefix_seek); @@ -537,8 +537,8 @@ void PlainTableReader::Prepare(const Slice& target) { } } -Status PlainTableReader::Get(const ReadOptions& ro, const Slice& target, - GetContext* get_context, bool skip_filters) { +Status PlainTableReader::Get(const ReadOptions& /*ro*/, const Slice& target, + GetContext* get_context, bool /*skip_filters*/) { // Check bloom filter first. Slice prefix_slice; uint32_t prefix_hash; @@ -602,7 +602,7 @@ Status PlainTableReader::Get(const ReadOptions& ro, const Slice& target, return Status::OK(); } -uint64_t PlainTableReader::ApproximateOffsetOf(const Slice& key) { +uint64_t PlainTableReader::ApproximateOffsetOf(const Slice& /*key*/) { return 0; } @@ -706,7 +706,7 @@ void PlainTableIterator::Seek(const Slice& target) { } } -void PlainTableIterator::SeekForPrev(const Slice& target) { +void PlainTableIterator::SeekForPrev(const Slice& /*target*/) { assert(false); status_ = Status::NotSupported("SeekForPrev() is not supported in PlainTable"); diff --git a/table/sst_file_writer_collectors.h b/table/sst_file_writer_collectors.h index ce3a45f5a..89e0970d8 100644 --- a/table/sst_file_writer_collectors.h +++ b/table/sst_file_writer_collectors.h @@ -26,8 +26,8 @@ class SstFileWriterPropertiesCollector : public IntTblPropCollector { SequenceNumber global_seqno) : version_(version), global_seqno_(global_seqno) {} - virtual Status InternalAdd(const Slice& key, const Slice& value, - uint64_t file_size) override { + virtual Status InternalAdd(const Slice& /*key*/, const Slice& /*value*/, + uint64_t /*file_size*/) override { // Intentionally left blank. Have no interest in collecting stats for // individual key/value pairs. return Status::OK(); @@ -68,7 +68,7 @@ class SstFileWriterPropertiesCollectorFactory : version_(version), global_seqno_(global_seqno) {} virtual IntTblPropCollector* CreateIntTblPropCollector( - uint32_t column_family_id) override { + uint32_t /*column_family_id*/) override { return new SstFileWriterPropertiesCollector(version_, global_seqno_); } diff --git a/table/table_reader.h b/table/table_reader.h index 18fcda273..37a282b10 100644 --- a/table/table_reader.h +++ b/table/table_reader.h @@ -43,7 +43,7 @@ class TableReader { bool skip_filters = false) = 0; virtual InternalIterator* NewRangeTombstoneIterator( - const ReadOptions& read_options) { + const ReadOptions& /*read_options*/) { return nullptr; } @@ -62,7 +62,7 @@ class TableReader { virtual std::shared_ptr GetTableProperties() const = 0; // Prepare work that can be done before the real Get() - virtual void Prepare(const Slice& target) {} + virtual void Prepare(const Slice& /*target*/) {} // Report an approximation of how much memory has been used. virtual size_t ApproximateMemoryUsage() const = 0; @@ -94,7 +94,7 @@ class TableReader { } // convert db file to a human readable form - virtual Status DumpTable(WritableFile* out_file) { + virtual Status DumpTable(WritableFile* /*out_file*/) { return Status::NotSupported("DumpTable() not supported"); } diff --git a/table/table_test.cc b/table/table_test.cc index 4bdf6ba19..e893201b1 100644 --- a/table/table_test.cc +++ b/table/table_test.cc @@ -66,9 +66,13 @@ class DummyPropertiesCollector : public TablePropertiesCollector { public: const char* Name() const { return ""; } - Status Finish(UserCollectedProperties* properties) { return Status::OK(); } + Status Finish(UserCollectedProperties* /*properties*/) { + return Status::OK(); + } - Status Add(const Slice& user_key, const Slice& value) { return Status::OK(); } + Status Add(const Slice& /*user_key*/, const Slice& /*value*/) { + return Status::OK(); + } virtual UserCollectedProperties GetReadableProperties() const { return UserCollectedProperties{}; @@ -79,7 +83,7 @@ class DummyPropertiesCollectorFactory1 : public TablePropertiesCollectorFactory { public: virtual TablePropertiesCollector* CreateTablePropertiesCollector( - TablePropertiesCollectorFactory::Context context) { + TablePropertiesCollectorFactory::Context /*context*/) { return new DummyPropertiesCollector(); } const char* Name() const { return "DummyPropertiesCollector1"; } @@ -89,7 +93,7 @@ class DummyPropertiesCollectorFactory2 : public TablePropertiesCollectorFactory { public: virtual TablePropertiesCollector* CreateTablePropertiesCollector( - TablePropertiesCollectorFactory::Context context) { + TablePropertiesCollectorFactory::Context /*context*/) { return new DummyPropertiesCollector(); } const char* Name() const { return "DummyPropertiesCollector2"; } @@ -207,11 +211,11 @@ class BlockConstructor: public Constructor { ~BlockConstructor() { delete block_; } - virtual Status FinishImpl(const Options& options, - const ImmutableCFOptions& ioptions, - const BlockBasedTableOptions& table_options, - const InternalKeyComparator& internal_comparator, - const stl_wrappers::KVMap& kv_map) override { + virtual Status FinishImpl( + const Options& /*options*/, const ImmutableCFOptions& /*ioptions*/, + const BlockBasedTableOptions& table_options, + const InternalKeyComparator& /*internal_comparator*/, + const stl_wrappers::KVMap& kv_map) override { delete block_; block_ = nullptr; BlockBuilder builder(table_options.block_restart_interval); @@ -305,7 +309,7 @@ class TableConstructor: public Constructor { virtual Status FinishImpl(const Options& options, const ImmutableCFOptions& ioptions, - const BlockBasedTableOptions& table_options, + const BlockBasedTableOptions& /*table_options*/, const InternalKeyComparator& internal_comparator, const stl_wrappers::KVMap& kv_map) override { Reset(); @@ -433,10 +437,11 @@ class MemTableConstructor: public Constructor { ~MemTableConstructor() { delete memtable_->Unref(); } - virtual Status FinishImpl(const Options&, const ImmutableCFOptions& ioptions, - const BlockBasedTableOptions& table_options, - const InternalKeyComparator& internal_comparator, - const stl_wrappers::KVMap& kv_map) override { + virtual Status FinishImpl( + const Options&, const ImmutableCFOptions& ioptions, + const BlockBasedTableOptions& /*table_options*/, + const InternalKeyComparator& /*internal_comparator*/, + const stl_wrappers::KVMap& kv_map) override { delete memtable_->Unref(); ImmutableCFOptions mem_ioptions(ioptions); memtable_ = new MemTable(internal_comparator_, mem_ioptions, @@ -499,11 +504,11 @@ class DBConstructor: public Constructor { ~DBConstructor() { delete db_; } - virtual Status FinishImpl(const Options& options, - const ImmutableCFOptions& ioptions, - const BlockBasedTableOptions& table_options, - const InternalKeyComparator& internal_comparator, - const stl_wrappers::KVMap& kv_map) override { + virtual Status FinishImpl( + const Options& /*options*/, const ImmutableCFOptions& /*ioptions*/, + const BlockBasedTableOptions& /*table_options*/, + const InternalKeyComparator& /*internal_comparator*/, + const stl_wrappers::KVMap& kv_map) override { delete db_; db_ = nullptr; NewDB(); @@ -665,7 +670,7 @@ class FixedOrLessPrefixTransform : public SliceTransform { return Slice(src.data(), prefix_len_); } - virtual bool InDomain(const Slice& src) const override { return true; } + virtual bool InDomain(const Slice& /*src*/) const override { return true; } virtual bool InRange(const Slice& dst) const override { return (dst.size() <= prefix_len_); @@ -795,7 +800,7 @@ class HarnessTest : public testing::Test { TestRandomAccess(rnd, keys, data); } - void TestForwardScan(const std::vector& keys, + void TestForwardScan(const std::vector& /*keys*/, const stl_wrappers::KVMap& data) { InternalIterator* iter = constructor_->NewIterator(); ASSERT_TRUE(!iter->Valid()); @@ -813,7 +818,7 @@ class HarnessTest : public testing::Test { } } - void TestBackwardScan(const std::vector& keys, + void TestBackwardScan(const std::vector& /*keys*/, const stl_wrappers::KVMap& data) { InternalIterator* iter = constructor_->NewIterator(); ASSERT_TRUE(!iter->Valid()); @@ -1595,7 +1600,7 @@ static std::string RandomString(Random* rnd, int len) { } void AddInternalKey(TableConstructor* c, const std::string& prefix, - int suffix_len = 800) { + int /*suffix_len*/ = 800) { static Random rnd(1023); InternalKey k(prefix + RandomString(&rnd, 800), 0, kTypeValue); c->Add(k.Encode().ToString(), "v"); @@ -2957,7 +2962,7 @@ class TestPrefixExtractor : public rocksdb::SliceTransform { return true; } - bool InRange(const rocksdb::Slice& dst) const override { return true; } + bool InRange(const rocksdb::Slice& /*dst*/) const override { return true; } bool IsValid(const rocksdb::Slice& src) const { if (src.size() != 4) { diff --git a/table/two_level_iterator.cc b/table/two_level_iterator.cc index dbdf4a9fd..0cb285551 100644 --- a/table/two_level_iterator.cc +++ b/table/two_level_iterator.cc @@ -54,8 +54,7 @@ class TwoLevelIterator : public InternalIterator { } } virtual void SetPinnedItersMgr( - PinnedIteratorsManager* pinned_iters_mgr) override { - } + PinnedIteratorsManager* /*pinned_iters_mgr*/) override {} virtual bool IsKeyPinned() const override { return false; } virtual bool IsValuePinned() const override { return false; } diff --git a/third-party/fbson/FbsonDocument.h b/third-party/fbson/FbsonDocument.h index 6fb8a93f1..fc7ca76ff 100644 --- a/third-party/fbson/FbsonDocument.h +++ b/third-party/fbson/FbsonDocument.h @@ -355,7 +355,7 @@ class NumberValT : public FbsonValue { unsigned int numPackedBytes() const { return sizeof(FbsonValue) + sizeof(T); } // catch all unknow specialization of the template class - bool setVal(T value) { return false; } + bool setVal(T /*value*/) { return false; } private: T num_; diff --git a/tools/db_bench_tool.cc b/tools/db_bench_tool.cc index 748ce57a9..cfa365dea 100644 --- a/tools/db_bench_tool.cc +++ b/tools/db_bench_tool.cc @@ -246,7 +246,7 @@ DEFINE_bool(use_uint64_comparator, false, "use Uint64 user comparator"); DEFINE_int64(batch_size, 1, "Batch size"); -static bool ValidateKeySize(const char* flagname, int32_t value) { +static bool ValidateKeySize(const char* /*flagname*/, int32_t /*value*/) { return true; } @@ -2129,8 +2129,9 @@ class Benchmark { explicit ExpiredTimeFilter( const std::shared_ptr& timestamp_emulator) : timestamp_emulator_(timestamp_emulator) {} - bool Filter(int level, const Slice& key, const Slice& existing_value, - std::string* new_value, bool* value_changed) const override { + bool Filter(int /*level*/, const Slice& key, + const Slice& /*existing_value*/, std::string* /*new_value*/, + bool* /*value_changed*/) const override { return KeyExpired(timestamp_emulator_.get(), key); } const char* Name() const override { return "ExpiredTimeFilter"; } @@ -3486,12 +3487,9 @@ void VerifyDBFromDB(std::string& truth_db_name) { class KeyGenerator { public: - KeyGenerator(Random64* rand, WriteMode mode, - uint64_t num, uint64_t num_per_set = 64 * 1024) - : rand_(rand), - mode_(mode), - num_(num), - next_(0) { + KeyGenerator(Random64* rand, WriteMode mode, uint64_t num, + uint64_t /*num_per_set*/ = 64 * 1024) + : rand_(rand), mode_(mode), num_(num), next_(0) { if (mode_ == UNIQUE_RANDOM) { // NOTE: if memory consumption of this approach becomes a concern, // we can either break it into pieces and only random shuffle a section diff --git a/tools/ldb_cmd.cc b/tools/ldb_cmd.cc index 96138ffa6..a22e61359 100644 --- a/tools/ldb_cmd.cc +++ b/tools/ldb_cmd.cc @@ -112,7 +112,7 @@ LDBCommand* LDBCommand::InitFromCmdLineArgs( LDBCommand* LDBCommand::InitFromCmdLineArgs( const std::vector& args, const Options& options, const LDBOptions& ldb_options, - const std::vector* column_families, + const std::vector* /*column_families*/, const std::function& selector) { // --x=y command line arguments are added as x->y map entries in // parsed_params.option_map. @@ -451,7 +451,7 @@ std::vector LDBCommand::BuildCmdLineOptions( * updated. */ bool LDBCommand::ParseIntOption( - const std::map& options, + const std::map& /*options*/, const std::string& option, int& value, LDBCommandExecuteResult& exec_state) { std::map::const_iterator itr = @@ -481,7 +481,7 @@ bool LDBCommand::ParseIntOption( * Returns false otherwise. */ bool LDBCommand::ParseStringOption( - const std::map& options, + const std::map& /*options*/, const std::string& option, std::string* value) { auto itr = option_map_.find(option); if (itr != option_map_.end()) { @@ -772,7 +772,7 @@ bool LDBCommand::StringToBool(std::string val) { } CompactorCommand::CompactorCommand( - const std::vector& params, + const std::vector& /*params*/, const std::map& options, const std::vector& flags) : LDBCommand(options, flags, false, @@ -842,7 +842,7 @@ const std::string DBLoaderCommand::ARG_BULK_LOAD = "bulk_load"; const std::string DBLoaderCommand::ARG_COMPACT = "compact"; DBLoaderCommand::DBLoaderCommand( - const std::vector& params, + const std::vector& /*params*/, const std::map& options, const std::vector& flags) : LDBCommand( @@ -958,7 +958,7 @@ void ManifestDumpCommand::Help(std::string& ret) { } ManifestDumpCommand::ManifestDumpCommand( - const std::vector& params, + const std::vector& /*params*/, const std::map& options, const std::vector& flags) : LDBCommand( @@ -1153,7 +1153,7 @@ const std::string InternalDumpCommand::ARG_STATS = "stats"; const std::string InternalDumpCommand::ARG_INPUT_KEY_HEX = "input_key_hex"; InternalDumpCommand::InternalDumpCommand( - const std::vector& params, + const std::vector& /*params*/, const std::map& options, const std::vector& flags) : LDBCommand( @@ -1292,7 +1292,7 @@ const std::string DBDumperCommand::ARG_STATS = "stats"; const std::string DBDumperCommand::ARG_TTL_BUCKET = "bucket"; DBDumperCommand::DBDumperCommand( - const std::vector& params, + const std::vector& /*params*/, const std::map& options, const std::vector& flags) : LDBCommand(options, flags, true, @@ -1579,7 +1579,7 @@ const std::string ReduceDBLevelsCommand::ARG_PRINT_OLD_LEVELS = "print_old_levels"; ReduceDBLevelsCommand::ReduceDBLevelsCommand( - const std::vector& params, + const std::vector& /*params*/, const std::map& options, const std::vector& flags) : LDBCommand(options, flags, false, @@ -1709,7 +1709,7 @@ const std::string ChangeCompactionStyleCommand::ARG_NEW_COMPACTION_STYLE = "new_compaction_style"; ChangeCompactionStyleCommand::ChangeCompactionStyleCommand( - const std::vector& params, + const std::vector& /*params*/, const std::map& options, const std::vector& flags) : LDBCommand(options, flags, false, @@ -1846,7 +1846,7 @@ void ChangeCompactionStyleCommand::DoCommand() { namespace { struct StdErrReporter : public log::Reader::Reporter { - virtual void Corruption(size_t bytes, const Status& s) override { + virtual void Corruption(size_t /*bytes*/, const Status& s) override { std::cerr << "Corruption detected in log file " << s.ToString() << "\n"; } }; @@ -2016,7 +2016,7 @@ const std::string WALDumperCommand::ARG_PRINT_VALUE = "print_value"; const std::string WALDumperCommand::ARG_PRINT_HEADER = "header"; WALDumperCommand::WALDumperCommand( - const std::vector& params, + const std::vector& /*params*/, const std::map& options, const std::vector& flags) : LDBCommand(options, flags, true, @@ -2100,7 +2100,7 @@ void GetCommand::DoCommand() { // ---------------------------------------------------------------------------- ApproxSizeCommand::ApproxSizeCommand( - const std::vector& params, + const std::vector& /*params*/, const std::map& options, const std::vector& flags) : LDBCommand(options, flags, true, @@ -2216,7 +2216,7 @@ Options BatchPutCommand::PrepareOptionsForOpenDB() { // ---------------------------------------------------------------------------- -ScanCommand::ScanCommand(const std::vector& params, +ScanCommand::ScanCommand(const std::vector& /*params*/, const std::map& options, const std::vector& flags) : LDBCommand( @@ -2499,7 +2499,7 @@ const char* DBQuerierCommand::PUT_CMD = "put"; const char* DBQuerierCommand::DELETE_CMD = "delete"; DBQuerierCommand::DBQuerierCommand( - const std::vector& params, + const std::vector& /*params*/, const std::map& options, const std::vector& flags) : LDBCommand( @@ -2578,7 +2578,7 @@ void DBQuerierCommand::DoCommand() { // ---------------------------------------------------------------------------- CheckConsistencyCommand::CheckConsistencyCommand( - const std::vector& params, + const std::vector& /*params*/, const std::map& options, const std::vector& flags) : LDBCommand(options, flags, false, BuildCmdLineOptions({})) {} @@ -2610,7 +2610,7 @@ void CheckConsistencyCommand::DoCommand() { const std::string CheckPointCommand::ARG_CHECKPOINT_DIR = "checkpoint_dir"; CheckPointCommand::CheckPointCommand( - const std::vector& params, + const std::vector& /*params*/, const std::map& options, const std::vector& flags) : LDBCommand(options, flags, false /* is_read_only */, @@ -2645,7 +2645,7 @@ void CheckPointCommand::DoCommand() { // ---------------------------------------------------------------------------- -RepairCommand::RepairCommand(const std::vector& params, +RepairCommand::RepairCommand(const std::vector& /*params*/, const std::map& options, const std::vector& flags) : LDBCommand(options, flags, false, BuildCmdLineOptions({})) {} @@ -2675,7 +2675,7 @@ const std::string BackupableCommand::ARG_BACKUP_DIR = "backup_dir"; const std::string BackupableCommand::ARG_STDERR_LOG_LEVEL = "stderr_log_level"; BackupableCommand::BackupableCommand( - const std::vector& params, + const std::vector& /*params*/, const std::map& options, const std::vector& flags) : LDBCommand(options, flags, false /* is_read_only */, @@ -2853,7 +2853,7 @@ void DumpSstFile(std::string filename, bool output_hex, bool show_properties) { } // namespace DBFileDumperCommand::DBFileDumperCommand( - const std::vector& params, + const std::vector& /*params*/, const std::map& options, const std::vector& flags) : LDBCommand(options, flags, true, BuildCmdLineOptions({})) {} diff --git a/tools/ldb_tool.cc b/tools/ldb_tool.cc index e8229ef7b..b09076ecc 100644 --- a/tools/ldb_tool.cc +++ b/tools/ldb_tool.cc @@ -13,7 +13,7 @@ namespace rocksdb { LDBOptions::LDBOptions() {} void LDBCommandRunner::PrintHelp(const LDBOptions& ldb_options, - const char* exec_name) { + const char* /*exec_name*/) { std::string ret; ret.append(ldb_options.print_help_header); diff --git a/tools/sst_dump_tool.cc b/tools/sst_dump_tool.cc index 29d8e4292..4480bb09e 100644 --- a/tools/sst_dump_tool.cc +++ b/tools/sst_dump_tool.cc @@ -121,9 +121,9 @@ Status SstFileReader::GetTableReader(const std::string& file_path) { } Status SstFileReader::NewTableReader( - const ImmutableCFOptions& ioptions, const EnvOptions& soptions, - const InternalKeyComparator& internal_comparator, uint64_t file_size, - unique_ptr* table_reader) { + const ImmutableCFOptions& /*ioptions*/, const EnvOptions& /*soptions*/, + const InternalKeyComparator& /*internal_comparator*/, uint64_t file_size, + unique_ptr* /*table_reader*/) { // We need to turn off pre-fetching of index and filter nodes for // BlockBasedTable if (BlockBasedTableFactory::kName == options_.table_factory->Name()) { diff --git a/util/compression.h b/util/compression.h index f12036d21..17ec1985c 100644 --- a/util/compression.h +++ b/util/compression.h @@ -162,8 +162,9 @@ inline std::string CompressionTypeToString(CompressionType compression_type) { // 2 -- Zlib, BZip2 and LZ4 encode decompressed size as Varint32 just before the // start of compressed block. Snappy format is the same as version 1. -inline bool Snappy_Compress(const CompressionOptions& opts, const char* input, - size_t length, ::std::string* output) { +inline bool Snappy_Compress(const CompressionOptions& /*opts*/, + const char* input, size_t length, + ::std::string* output) { #ifdef SNAPPY output->resize(snappy::MaxCompressedLength(length)); size_t outlen; @@ -393,10 +394,9 @@ inline char* Zlib_Uncompress(const char* input_data, size_t input_length, // block header // compress_format_version == 2 -- decompressed size is included in the block // header in varint32 format -inline bool BZip2_Compress(const CompressionOptions& opts, - uint32_t compress_format_version, - const char* input, size_t length, - ::std::string* output) { +inline bool BZip2_Compress(const CompressionOptions& /*opts*/, + uint32_t compress_format_version, const char* input, + size_t length, ::std::string* output) { #ifdef BZIP2 if (length > std::numeric_limits::max()) { // Can't compress more than 4GB @@ -534,7 +534,7 @@ inline char* BZip2_Uncompress(const char* input_data, size_t input_length, // header in varint32 format // @param compression_dict Data for presetting the compression library's // dictionary. -inline bool LZ4_Compress(const CompressionOptions& opts, +inline bool LZ4_Compress(const CompressionOptions& /*opts*/, uint32_t compress_format_version, const char* input, size_t length, ::std::string* output, const Slice compression_dict = Slice()) { @@ -722,7 +722,8 @@ inline bool LZ4HC_Compress(const CompressionOptions& opts, #endif } -inline bool XPRESS_Compress(const char* input, size_t length, std::string* output) { +inline bool XPRESS_Compress(const char* /*input*/, size_t /*length*/, + std::string* /*output*/) { #ifdef XPRESS return port::xpress::Compress(input, length, output); #else @@ -730,8 +731,9 @@ inline bool XPRESS_Compress(const char* input, size_t length, std::string* outpu #endif } -inline char* XPRESS_Uncompress(const char* input_data, size_t input_length, - int* decompress_size) { +inline char* XPRESS_Uncompress(const char* /*input_data*/, + size_t /*input_length*/, + int* /*decompress_size*/) { #ifdef XPRESS return port::xpress::Decompress(input_data, input_length, decompress_size); #else diff --git a/util/file_reader_writer_test.cc b/util/file_reader_writer_test.cc index 45675e9dd..4425f87a0 100644 --- a/util/file_reader_writer_test.cc +++ b/util/file_reader_writer_test.cc @@ -26,9 +26,7 @@ TEST_F(WritableFileWriterTest, RangeSync) { size_ += data.size(); return Status::OK(); } - virtual Status Truncate(uint64_t size) override { - return Status::OK(); - } + virtual Status Truncate(uint64_t /*size*/) override { return Status::OK(); } Status Close() override { EXPECT_GE(size_, last_synced_ + kMb); EXPECT_LT(size_, last_synced_ + 2 * kMb); @@ -39,17 +37,21 @@ TEST_F(WritableFileWriterTest, RangeSync) { Status Flush() override { return Status::OK(); } Status Sync() override { return Status::OK(); } Status Fsync() override { return Status::OK(); } - void SetIOPriority(Env::IOPriority pri) override {} + void SetIOPriority(Env::IOPriority /*pri*/) override {} uint64_t GetFileSize() override { return size_; } - void GetPreallocationStatus(size_t* block_size, - size_t* last_allocated_block) override {} - size_t GetUniqueId(char* id, size_t max_size) const override { return 0; } - Status InvalidateCache(size_t offset, size_t length) override { + void GetPreallocationStatus(size_t* /*block_size*/, + size_t* /*last_allocated_block*/) override {} + size_t GetUniqueId(char* /*id*/, size_t /*max_size*/) const override { + return 0; + } + Status InvalidateCache(size_t /*offset*/, size_t /*length*/) override { return Status::OK(); } protected: - Status Allocate(uint64_t offset, uint64_t len) override { return Status::OK(); } + Status Allocate(uint64_t /*offset*/, uint64_t /*len*/) override { + return Status::OK(); + } Status RangeSync(uint64_t offset, uint64_t nbytes) override { EXPECT_EQ(offset % 4096, 0u); EXPECT_EQ(nbytes % 4096, 0u); @@ -119,12 +121,14 @@ TEST_F(WritableFileWriterTest, IncrementalBuffer) { Status Flush() override { return Status::OK(); } Status Sync() override { return Status::OK(); } Status Fsync() override { return Status::OK(); } - void SetIOPriority(Env::IOPriority pri) override {} + void SetIOPriority(Env::IOPriority /*pri*/) override {} uint64_t GetFileSize() override { return size_; } - void GetPreallocationStatus(size_t* block_size, - size_t* last_allocated_block) override {} - size_t GetUniqueId(char* id, size_t max_size) const override { return 0; } - Status InvalidateCache(size_t offset, size_t length) override { + void GetPreallocationStatus(size_t* /*block_size*/, + size_t* /*last_allocated_block*/) override {} + size_t GetUniqueId(char* /*id*/, size_t /*max_size*/) const override { + return 0; + } + Status InvalidateCache(size_t /*offset*/, size_t /*length*/) override { return Status::OK(); } bool use_direct_io() const override { return use_direct_io_; } @@ -180,13 +184,13 @@ TEST_F(WritableFileWriterTest, AppendStatusReturn) { explicit FakeWF() : use_direct_io_(false), io_error_(false) {} virtual bool use_direct_io() const override { return use_direct_io_; } - Status Append(const Slice& data) override { + Status Append(const Slice& /*data*/) override { if (io_error_) { return Status::IOError("Fake IO error"); } return Status::OK(); } - Status PositionedAppend(const Slice& data, uint64_t) override { + Status PositionedAppend(const Slice& /*data*/, uint64_t) override { if (io_error_) { return Status::IOError("Fake IO error"); } diff --git a/util/slice.cc b/util/slice.cc index 10b19080b..d344fbacf 100644 --- a/util/slice.cc +++ b/util/slice.cc @@ -74,7 +74,7 @@ class CappedPrefixTransform : public SliceTransform { return Slice(src.data(), std::min(cap_len_, src.size())); } - virtual bool InDomain(const Slice& src) const override { return true; } + virtual bool InDomain(const Slice& /*src*/) const override { return true; } virtual bool InRange(const Slice& dst) const override { return (dst.size() <= cap_len_); @@ -93,11 +93,11 @@ class NoopTransform : public SliceTransform { virtual Slice Transform(const Slice& src) const override { return src; } - virtual bool InDomain(const Slice& src) const override { return true; } + virtual bool InDomain(const Slice& /*src*/) const override { return true; } - virtual bool InRange(const Slice& dst) const override { return true; } + virtual bool InRange(const Slice& /*dst*/) const override { return true; } - virtual bool SameResultWhenAppended(const Slice& prefix) const override { + virtual bool SameResultWhenAppended(const Slice& /*prefix*/) const override { return false; } }; diff --git a/util/testutil.cc b/util/testutil.cc index ecc4cbe14..1aa4bce75 100644 --- a/util/testutil.cc +++ b/util/testutil.cc @@ -107,12 +107,12 @@ class Uint64ComparatorImpl : public Comparator { } } - virtual void FindShortestSeparator(std::string* start, - const Slice& limit) const override { + virtual void FindShortestSeparator(std::string* /*start*/, + const Slice& /*limit*/) const override { return; } - virtual void FindShortSuccessor(std::string* key) const override { + virtual void FindShortSuccessor(std::string* /*key*/) const override { return; } }; diff --git a/util/testutil.h b/util/testutil.h index 6683963af..62a4de1ab 100644 --- a/util/testutil.h +++ b/util/testutil.h @@ -123,10 +123,10 @@ class SimpleSuffixReverseComparator : public Comparator { return -(suffix_a.compare(suffix_b)); } } - virtual void FindShortestSeparator(std::string* start, - const Slice& limit) const override {} + virtual void FindShortestSeparator(std::string* /*start*/, + const Slice& /*limit*/) const override {} - virtual void FindShortSuccessor(std::string* key) const override {} + virtual void FindShortSuccessor(std::string* /*key*/) const override {} }; // Returns a user key comparator that can be used for comparing two uint64_t @@ -257,7 +257,8 @@ class RandomRWStringSink : public RandomRWFile { return Status::OK(); } - Status Read(uint64_t offset, size_t n, Slice* result, char* scratch) const { + Status Read(uint64_t offset, size_t n, Slice* result, + char* /*scratch*/) const { *result = Slice(nullptr, 0); if (offset < ss_->contents_.size()) { size_t str_res_sz = @@ -378,7 +379,7 @@ class StringSource: public RandomAccessFile { class NullLogger : public Logger { public: using Logger::Logv; - virtual void Logv(const char* format, va_list ap) override {} + virtual void Logv(const char* /*format*/, va_list /*ap*/) override {} virtual size_t GetLogFileSize() const override { return 0; } }; @@ -459,15 +460,16 @@ class FilterNumber : public CompactionFilter { std::string last_merge_operand_key() { return last_merge_operand_key_; } - bool Filter(int level, const rocksdb::Slice& key, const rocksdb::Slice& value, - std::string* new_value, bool* value_changed) const override { + bool Filter(int /*level*/, const rocksdb::Slice& /*key*/, + const rocksdb::Slice& value, std::string* /*new_value*/, + bool* /*value_changed*/) const override { if (value.size() == sizeof(uint64_t)) { return num_ == DecodeFixed64(value.data()); } return true; } - bool FilterMergeOperand(int level, const rocksdb::Slice& key, + bool FilterMergeOperand(int /*level*/, const rocksdb::Slice& key, const rocksdb::Slice& value) const override { last_merge_operand_key_ = key.ToString(); if (value.size() == sizeof(uint64_t)) { @@ -565,7 +567,7 @@ class StringEnv : public EnvWrapper { // The following text is boilerplate that forwards all methods to target() Status NewSequentialFile(const std::string& f, unique_ptr* r, - const EnvOptions& options) override { + const EnvOptions& /*options*/) override { auto iter = files_.find(f); if (iter == files_.end()) { return Status::NotFound("The specified file does not exist", f); @@ -573,13 +575,13 @@ class StringEnv : public EnvWrapper { r->reset(new SeqStringSource(iter->second)); return Status::OK(); } - Status NewRandomAccessFile(const std::string& f, - unique_ptr* r, - const EnvOptions& options) override { + Status NewRandomAccessFile(const std::string& /*f*/, + unique_ptr* /*r*/, + const EnvOptions& /*options*/) override { return Status::NotSupported(); } Status NewWritableFile(const std::string& f, unique_ptr* r, - const EnvOptions& options) override { + const EnvOptions& /*options*/) override { auto iter = files_.find(f); if (iter != files_.end()) { return Status::IOError("The specified file already exists", f); @@ -587,8 +589,8 @@ class StringEnv : public EnvWrapper { r->reset(new StringSink(&files_[f])); return Status::OK(); } - virtual Status NewDirectory(const std::string& name, - unique_ptr* result) override { + virtual Status NewDirectory(const std::string& /*name*/, + unique_ptr* /*result*/) override { return Status::NotSupported(); } Status FileExists(const std::string& f) override { @@ -597,21 +599,21 @@ class StringEnv : public EnvWrapper { } return Status::OK(); } - Status GetChildren(const std::string& dir, - std::vector* r) override { + Status GetChildren(const std::string& /*dir*/, + std::vector* /*r*/) override { return Status::NotSupported(); } Status DeleteFile(const std::string& f) override { files_.erase(f); return Status::OK(); } - Status CreateDir(const std::string& d) override { + Status CreateDir(const std::string& /*d*/) override { return Status::NotSupported(); } - Status CreateDirIfMissing(const std::string& d) override { + Status CreateDirIfMissing(const std::string& /*d*/) override { return Status::NotSupported(); } - Status DeleteDir(const std::string& d) override { + Status DeleteDir(const std::string& /*d*/) override { return Status::NotSupported(); } Status GetFileSize(const std::string& f, uint64_t* s) override { @@ -623,24 +625,25 @@ class StringEnv : public EnvWrapper { return Status::OK(); } - Status GetFileModificationTime(const std::string& fname, - uint64_t* file_mtime) override { + Status GetFileModificationTime(const std::string& /*fname*/, + uint64_t* /*file_mtime*/) override { return Status::NotSupported(); } - Status RenameFile(const std::string& s, const std::string& t) override { + Status RenameFile(const std::string& /*s*/, + const std::string& /*t*/) override { return Status::NotSupported(); } - Status LinkFile(const std::string& s, const std::string& t) override { + Status LinkFile(const std::string& /*s*/, const std::string& /*t*/) override { return Status::NotSupported(); } - Status LockFile(const std::string& f, FileLock** l) override { + Status LockFile(const std::string& /*f*/, FileLock** /*l*/) override { return Status::NotSupported(); } - Status UnlockFile(FileLock* l) override { return Status::NotSupported(); } + Status UnlockFile(FileLock* /*l*/) override { return Status::NotSupported(); } protected: std::unordered_map files_; @@ -663,14 +666,14 @@ class ChanglingMergeOperator : public MergeOperator { void SetName(const std::string& name) { name_ = name; } - virtual bool FullMergeV2(const MergeOperationInput& merge_in, - MergeOperationOutput* merge_out) const override { + virtual bool FullMergeV2(const MergeOperationInput& /*merge_in*/, + MergeOperationOutput* /*merge_out*/) const override { return false; } - virtual bool PartialMergeMulti(const Slice& key, - const std::deque& operand_list, - std::string* new_value, - Logger* logger) const override { + virtual bool PartialMergeMulti(const Slice& /*key*/, + const std::deque& /*operand_list*/, + std::string* /*new_value*/, + Logger* /*logger*/) const override { return false; } virtual const char* Name() const override { return name_.c_str(); } @@ -691,8 +694,9 @@ class ChanglingCompactionFilter : public CompactionFilter { void SetName(const std::string& name) { name_ = name; } - bool Filter(int level, const Slice& key, const Slice& existing_value, - std::string* new_value, bool* value_changed) const override { + bool Filter(int /*level*/, const Slice& /*key*/, + const Slice& /*existing_value*/, std::string* /*new_value*/, + bool* /*value_changed*/) const override { return false; } @@ -715,7 +719,7 @@ class ChanglingCompactionFilterFactory : public CompactionFilterFactory { void SetName(const std::string& name) { name_ = name; } std::unique_ptr CreateCompactionFilter( - const CompactionFilter::Context& context) override { + const CompactionFilter::Context& /*context*/) override { return std::unique_ptr(); } diff --git a/util/thread_local_test.cc b/util/thread_local_test.cc index 6fee5eaa5..789be83d8 100644 --- a/util/thread_local_test.cc +++ b/util/thread_local_test.cc @@ -535,7 +535,7 @@ TEST_F(ThreadLocalTest, CompareAndSwap) { namespace { -void* AccessThreadLocal(void* arg) { +void* AccessThreadLocal(void* /*arg*/) { TEST_SYNC_POINT("AccessThreadLocal:Start"); ThreadLocalPtr tlp; tlp.Reset(new std::string("hello RocksDB")); diff --git a/utilities/backupable/backupable_db_test.cc b/utilities/backupable/backupable_db_test.cc index b31d273d1..714a8d465 100644 --- a/utilities/backupable/backupable_db_test.cc +++ b/utilities/backupable/backupable_db_test.cc @@ -57,7 +57,8 @@ class DummyDB : public StackableDB { } using DB::GetOptions; - virtual Options GetOptions(ColumnFamilyHandle* column_family) const override { + virtual Options GetOptions( + ColumnFamilyHandle* /*column_family*/) const override { return options_; } @@ -65,7 +66,7 @@ class DummyDB : public StackableDB { return DBOptions(options_); } - virtual Status EnableFileDeletions(bool force) override { + virtual Status EnableFileDeletions(bool /*force*/) override { EXPECT_TRUE(!deletions_enabled_); deletions_enabled_ = true; return Status::OK(); @@ -78,7 +79,7 @@ class DummyDB : public StackableDB { } virtual Status GetLiveFiles(std::vector& vec, uint64_t* mfs, - bool flush_memtable = true) override { + bool /*flush_memtable*/ = true) override { EXPECT_TRUE(!deletions_enabled_); vec = live_files_; *mfs = 100; @@ -135,7 +136,7 @@ class DummyDB : public StackableDB { } // To avoid FlushWAL called on stacked db which is nullptr - virtual Status FlushWAL(bool sync) override { return Status::OK(); } + virtual Status FlushWAL(bool /*sync*/) override { return Status::OK(); } std::vector live_files_; // pair @@ -521,7 +522,7 @@ class BackupableDBTest : public testing::Test { void OpenDBAndBackupEngineShareWithChecksum( bool destroy_old_data = false, bool dummy = false, - bool share_table_files = true, bool share_with_checksums = false) { + bool /*share_table_files*/ = true, bool share_with_checksums = false) { backupable_options_->share_files_with_checksum = share_with_checksums; OpenDBAndBackupEngine(destroy_old_data, dummy, share_with_checksums); } diff --git a/utilities/blob_db/blob_db_impl.cc b/utilities/blob_db/blob_db_impl.cc index c8914ebf0..7a6874c95 100644 --- a/utilities/blob_db/blob_db_impl.cc +++ b/utilities/blob_db/blob_db_impl.cc @@ -44,14 +44,16 @@ int kBlockBasedTableVersionFormat = 2; namespace rocksdb { namespace blob_db { -void BlobDBFlushBeginListener::OnFlushBegin(DB* db, const FlushJobInfo& info) { +void BlobDBFlushBeginListener::OnFlushBegin(DB* /*db*/, + const FlushJobInfo& /*info*/) { assert(blob_db_impl_ != nullptr); blob_db_impl_->SyncBlobFiles(); } WalFilter::WalProcessingOption BlobReconcileWalFilter::LogRecordFound( - unsigned long long log_number, const std::string& log_file_name, - const WriteBatch& batch, WriteBatch* new_batch, bool* batch_changed) { + unsigned long long /*log_number*/, const std::string& /*log_file_name*/, + const WriteBatch& /*batch*/, WriteBatch* /*new_batch*/, + bool* /*batch_changed*/) { return WalFilter::WalProcessingOption::kContinueProcessing; } @@ -658,9 +660,9 @@ Status BlobDBImpl::PutUntil(const WriteOptions& options, const Slice& key, return s; } -Status BlobDBImpl::PutBlobValue(const WriteOptions& options, const Slice& key, - const Slice& value, uint64_t expiration, - WriteBatch* batch) { +Status BlobDBImpl::PutBlobValue(const WriteOptions& /*options*/, + const Slice& key, const Slice& value, + uint64_t expiration, WriteBatch* batch) { Status s; std::string index_entry; uint32_t column_family_id = diff --git a/utilities/blob_db/blob_db_impl.h b/utilities/blob_db/blob_db_impl.h index d120ea258..38d1580bb 100644 --- a/utilities/blob_db/blob_db_impl.h +++ b/utilities/blob_db/blob_db_impl.h @@ -140,9 +140,9 @@ class BlobDBImpl : public BlobDB { using BlobDB::NewIterators; virtual Status NewIterators( - const ReadOptions& read_options, - const std::vector& column_families, - std::vector* iterators) override { + const ReadOptions& /*read_options*/, + const std::vector& /*column_families*/, + std::vector* /*iterators*/) override { return Status::NotSupported("Not implemented"); } diff --git a/utilities/cassandra/cassandra_compaction_filter.cc b/utilities/cassandra/cassandra_compaction_filter.cc index af3e9a779..1b99d3a8b 100644 --- a/utilities/cassandra/cassandra_compaction_filter.cc +++ b/utilities/cassandra/cassandra_compaction_filter.cc @@ -17,13 +17,9 @@ const char* CassandraCompactionFilter::Name() const { } CompactionFilter::Decision CassandraCompactionFilter::FilterV2( - int level, - const Slice& key, - ValueType value_type, - const Slice& existing_value, - std::string* new_value, - std::string* skip_until) const { - + int /*level*/, const Slice& /*key*/, ValueType value_type, + const Slice& existing_value, std::string* new_value, + std::string* /*skip_until*/) const { bool value_changed = false; RowValue row_value = RowValue::Deserialize( existing_value.data(), existing_value.size()); diff --git a/utilities/cassandra/cassandra_functional_test.cc b/utilities/cassandra/cassandra_functional_test.cc index 5bd19cadb..895c25177 100644 --- a/utilities/cassandra/cassandra_functional_test.cc +++ b/utilities/cassandra/cassandra_functional_test.cc @@ -100,7 +100,7 @@ public: gc_grace_period_in_seconds_(gc_grace_period_in_seconds) {} virtual std::unique_ptr CreateCompactionFilter( - const CompactionFilter::Context& context) override { + const CompactionFilter::Context& /*context*/) override { return unique_ptr(new CassandraCompactionFilter( purge_ttl_on_expiration_, gc_grace_period_in_seconds_)); } diff --git a/utilities/cassandra/merge_operator.cc b/utilities/cassandra/merge_operator.cc index ffd313403..4e529a6f2 100644 --- a/utilities/cassandra/merge_operator.cc +++ b/utilities/cassandra/merge_operator.cc @@ -42,10 +42,8 @@ bool CassandraValueMergeOperator::FullMergeV2( } bool CassandraValueMergeOperator::PartialMergeMulti( - const Slice& key, - const std::deque& operand_list, - std::string* new_value, - Logger* logger) const { + const Slice& /*key*/, const std::deque& operand_list, + std::string* new_value, Logger* /*logger*/) const { // Clear the *new_value for writing. assert(new_value); new_value->clear(); diff --git a/utilities/checkpoint/checkpoint_impl.cc b/utilities/checkpoint/checkpoint_impl.cc index d93c7095f..9135dbabf 100644 --- a/utilities/checkpoint/checkpoint_impl.cc +++ b/utilities/checkpoint/checkpoint_impl.cc @@ -37,8 +37,8 @@ Status Checkpoint::Create(DB* db, Checkpoint** checkpoint_ptr) { return Status::OK(); } -Status Checkpoint::CreateCheckpoint(const std::string& checkpoint_dir, - uint64_t log_size_for_flush) { +Status Checkpoint::CreateCheckpoint(const std::string& /*checkpoint_dir*/, + uint64_t /*log_size_for_flush*/) { return Status::NotSupported(""); } diff --git a/utilities/col_buf_decoder.h b/utilities/col_buf_decoder.h index 0311a4100..cea952637 100644 --- a/utilities/col_buf_decoder.h +++ b/utilities/col_buf_decoder.h @@ -23,7 +23,7 @@ struct ColDeclaration; class ColBufDecoder { public: virtual ~ColBufDecoder() = 0; - virtual size_t Init(const char* src) { return 0; } + virtual size_t Init(const char* /*src*/) { return 0; } virtual size_t Decode(const char* src, char** dest) = 0; static ColBufDecoder* NewColBufDecoder(const ColDeclaration& col_declaration); diff --git a/utilities/compaction_filters/remove_emptyvalue_compactionfilter.cc b/utilities/compaction_filters/remove_emptyvalue_compactionfilter.cc index 43a252934..49760ba5a 100644 --- a/utilities/compaction_filters/remove_emptyvalue_compactionfilter.cc +++ b/utilities/compaction_filters/remove_emptyvalue_compactionfilter.cc @@ -16,12 +16,11 @@ const char* RemoveEmptyValueCompactionFilter::Name() const { return "RemoveEmptyValueCompactionFilter"; } -bool RemoveEmptyValueCompactionFilter::Filter(int level, - const Slice& key, - const Slice& existing_value, - std::string* new_value, - bool* value_changed) const { - +bool RemoveEmptyValueCompactionFilter::Filter(int /*level*/, + const Slice& /*key*/, + const Slice& existing_value, + std::string* /*new_value*/, + bool* /*value_changed*/) const { // remove kv pairs that have empty values return existing_value.empty(); } diff --git a/utilities/document/document_db.cc b/utilities/document/document_db.cc index 90b21bbe7..939327ed1 100644 --- a/utilities/document/document_db.cc +++ b/utilities/document/document_db.cc @@ -1044,24 +1044,25 @@ class DocumentDBImpl : public DocumentDB { // RocksDB functions using DB::Get; - virtual Status Get(const ReadOptions& options, - ColumnFamilyHandle* column_family, const Slice& key, - PinnableSlice* value) override { + virtual Status Get(const ReadOptions& /*options*/, + ColumnFamilyHandle* /*column_family*/, + const Slice& /*key*/, PinnableSlice* /*value*/) override { return Status::NotSupported(""); } - virtual Status Get(const ReadOptions& options, const Slice& key, - std::string* value) override { + virtual Status Get(const ReadOptions& /*options*/, const Slice& /*key*/, + std::string* /*value*/) override { return Status::NotSupported(""); } - virtual Status Write(const WriteOptions& options, - WriteBatch* updates) override { + virtual Status Write(const WriteOptions& /*options*/, + WriteBatch* /*updates*/) override { return Status::NotSupported(""); } - virtual Iterator* NewIterator(const ReadOptions& options, - ColumnFamilyHandle* column_family) override { + virtual Iterator* NewIterator( + const ReadOptions& /*options*/, + ColumnFamilyHandle* /*column_family*/) override { return nullptr; } - virtual Iterator* NewIterator(const ReadOptions& options) override { + virtual Iterator* NewIterator(const ReadOptions& /*options*/) override { return nullptr; } diff --git a/utilities/merge_operators/max.cc b/utilities/merge_operators/max.cc index 5f42e816e..732f203e3 100644 --- a/utilities/merge_operators/max.cc +++ b/utilities/merge_operators/max.cc @@ -38,9 +38,9 @@ class MaxOperator : public MergeOperator { return true; } - virtual bool PartialMerge(const Slice& key, const Slice& left_operand, + virtual bool PartialMerge(const Slice& /*key*/, const Slice& left_operand, const Slice& right_operand, std::string* new_value, - Logger* logger) const override { + Logger* /*logger*/) const override { if (left_operand.compare(right_operand) >= 0) { new_value->assign(left_operand.data(), left_operand.size()); } else { @@ -49,10 +49,10 @@ class MaxOperator : public MergeOperator { return true; } - virtual bool PartialMergeMulti(const Slice& key, + virtual bool PartialMergeMulti(const Slice& /*key*/, const std::deque& operand_list, std::string* new_value, - Logger* logger) const override { + Logger* /*logger*/) const override { Slice max; for (const auto& operand : operand_list) { if (max.compare(operand) < 0) { diff --git a/utilities/merge_operators/put.cc b/utilities/merge_operators/put.cc index 7f206ad3b..fcbf67d9b 100644 --- a/utilities/merge_operators/put.cc +++ b/utilities/merge_operators/put.cc @@ -22,11 +22,10 @@ namespace { // anonymous namespace // From the client-perspective, semantics are the same. class PutOperator : public MergeOperator { public: - virtual bool FullMerge(const Slice& key, - const Slice* existing_value, + virtual bool FullMerge(const Slice& /*key*/, const Slice* /*existing_value*/, const std::deque& operand_sequence, std::string* new_value, - Logger* logger) const override { + Logger* /*logger*/) const override { // Put basically only looks at the current/latest value assert(!operand_sequence.empty()); assert(new_value != nullptr); @@ -34,20 +33,18 @@ class PutOperator : public MergeOperator { return true; } - virtual bool PartialMerge(const Slice& key, - const Slice& left_operand, - const Slice& right_operand, - std::string* new_value, - Logger* logger) const override { + virtual bool PartialMerge(const Slice& /*key*/, const Slice& /*left_operand*/, + const Slice& right_operand, std::string* new_value, + Logger* /*logger*/) const override { new_value->assign(right_operand.data(), right_operand.size()); return true; } using MergeOperator::PartialMergeMulti; - virtual bool PartialMergeMulti(const Slice& key, + virtual bool PartialMergeMulti(const Slice& /*key*/, const std::deque& operand_list, - std::string* new_value, Logger* logger) const - override { + std::string* new_value, + Logger* /*logger*/) const override { new_value->assign(operand_list.back().data(), operand_list.back().size()); return true; } @@ -58,10 +55,10 @@ class PutOperator : public MergeOperator { }; class PutOperatorV2 : public PutOperator { - virtual bool FullMerge(const Slice& key, const Slice* existing_value, - const std::deque& operand_sequence, - std::string* new_value, - Logger* logger) const override { + virtual bool FullMerge(const Slice& /*key*/, const Slice* /*existing_value*/, + const std::deque& /*operand_sequence*/, + std::string* /*new_value*/, + Logger* /*logger*/) const override { assert(false); return false; } diff --git a/utilities/merge_operators/string_append/stringappend.cc b/utilities/merge_operators/string_append/stringappend.cc index ff19348f0..e3e755dfd 100644 --- a/utilities/merge_operators/string_append/stringappend.cc +++ b/utilities/merge_operators/string_append/stringappend.cc @@ -21,12 +21,10 @@ StringAppendOperator::StringAppendOperator(char delim_char) } // Implementation for the merge operation (concatenates two strings) -bool StringAppendOperator::Merge(const Slice& key, +bool StringAppendOperator::Merge(const Slice& /*key*/, const Slice* existing_value, - const Slice& value, - std::string* new_value, - Logger* logger) const { - + const Slice& value, std::string* new_value, + Logger* /*logger*/) const { // Clear the *new_value for writing. assert(new_value); new_value->clear(); diff --git a/utilities/merge_operators/string_append/stringappend2.cc b/utilities/merge_operators/string_append/stringappend2.cc index 2d7b7423c..6e46d80a1 100644 --- a/utilities/merge_operators/string_append/stringappend2.cc +++ b/utilities/merge_operators/string_append/stringappend2.cc @@ -68,16 +68,16 @@ bool StringAppendTESTOperator::FullMergeV2( } bool StringAppendTESTOperator::PartialMergeMulti( - const Slice& key, const std::deque& operand_list, - std::string* new_value, Logger* logger) const { + const Slice& /*key*/, const std::deque& /*operand_list*/, + std::string* /*new_value*/, Logger* /*logger*/) const { return false; } // A version of PartialMerge that actually performs "partial merging". // Use this to simulate the exact behaviour of the StringAppendOperator. bool StringAppendTESTOperator::_AssocPartialMergeMulti( - const Slice& key, const std::deque& operand_list, - std::string* new_value, Logger* logger) const { + const Slice& /*key*/, const std::deque& operand_list, + std::string* new_value, Logger* /*logger*/) const { // Clear the *new_value for writing assert(new_value); new_value->clear(); diff --git a/utilities/merge_operators/uint64add.cc b/utilities/merge_operators/uint64add.cc index d78217375..dc761e74b 100644 --- a/utilities/merge_operators/uint64add.cc +++ b/utilities/merge_operators/uint64add.cc @@ -20,10 +20,8 @@ namespace { // anonymous namespace // Implemented as an AssociativeMergeOperator for simplicity and example. class UInt64AddOperator : public AssociativeMergeOperator { public: - virtual bool Merge(const Slice& key, - const Slice* existing_value, - const Slice& value, - std::string* new_value, + virtual bool Merge(const Slice& /*key*/, const Slice* existing_value, + const Slice& value, std::string* new_value, Logger* logger) const override { uint64_t orig_value = 0; if (existing_value){ diff --git a/utilities/object_registry_test.cc b/utilities/object_registry_test.cc index 40fb387bc..fe69d9a39 100644 --- a/utilities/object_registry_test.cc +++ b/utilities/object_registry_test.cc @@ -18,13 +18,14 @@ class EnvRegistryTest : public testing::Test { int EnvRegistryTest::num_a = 0; int EnvRegistryTest::num_b = 0; -static Registrar test_reg_a("a://.*", [](const std::string& uri, - std::unique_ptr* env_guard) { - ++EnvRegistryTest::num_a; - return Env::Default(); -}); +static Registrar test_reg_a("a://.*", + [](const std::string& /*uri*/, + std::unique_ptr* /*env_guard*/) { + ++EnvRegistryTest::num_a; + return Env::Default(); + }); -static Registrar test_reg_b("b://.*", [](const std::string& uri, +static Registrar test_reg_b("b://.*", [](const std::string& /*uri*/, std::unique_ptr* env_guard) { ++EnvRegistryTest::num_b; // Env::Default() is a singleton so we can't grant ownership directly to the diff --git a/utilities/options/options_util_test.cc b/utilities/options/options_util_test.cc index 6a4efd778..ef5bbdfe6 100644 --- a/utilities/options/options_util_test.cc +++ b/utilities/options/options_util_test.cc @@ -103,29 +103,30 @@ class DummyTableFactory : public TableFactory { virtual const char* Name() const override { return "DummyTableFactory"; } virtual Status NewTableReader( - const TableReaderOptions& table_reader_options, - unique_ptr&& file, uint64_t file_size, - unique_ptr* table_reader, - bool prefetch_index_and_filter_in_cache) const override { + const TableReaderOptions& /*table_reader_options*/, + unique_ptr&& /*file*/, uint64_t /*file_size*/, + unique_ptr* /*table_reader*/, + bool /*prefetch_index_and_filter_in_cache*/) const override { return Status::NotSupported(); } virtual TableBuilder* NewTableBuilder( - const TableBuilderOptions& table_builder_options, - uint32_t column_family_id, WritableFileWriter* file) const override { + const TableBuilderOptions& /*table_builder_options*/, + uint32_t /*column_family_id*/, + WritableFileWriter* /*file*/) const override { return nullptr; } virtual Status SanitizeOptions( - const DBOptions& db_opts, - const ColumnFamilyOptions& cf_opts) const override { + const DBOptions& /*db_opts*/, + const ColumnFamilyOptions& /*cf_opts*/) const override { return Status::NotSupported(); } virtual std::string GetPrintableTableOptions() const override { return ""; } - Status GetOptionString(std::string* opt_string, - const std::string& delimiter) const override { + Status GetOptionString(std::string* /*opt_string*/, + const std::string& /*delimiter*/) const override { return Status::OK(); } }; @@ -135,15 +136,15 @@ class DummyMergeOperator : public MergeOperator { DummyMergeOperator() {} virtual ~DummyMergeOperator() {} - virtual bool FullMergeV2(const MergeOperationInput& merge_in, - MergeOperationOutput* merge_out) const override { + virtual bool FullMergeV2(const MergeOperationInput& /*merge_in*/, + MergeOperationOutput* /*merge_out*/) const override { return false; } - virtual bool PartialMergeMulti(const Slice& key, - const std::deque& operand_list, - std::string* new_value, - Logger* logger) const override { + virtual bool PartialMergeMulti(const Slice& /*key*/, + const std::deque& /*operand_list*/, + std::string* /*new_value*/, + Logger* /*logger*/) const override { return false; } @@ -162,10 +163,10 @@ class DummySliceTransform : public SliceTransform { virtual Slice Transform(const Slice& src) const { return src; } // determine whether this is a valid src upon the function applies - virtual bool InDomain(const Slice& src) const { return false; } + virtual bool InDomain(const Slice& /*src*/) const { return false; } // determine whether dst=Transform(src) for some src - virtual bool InRange(const Slice& dst) const { return false; } + virtual bool InRange(const Slice& /*dst*/) const { return false; } }; } // namespace diff --git a/utilities/persistent_cache/block_cache_tier_file.cc b/utilities/persistent_cache/block_cache_tier_file.cc index 9e419563a..ce6335fb5 100644 --- a/utilities/persistent_cache/block_cache_tier_file.cc +++ b/utilities/persistent_cache/block_cache_tier_file.cc @@ -278,7 +278,7 @@ WriteableCacheFile::~WriteableCacheFile() { ClearBuffers(); } -bool WriteableCacheFile::Create(const bool enable_direct_writes, +bool WriteableCacheFile::Create(const bool /*enable_direct_writes*/, const bool enable_direct_reads) { WriteLock _(&rwlock_); diff --git a/utilities/persistent_cache/block_cache_tier_file.h b/utilities/persistent_cache/block_cache_tier_file.h index 3922136d6..ef5dbab04 100644 --- a/utilities/persistent_cache/block_cache_tier_file.h +++ b/utilities/persistent_cache/block_cache_tier_file.h @@ -103,13 +103,15 @@ class BlockCacheFile : public LRUElement { virtual ~BlockCacheFile() {} // append key/value to file and return LBA locator to user - virtual bool Append(const Slice& key, const Slice& val, LBA* const lba) { + virtual bool Append(const Slice& /*key*/, const Slice& /*val*/, + LBA* const /*lba*/) { assert(!"not implemented"); return false; } // read from the record locator (LBA) and return key, value and status - virtual bool Read(const LBA& lba, Slice* key, Slice* block, char* scratch) { + virtual bool Read(const LBA& /*lba*/, Slice* /*key*/, Slice* /*block*/, + char* /*scratch*/) { assert(!"not implemented"); return false; } diff --git a/utilities/persistent_cache/hash_table_test.cc b/utilities/persistent_cache/hash_table_test.cc index 1a6df4e61..6fe5a5965 100644 --- a/utilities/persistent_cache/hash_table_test.cc +++ b/utilities/persistent_cache/hash_table_test.cc @@ -43,7 +43,7 @@ struct HashTableTest : public testing::Test { } }; - static void ClearNode(Node node) {} + static void ClearNode(Node /*node*/) {} HashTable map_; }; @@ -73,7 +73,7 @@ struct EvictableHashTableTest : public testing::Test { } }; - static void ClearNode(Node* node) {} + static void ClearNode(Node* /*node*/) {} EvictableHashTable map_; }; diff --git a/utilities/persistent_cache/persistent_cache_test.h b/utilities/persistent_cache/persistent_cache_test.h index 77fd172ba..37e842f2e 100644 --- a/utilities/persistent_cache/persistent_cache_test.h +++ b/utilities/persistent_cache/persistent_cache_test.h @@ -233,8 +233,8 @@ class PersistentCacheDBTest : public DBTestBase { // insert data to table void Insert(const Options& options, - const BlockBasedTableOptions& table_options, const int num_iter, - std::vector* values) { + const BlockBasedTableOptions& /*table_options*/, + const int num_iter, std::vector* values) { CreateAndReopenWithCF({"pikachu"}, options); // default column family doesn't have block cache Options no_block_cache_opts; diff --git a/utilities/persistent_cache/persistent_cache_tier.cc b/utilities/persistent_cache/persistent_cache_tier.cc index 0f500e871..732762a16 100644 --- a/utilities/persistent_cache/persistent_cache_tier.cc +++ b/utilities/persistent_cache/persistent_cache_tier.cc @@ -75,12 +75,12 @@ Status PersistentCacheTier::Close() { return Status::OK(); } -bool PersistentCacheTier::Reserve(const size_t size) { +bool PersistentCacheTier::Reserve(const size_t /*size*/) { // default implementation is a pass through return true; } -bool PersistentCacheTier::Erase(const Slice& key) { +bool PersistentCacheTier::Erase(const Slice& /*key*/) { // default implementation is a pass through since not all cache tiers might // support erase return true; diff --git a/utilities/persistent_cache/volatile_tier_impl.cc b/utilities/persistent_cache/volatile_tier_impl.cc index d190a2102..177fc9169 100644 --- a/utilities/persistent_cache/volatile_tier_impl.cc +++ b/utilities/persistent_cache/volatile_tier_impl.cc @@ -106,7 +106,7 @@ Status VolatileCacheTier::Lookup(const Slice& page_key, return Status::NotFound("key not found in volatile cache"); } -bool VolatileCacheTier::Erase(const Slice& key) { +bool VolatileCacheTier::Erase(const Slice& /*key*/) { assert(!"not supported"); return true; } diff --git a/utilities/redis/redis_list_iterator.h b/utilities/redis/redis_list_iterator.h index 73907ddf8..1c4bc11e5 100644 --- a/utilities/redis/redis_list_iterator.h +++ b/utilities/redis/redis_list_iterator.h @@ -288,7 +288,7 @@ class RedisListIterator { /// Will throw an exception based on the passed-in message. /// This function is guaranteed to STOP THE CONTROL-FLOW. /// (i.e.: you do not have to call "return" after calling ThrowError) - void ThrowError(const char* const msg = NULL) { + void ThrowError(const char* const /*msg*/ = NULL) { // TODO: For now we ignore the msg parameter. This can be expanded later. throw RedisListException(); } diff --git a/utilities/simulator_cache/sim_cache_test.cc b/utilities/simulator_cache/sim_cache_test.cc index 4e9793817..0e504d443 100644 --- a/utilities/simulator_cache/sim_cache_test.cc +++ b/utilities/simulator_cache/sim_cache_test.cc @@ -39,7 +39,7 @@ class SimCacheTest : public DBTestBase { return options; } - void InitTable(const Options& options) { + void InitTable(const Options& /*options*/) { std::string value(kValueSize, 'a'); for (size_t i = 0; i < kNumBlocks * 2; i++) { ASSERT_OK(Put(ToString(i), value.c_str())); diff --git a/utilities/spatialdb/spatial_db.cc b/utilities/spatialdb/spatial_db.cc index 539ddd06e..a9b990ee2 100644 --- a/utilities/spatialdb/spatial_db.cc +++ b/utilities/spatialdb/spatial_db.cc @@ -704,7 +704,7 @@ DBOptions GetDBOptionsFromSpatialDBOptions(const SpatialDBOptions& options) { return db_options; } -ColumnFamilyOptions GetColumnFamilyOptions(const SpatialDBOptions& options, +ColumnFamilyOptions GetColumnFamilyOptions(const SpatialDBOptions& /*options*/, std::shared_ptr block_cache) { ColumnFamilyOptions column_family_options; column_family_options.write_buffer_size = 128 * 1024 * 1024; // 128MB diff --git a/utilities/table_properties_collectors/compact_on_deletion_collector.cc b/utilities/table_properties_collectors/compact_on_deletion_collector.cc index 1d6f96952..fdb7389a7 100644 --- a/utilities/table_properties_collectors/compact_on_deletion_collector.cc +++ b/utilities/table_properties_collectors/compact_on_deletion_collector.cc @@ -29,10 +29,11 @@ CompactOnDeletionCollector::CompactOnDeletionCollector( // @params key the user key that is inserted into the table. // @params value the value that is inserted into the table. // @params file_size file size up to now -Status CompactOnDeletionCollector::AddUserKey( - const Slice& key, const Slice& value, - EntryType type, SequenceNumber seq, - uint64_t file_size) { +Status CompactOnDeletionCollector::AddUserKey(const Slice& /*key*/, + const Slice& /*value*/, + EntryType type, + SequenceNumber /*seq*/, + uint64_t /*file_size*/) { assert(!finished_); if (need_compaction_) { // If the output file already needs to be compacted, skip the check. @@ -68,7 +69,7 @@ Status CompactOnDeletionCollector::AddUserKey( TablePropertiesCollector* CompactOnDeletionCollectorFactory::CreateTablePropertiesCollector( - TablePropertiesCollectorFactory::Context context) { + TablePropertiesCollectorFactory::Context /*context*/) { return new CompactOnDeletionCollector( sliding_window_size_, deletion_trigger_); } diff --git a/utilities/table_properties_collectors/compact_on_deletion_collector.h b/utilities/table_properties_collectors/compact_on_deletion_collector.h index 9b8205108..5406ecea2 100644 --- a/utilities/table_properties_collectors/compact_on_deletion_collector.h +++ b/utilities/table_properties_collectors/compact_on_deletion_collector.h @@ -60,7 +60,7 @@ class CompactOnDeletionCollector : public TablePropertiesCollector { // for writing the properties block. // @params properties User will add their collected statistics to // `properties`. - virtual Status Finish(UserCollectedProperties* properties) override { + virtual Status Finish(UserCollectedProperties* /*properties*/) override { finished_ = true; return Status::OK(); } diff --git a/utilities/table_properties_collectors/compact_on_deletion_collector_test.cc b/utilities/table_properties_collectors/compact_on_deletion_collector_test.cc index cfa444139..c0768ec5b 100644 --- a/utilities/table_properties_collectors/compact_on_deletion_collector_test.cc +++ b/utilities/table_properties_collectors/compact_on_deletion_collector_test.cc @@ -20,7 +20,7 @@ #include "util/random.h" #include "utilities/table_properties_collectors/compact_on_deletion_collector.h" -int main(int argc, char** argv) { +int main(int /*argc*/, char** /*argv*/) { const int kWindowSizes[] = {1000, 10000, 10000, 127, 128, 129, 255, 256, 257, 2, 10000}; const int kDeletionTriggers[] = diff --git a/utilities/transactions/transaction_base.h b/utilities/transactions/transaction_base.h index d336eb3a7..d42a6d1ba 100644 --- a/utilities/transactions/transaction_base.h +++ b/utilities/transactions/transaction_base.h @@ -180,7 +180,7 @@ class TransactionBaseImpl : public Transaction { WriteBatchWithIndex* GetWriteBatch() override; - virtual void SetLockTimeout(int64_t timeout) override { /* Do nothing */ + virtual void SetLockTimeout(int64_t /*timeout*/) override { /* Do nothing */ } const Snapshot* GetSnapshot() const override { diff --git a/utilities/transactions/write_prepared_txn.cc b/utilities/transactions/write_prepared_txn.cc index 6f573c324..591a5d3ab 100644 --- a/utilities/transactions/write_prepared_txn.cc +++ b/utilities/transactions/write_prepared_txn.cc @@ -202,7 +202,7 @@ Status WritePreparedTxn::RollbackInternal() { return s; } - Status PutCF(uint32_t cf, const Slice& key, const Slice& val) override { + Status PutCF(uint32_t cf, const Slice& key, const Slice& /*val*/) override { return Rollback(cf, key); } @@ -214,7 +214,8 @@ Status WritePreparedTxn::RollbackInternal() { return Rollback(cf, key); } - Status MergeCF(uint32_t cf, const Slice& key, const Slice& val) override { + Status MergeCF(uint32_t cf, const Slice& key, + const Slice& /*val*/) override { return Rollback(cf, key); } diff --git a/utilities/transactions/write_prepared_txn_db.cc b/utilities/transactions/write_prepared_txn_db.cc index d91bdccaa..9075d5c0b 100644 --- a/utilities/transactions/write_prepared_txn_db.cc +++ b/utilities/transactions/write_prepared_txn_db.cc @@ -239,7 +239,7 @@ struct WritePreparedTxnDB::IteratorState { }; namespace { -static void CleanupWritePreparedTxnDBIterator(void* arg1, void* arg2) { +static void CleanupWritePreparedTxnDBIterator(void* arg1, void* /*arg2*/) { delete reinterpret_cast(arg1); } } // anonymous namespace @@ -436,7 +436,7 @@ void WritePreparedTxnDB::AddPrepared(uint64_t seq) { } void WritePreparedTxnDB::RollbackPrepared(uint64_t prep_seq, - uint64_t rollback_seq) { + uint64_t /*rollback_seq*/) { ROCKS_LOG_DETAILS( info_log_, "Txn %" PRIu64 " rolling back with rollback seq of " PRIu64 "", prep_seq, rollback_seq); diff --git a/utilities/ttl/ttl_test.cc b/utilities/ttl/ttl_test.cc index c404b9a98..7462fbb81 100644 --- a/utilities/ttl/ttl_test.cc +++ b/utilities/ttl/ttl_test.cc @@ -301,8 +301,8 @@ class TtlTest : public testing::Test { // Keeps key if it is in [kSampleSize_/3, 2*kSampleSize_/3), // Change value if it is in [2*kSampleSize_/3, kSampleSize_) // Eg. kSampleSize_=6. Drop:key0-1...Keep:key2-3...Change:key4-5... - virtual bool Filter(int level, const Slice& key, - const Slice& value, std::string* new_value, + virtual bool Filter(int /*level*/, const Slice& key, const Slice& /*value*/, + std::string* new_value, bool* value_changed) const override { assert(new_value != nullptr); @@ -351,7 +351,7 @@ class TtlTest : public testing::Test { } virtual std::unique_ptr CreateCompactionFilter( - const CompactionFilter::Context& context) override { + const CompactionFilter::Context& /*context*/) override { return std::unique_ptr( new TestFilter(kSampleSize_, kNewValue_)); } diff --git a/utilities/write_batch_with_index/write_batch_with_index_test.cc b/utilities/write_batch_with_index/write_batch_with_index_test.cc index 5b1250a64..105f7517d 100644 --- a/utilities/write_batch_with_index/write_batch_with_index_test.cc +++ b/utilities/write_batch_with_index/write_batch_with_index_test.cc @@ -63,7 +63,7 @@ struct TestHandler : public WriteBatch::Handler { seen[column_family_id].push_back(e); return Status::OK(); } - virtual void LogData(const Slice& blob) {} + virtual void LogData(const Slice& /*blob*/) {} virtual Status DeleteCF(uint32_t column_family_id, const Slice& key) { Entry e; e.key = key.ToString();