diff --git a/db/arena_wrapped_db_iter.cc b/db/arena_wrapped_db_iter.cc index 6635bf52b..2bb0ef8d9 100644 --- a/db/arena_wrapped_db_iter.cc +++ b/db/arena_wrapped_db_iter.cc @@ -32,7 +32,7 @@ Status ArenaWrappedDBIter::GetProperty(std::string prop_name, void ArenaWrappedDBIter::Init( Env* env, const ReadOptions& read_options, - const ImmutableCFOptions& cf_options, + const ImmutableOptions& cf_options, const MutableCFOptions& mutable_cf_options, const Version* version, const SequenceNumber& sequence, uint64_t max_sequential_skip_in_iteration, uint64_t version_number, ReadCallback* read_callback, DBImpl* db_impl, @@ -89,7 +89,7 @@ Status ArenaWrappedDBIter::Refresh() { ArenaWrappedDBIter* NewArenaWrappedDbIterator( Env* env, const ReadOptions& read_options, - const ImmutableCFOptions& cf_options, + const ImmutableOptions& cf_options, const MutableCFOptions& mutable_cf_options, const Version* version, const SequenceNumber& sequence, uint64_t max_sequential_skip_in_iterations, uint64_t version_number, ReadCallback* read_callback, DBImpl* db_impl, diff --git a/db/arena_wrapped_db_iter.h b/db/arena_wrapped_db_iter.h index 15377e45c..42f65ec13 100644 --- a/db/arena_wrapped_db_iter.h +++ b/db/arena_wrapped_db_iter.h @@ -72,7 +72,7 @@ class ArenaWrappedDBIter : public Iterator { Status Refresh() override; void Init(Env* env, const ReadOptions& read_options, - const ImmutableCFOptions& cf_options, + const ImmutableOptions& cf_options, const MutableCFOptions& mutable_cf_options, const Version* version, const SequenceNumber& sequence, uint64_t max_sequential_skip_in_iterations, uint64_t version_number, @@ -106,7 +106,7 @@ class ArenaWrappedDBIter : public Iterator { // be supported. extern ArenaWrappedDBIter* NewArenaWrappedDbIterator( Env* env, const ReadOptions& read_options, - const ImmutableCFOptions& cf_options, + const ImmutableOptions& cf_options, const MutableCFOptions& mutable_cf_options, const Version* version, const SequenceNumber& sequence, uint64_t max_sequential_skip_in_iterations, uint64_t version_number, ReadCallback* read_callback, diff --git a/db/blob/blob_file_builder.cc b/db/blob/blob_file_builder.cc index a2de76f62..f27a4e25b 100644 --- a/db/blob/blob_file_builder.cc +++ b/db/blob/blob_file_builder.cc @@ -29,7 +29,7 @@ namespace ROCKSDB_NAMESPACE { BlobFileBuilder::BlobFileBuilder( VersionSet* versions, FileSystem* fs, - const ImmutableCFOptions* immutable_cf_options, + const ImmutableOptions* immutable_cf_options, const MutableCFOptions* mutable_cf_options, const FileOptions* file_options, int job_id, uint32_t column_family_id, const std::string& column_family_name, Env::IOPriority io_priority, @@ -46,7 +46,7 @@ BlobFileBuilder::BlobFileBuilder( BlobFileBuilder::BlobFileBuilder( std::function file_number_generator, FileSystem* fs, - const ImmutableCFOptions* immutable_cf_options, + const ImmutableOptions* immutable_cf_options, const MutableCFOptions* mutable_cf_options, const FileOptions* file_options, int job_id, uint32_t column_family_id, const std::string& column_family_name, Env::IOPriority io_priority, diff --git a/db/blob/blob_file_builder.h b/db/blob/blob_file_builder.h index 965314379..fc00097da 100644 --- a/db/blob/blob_file_builder.h +++ b/db/blob/blob_file_builder.h @@ -19,7 +19,7 @@ namespace ROCKSDB_NAMESPACE { class VersionSet; class FileSystem; class SystemClock; -struct ImmutableCFOptions; +struct ImmutableOptions; struct MutableCFOptions; struct FileOptions; class BlobFileAddition; @@ -32,7 +32,7 @@ class BlobFileCompletionCallback; class BlobFileBuilder { public: BlobFileBuilder(VersionSet* versions, FileSystem* fs, - const ImmutableCFOptions* immutable_cf_options, + const ImmutableOptions* immutable_options, const MutableCFOptions* mutable_cf_options, const FileOptions* file_options, int job_id, uint32_t column_family_id, @@ -45,8 +45,7 @@ class BlobFileBuilder { std::vector* blob_file_additions); BlobFileBuilder(std::function file_number_generator, - FileSystem* fs, - const ImmutableCFOptions* immutable_cf_options, + FileSystem* fs, const ImmutableOptions* immutable_options, const MutableCFOptions* mutable_cf_options, const FileOptions* file_options, int job_id, uint32_t column_family_id, @@ -78,7 +77,7 @@ class BlobFileBuilder { std::function file_number_generator_; FileSystem* fs_; - const ImmutableCFOptions* immutable_cf_options_; + const ImmutableOptions* immutable_cf_options_; uint64_t min_blob_size_; uint64_t blob_file_size_; CompressionType blob_compression_type_; diff --git a/db/blob/blob_file_builder_test.cc b/db/blob/blob_file_builder_test.cc index 75489298c..d478e6663 100644 --- a/db/blob/blob_file_builder_test.cc +++ b/db/blob/blob_file_builder_test.cc @@ -129,7 +129,7 @@ TEST_F(BlobFileBuilderTest, BuildAndCheckOneFile) { options.enable_blob_files = true; options.env = &mock_env_; - ImmutableCFOptions immutable_cf_options(options); + ImmutableOptions immutable_cf_options(options); MutableCFOptions mutable_cf_options(options); constexpr int job_id = 1; @@ -214,7 +214,7 @@ TEST_F(BlobFileBuilderTest, BuildAndCheckMultipleFiles) { options.blob_file_size = value_size; options.env = &mock_env_; - ImmutableCFOptions immutable_cf_options(options); + ImmutableOptions immutable_cf_options(options); MutableCFOptions mutable_cf_options(options); constexpr int job_id = 1; @@ -301,7 +301,7 @@ TEST_F(BlobFileBuilderTest, InlinedValues) { options.min_blob_size = 1024; options.env = &mock_env_; - ImmutableCFOptions immutable_cf_options(options); + ImmutableOptions immutable_cf_options(options); MutableCFOptions mutable_cf_options(options); constexpr int job_id = 1; @@ -355,7 +355,7 @@ TEST_F(BlobFileBuilderTest, Compression) { options.blob_compression_type = kSnappyCompression; options.env = &mock_env_; - ImmutableCFOptions immutable_cf_options(options); + ImmutableOptions immutable_cf_options(options); MutableCFOptions mutable_cf_options(options); constexpr int job_id = 1; @@ -438,7 +438,7 @@ TEST_F(BlobFileBuilderTest, CompressionError) { options.enable_blob_files = true; options.blob_compression_type = kSnappyCompression; options.env = &mock_env_; - ImmutableCFOptions immutable_cf_options(options); + ImmutableOptions immutable_cf_options(options); MutableCFOptions mutable_cf_options(options); constexpr int job_id = 1; @@ -517,7 +517,7 @@ TEST_F(BlobFileBuilderTest, Checksum) { std::make_shared(); options.env = &mock_env_; - ImmutableCFOptions immutable_cf_options(options); + ImmutableOptions immutable_cf_options(options); MutableCFOptions mutable_cf_options(options); constexpr int job_id = 1; @@ -614,7 +614,7 @@ TEST_P(BlobFileBuilderIOErrorTest, IOError) { options.blob_file_size = value_size; options.env = &mock_env_; - ImmutableCFOptions immutable_cf_options(options); + ImmutableOptions immutable_cf_options(options); MutableCFOptions mutable_cf_options(options); constexpr int job_id = 1; diff --git a/db/blob/blob_file_cache.cc b/db/blob/blob_file_cache.cc index c23a3f5b4..0d1b73487 100644 --- a/db/blob/blob_file_cache.cc +++ b/db/blob/blob_file_cache.cc @@ -19,14 +19,14 @@ namespace ROCKSDB_NAMESPACE { BlobFileCache::BlobFileCache(Cache* cache, - const ImmutableCFOptions* immutable_cf_options, + const ImmutableOptions* immutable_options, const FileOptions* file_options, uint32_t column_family_id, HistogramImpl* blob_file_read_hist, const std::shared_ptr& io_tracer) : cache_(cache), mutex_(kNumberOfMutexStripes, kGetSliceNPHash64UnseededFnPtr), - immutable_cf_options_(immutable_cf_options), + immutable_cf_options_(immutable_options), file_options_(file_options), column_family_id_(column_family_id), blob_file_read_hist_(blob_file_read_hist), diff --git a/db/blob/blob_file_cache.h b/db/blob/blob_file_cache.h index ace2d938b..599bdaded 100644 --- a/db/blob/blob_file_cache.h +++ b/db/blob/blob_file_cache.h @@ -14,7 +14,7 @@ namespace ROCKSDB_NAMESPACE { class Cache; -struct ImmutableCFOptions; +struct ImmutableOptions; struct FileOptions; class HistogramImpl; class Status; @@ -24,7 +24,7 @@ class IOTracer; class BlobFileCache { public: - BlobFileCache(Cache* cache, const ImmutableCFOptions* immutable_cf_options, + BlobFileCache(Cache* cache, const ImmutableOptions* immutable_options, const FileOptions* file_options, uint32_t column_family_id, HistogramImpl* blob_file_read_hist, const std::shared_ptr& io_tracer); @@ -40,7 +40,7 @@ class BlobFileCache { // Note: mutex_ below is used to guard against multiple threads racing to open // the same file. Striped mutex_; - const ImmutableCFOptions* immutable_cf_options_; + const ImmutableOptions* immutable_cf_options_; const FileOptions* file_options_; uint32_t column_family_id_; HistogramImpl* blob_file_read_hist_; diff --git a/db/blob/blob_file_cache_test.cc b/db/blob/blob_file_cache_test.cc index cb10ff319..0dc822243 100644 --- a/db/blob/blob_file_cache_test.cc +++ b/db/blob/blob_file_cache_test.cc @@ -29,7 +29,7 @@ namespace { // Creates a test blob file with a single blob in it. void WriteBlobFile(uint32_t column_family_id, - const ImmutableCFOptions& immutable_cf_options, + const ImmutableOptions& immutable_cf_options, uint64_t blob_file_number) { assert(!immutable_cf_options.cf_paths.empty()); @@ -37,8 +37,8 @@ void WriteBlobFile(uint32_t column_family_id, immutable_cf_options.cf_paths.front().path, blob_file_number); std::unique_ptr file; - ASSERT_OK(NewWritableFile(immutable_cf_options.fs, blob_file_path, &file, - FileOptions())); + ASSERT_OK(NewWritableFile(immutable_cf_options.fs.get(), blob_file_path, + &file, FileOptions())); std::unique_ptr file_writer( new WritableFileWriter(std::move(file), blob_file_path, FileOptions(), @@ -100,7 +100,7 @@ TEST_F(BlobFileCacheTest, GetBlobFileReader) { options.enable_blob_files = true; constexpr uint32_t column_family_id = 1; - ImmutableCFOptions immutable_cf_options(options); + ImmutableOptions immutable_cf_options(options); constexpr uint64_t blob_file_number = 123; WriteBlobFile(column_family_id, immutable_cf_options, blob_file_number); @@ -145,7 +145,7 @@ TEST_F(BlobFileCacheTest, GetBlobFileReader_Race) { options.enable_blob_files = true; constexpr uint32_t column_family_id = 1; - ImmutableCFOptions immutable_cf_options(options); + ImmutableOptions immutable_cf_options(options); constexpr uint64_t blob_file_number = 123; WriteBlobFile(column_family_id, immutable_cf_options, blob_file_number); @@ -199,7 +199,7 @@ TEST_F(BlobFileCacheTest, GetBlobFileReader_IOError) { constexpr size_t capacity = 10; std::shared_ptr backing_cache = NewLRUCache(capacity); - ImmutableCFOptions immutable_cf_options(options); + ImmutableOptions immutable_cf_options(options); FileOptions file_options; constexpr uint32_t column_family_id = 1; constexpr HistogramImpl* blob_file_read_hist = nullptr; @@ -231,7 +231,7 @@ TEST_F(BlobFileCacheTest, GetBlobFileReader_CacheFull) { options.enable_blob_files = true; constexpr uint32_t column_family_id = 1; - ImmutableCFOptions immutable_cf_options(options); + ImmutableOptions immutable_cf_options(options); constexpr uint64_t blob_file_number = 123; WriteBlobFile(column_family_id, immutable_cf_options, blob_file_number); diff --git a/db/blob/blob_file_reader.cc b/db/blob/blob_file_reader.cc index cfe88b3e5..9fff38340 100644 --- a/db/blob/blob_file_reader.cc +++ b/db/blob/blob_file_reader.cc @@ -21,7 +21,7 @@ namespace ROCKSDB_NAMESPACE { Status BlobFileReader::Create( - const ImmutableCFOptions& immutable_cf_options, + const ImmutableOptions& immutable_cf_options, const FileOptions& file_options, uint32_t column_family_id, HistogramImpl* blob_file_read_hist, uint64_t blob_file_number, const std::shared_ptr& io_tracer, @@ -67,10 +67,10 @@ Status BlobFileReader::Create( } Status BlobFileReader::OpenFile( - const ImmutableCFOptions& immutable_cf_options, - const FileOptions& file_opts, HistogramImpl* blob_file_read_hist, - uint64_t blob_file_number, const std::shared_ptr& io_tracer, - uint64_t* file_size, std::unique_ptr* file_reader) { + const ImmutableOptions& immutable_cf_options, const FileOptions& file_opts, + HistogramImpl* blob_file_read_hist, uint64_t blob_file_number, + const std::shared_ptr& io_tracer, uint64_t* file_size, + std::unique_ptr* file_reader) { assert(file_size); assert(file_reader); @@ -80,7 +80,7 @@ Status BlobFileReader::OpenFile( const std::string blob_file_path = BlobFileName(cf_paths.front().path, blob_file_number); - FileSystem* const fs = immutable_cf_options.fs; + FileSystem* const fs = immutable_cf_options.fs.get(); assert(fs); constexpr IODebugContext* dbg = nullptr; diff --git a/db/blob/blob_file_reader.h b/db/blob/blob_file_reader.h index 0ebd89c74..9b3f5ebd6 100644 --- a/db/blob/blob_file_reader.h +++ b/db/blob/blob_file_reader.h @@ -15,7 +15,7 @@ namespace ROCKSDB_NAMESPACE { class Status; -struct ImmutableCFOptions; +struct ImmutableOptions; struct FileOptions; class HistogramImpl; struct ReadOptions; @@ -24,7 +24,7 @@ class PinnableSlice; class BlobFileReader { public: - static Status Create(const ImmutableCFOptions& immutable_cf_options, + static Status Create(const ImmutableOptions& immutable_options, const FileOptions& file_options, uint32_t column_family_id, HistogramImpl* blob_file_read_hist, @@ -46,7 +46,7 @@ class BlobFileReader { BlobFileReader(std::unique_ptr&& file_reader, uint64_t file_size, CompressionType compression_type); - static Status OpenFile(const ImmutableCFOptions& immutable_cf_options, + static Status OpenFile(const ImmutableOptions& immutable_options, const FileOptions& file_opts, HistogramImpl* blob_file_read_hist, uint64_t blob_file_number, diff --git a/db/blob/blob_file_reader_test.cc b/db/blob/blob_file_reader_test.cc index 058e6c4e5..efa3c1439 100644 --- a/db/blob/blob_file_reader_test.cc +++ b/db/blob/blob_file_reader_test.cc @@ -30,7 +30,7 @@ namespace { // Creates a test blob file with a single blob in it. Note: this method // makes it possible to test various corner cases by allowing the caller // to specify the contents of various blob file header/footer fields. -void WriteBlobFile(const ImmutableCFOptions& immutable_cf_options, +void WriteBlobFile(const ImmutableOptions& immutable_cf_options, uint32_t column_family_id, bool has_ttl, const ExpirationRange& expiration_range_header, const ExpirationRange& expiration_range_footer, @@ -45,8 +45,8 @@ void WriteBlobFile(const ImmutableCFOptions& immutable_cf_options, immutable_cf_options.cf_paths.front().path, blob_file_number); std::unique_ptr file; - ASSERT_OK(NewWritableFile(immutable_cf_options.fs, blob_file_path, &file, - FileOptions())); + ASSERT_OK(NewWritableFile(immutable_cf_options.fs.get(), blob_file_path, + &file, FileOptions())); std::unique_ptr file_writer( new WritableFileWriter(std::move(file), blob_file_path, FileOptions(), @@ -122,7 +122,7 @@ TEST_F(BlobFileReaderTest, CreateReaderAndGetBlob) { 0); options.enable_blob_files = true; - ImmutableCFOptions immutable_cf_options(options); + ImmutableOptions immutable_cf_options(options); constexpr uint32_t column_family_id = 1; constexpr bool has_ttl = false; @@ -262,7 +262,7 @@ TEST_F(BlobFileReaderTest, Malformed) { test::PerThreadDBPath(&mock_env_, "BlobFileReaderTest_Malformed"), 0); options.enable_blob_files = true; - ImmutableCFOptions immutable_cf_options(options); + ImmutableOptions immutable_cf_options(options); constexpr uint32_t column_family_id = 1; constexpr uint64_t blob_file_number = 1; @@ -275,8 +275,8 @@ TEST_F(BlobFileReaderTest, Malformed) { immutable_cf_options.cf_paths.front().path, blob_file_number); std::unique_ptr file; - ASSERT_OK(NewWritableFile(immutable_cf_options.fs, blob_file_path, &file, - FileOptions())); + ASSERT_OK(NewWritableFile(immutable_cf_options.fs.get(), blob_file_path, + &file, FileOptions())); std::unique_ptr file_writer( new WritableFileWriter(std::move(file), blob_file_path, FileOptions(), @@ -314,7 +314,7 @@ TEST_F(BlobFileReaderTest, TTL) { test::PerThreadDBPath(&mock_env_, "BlobFileReaderTest_TTL"), 0); options.enable_blob_files = true; - ImmutableCFOptions immutable_cf_options(options); + ImmutableOptions immutable_cf_options(options); constexpr uint32_t column_family_id = 1; constexpr bool has_ttl = true; @@ -350,7 +350,7 @@ TEST_F(BlobFileReaderTest, ExpirationRangeInHeader) { 0); options.enable_blob_files = true; - ImmutableCFOptions immutable_cf_options(options); + ImmutableOptions immutable_cf_options(options); constexpr uint32_t column_family_id = 1; constexpr bool has_ttl = false; @@ -389,7 +389,7 @@ TEST_F(BlobFileReaderTest, ExpirationRangeInFooter) { 0); options.enable_blob_files = true; - ImmutableCFOptions immutable_cf_options(options); + ImmutableOptions immutable_cf_options(options); constexpr uint32_t column_family_id = 1; constexpr bool has_ttl = false; @@ -428,7 +428,7 @@ TEST_F(BlobFileReaderTest, IncorrectColumnFamily) { 0); options.enable_blob_files = true; - ImmutableCFOptions immutable_cf_options(options); + ImmutableOptions immutable_cf_options(options); constexpr uint32_t column_family_id = 1; constexpr bool has_ttl = false; @@ -464,7 +464,7 @@ TEST_F(BlobFileReaderTest, BlobCRCError) { test::PerThreadDBPath(&mock_env_, "BlobFileReaderTest_BlobCRCError"), 0); options.enable_blob_files = true; - ImmutableCFOptions immutable_cf_options(options); + ImmutableOptions immutable_cf_options(options); constexpr uint32_t column_family_id = 1; constexpr bool has_ttl = false; @@ -522,7 +522,7 @@ TEST_F(BlobFileReaderTest, Compression) { test::PerThreadDBPath(&mock_env_, "BlobFileReaderTest_Compression"), 0); options.enable_blob_files = true; - ImmutableCFOptions immutable_cf_options(options); + ImmutableOptions immutable_cf_options(options); constexpr uint32_t column_family_id = 1; constexpr bool has_ttl = false; @@ -590,7 +590,7 @@ TEST_F(BlobFileReaderTest, UncompressionError) { 0); options.enable_blob_files = true; - ImmutableCFOptions immutable_cf_options(options); + ImmutableOptions immutable_cf_options(options); constexpr uint32_t column_family_id = 1; constexpr bool has_ttl = false; @@ -671,7 +671,7 @@ TEST_P(BlobFileReaderIOErrorTest, IOError) { 0); options.enable_blob_files = true; - ImmutableCFOptions immutable_cf_options(options); + ImmutableOptions immutable_cf_options(options); constexpr uint32_t column_family_id = 1; constexpr bool has_ttl = false; @@ -749,7 +749,7 @@ TEST_P(BlobFileReaderDecodingErrorTest, DecodingError) { 0); options.enable_blob_files = true; - ImmutableCFOptions immutable_cf_options(options); + ImmutableOptions immutable_cf_options(options); constexpr uint32_t column_family_id = 1; constexpr bool has_ttl = false; diff --git a/db/column_family.cc b/db/column_family.cc index 43c7dc036..356c164af 100644 --- a/db/column_family.cc +++ b/db/column_family.cc @@ -1417,7 +1417,8 @@ Status ColumnFamilyData::AddDirectories( if (existing_dir == created_dirs->end()) { std::unique_ptr path_directory; - s = DBImpl::CreateAndNewDirectory(ioptions_.fs, p.path, &path_directory); + s = DBImpl::CreateAndNewDirectory(ioptions_.fs.get(), p.path, + &path_directory); if (!s.ok()) { return s; } diff --git a/db/column_family.h b/db/column_family.h index 7dafe2a31..256270fe0 100644 --- a/db/column_family.h +++ b/db/column_family.h @@ -316,7 +316,7 @@ class ColumnFamilyData { FlushReason GetFlushReason() const { return flush_reason_; } // thread-safe const FileOptions* soptions() const; - const ImmutableCFOptions* ioptions() const { return &ioptions_; } + const ImmutableOptions* ioptions() const { return &ioptions_; } // REQUIRES: DB mutex held // This returns the MutableCFOptions used by current SuperVersion // You should use this API to reference MutableCFOptions most of the time. @@ -552,7 +552,7 @@ class ColumnFamilyData { int_tbl_prop_collector_factories_; const ColumnFamilyOptions initial_cf_options_; - const ImmutableCFOptions ioptions_; + const ImmutableOptions ioptions_; MutableCFOptions mutable_cf_options_; const bool is_delete_range_supported_; diff --git a/db/compaction/compaction.cc b/db/compaction/compaction.cc index 82bf73d0c..c3f6a4afe 100644 --- a/db/compaction/compaction.cc +++ b/db/compaction/compaction.cc @@ -204,27 +204,24 @@ bool Compaction::IsFullCompaction( return num_files_in_compaction == total_num_files; } -Compaction::Compaction(VersionStorageInfo* vstorage, - const ImmutableCFOptions& _immutable_cf_options, - const MutableCFOptions& _mutable_cf_options, - const MutableDBOptions& _mutable_db_options, - std::vector _inputs, - int _output_level, uint64_t _target_file_size, - uint64_t _max_compaction_bytes, uint32_t _output_path_id, - CompressionType _compression, - CompressionOptions _compression_opts, - uint32_t _max_subcompactions, - std::vector _grandparents, - bool _manual_compaction, double _score, - bool _deletion_compaction, - CompactionReason _compaction_reason) +Compaction::Compaction( + VersionStorageInfo* vstorage, const ImmutableOptions& _immutable_options, + const MutableCFOptions& _mutable_cf_options, + const MutableDBOptions& _mutable_db_options, + std::vector _inputs, int _output_level, + uint64_t _target_file_size, uint64_t _max_compaction_bytes, + uint32_t _output_path_id, CompressionType _compression, + CompressionOptions _compression_opts, uint32_t _max_subcompactions, + std::vector _grandparents, bool _manual_compaction, + double _score, bool _deletion_compaction, + CompactionReason _compaction_reason) : input_vstorage_(vstorage), start_level_(_inputs[0].level), output_level_(_output_level), max_output_file_size_(_target_file_size), max_compaction_bytes_(_max_compaction_bytes), max_subcompactions_(_max_subcompactions), - immutable_cf_options_(_immutable_cf_options), + immutable_options_(_immutable_options), mutable_cf_options_(_mutable_cf_options), input_version_(nullptr), number_levels_(vstorage->num_levels()), @@ -278,7 +275,7 @@ Compaction::~Compaction() { bool Compaction::InputCompressionMatchesOutput() const { int base_level = input_vstorage_->base_level(); - bool matches = (GetCompressionType(immutable_cf_options_, input_vstorage_, + bool matches = (GetCompressionType(immutable_options_, input_vstorage_, mutable_cf_options_, start_level_, base_level) == output_compression_); if (matches) { @@ -303,8 +300,8 @@ bool Compaction::IsTrivialMove() const { } if (is_manual_compaction_ && - (immutable_cf_options_.compaction_filter != nullptr || - immutable_cf_options_.compaction_filter_factory != nullptr)) { + (immutable_options_.compaction_filter != nullptr || + immutable_options_.compaction_filter_factory != nullptr)) { // This is a manual compaction and we have a compaction filter that should // be executed, we cannot do a trivial move return false; @@ -512,7 +509,7 @@ uint64_t Compaction::OutputFilePreallocationSize() const { } if (max_output_file_size_ != port::kMaxUint64 && - (immutable_cf_options_.compaction_style == kCompactionStyleLevel || + (immutable_options_.compaction_style == kCompactionStyleLevel || output_level() > 0)) { preallocation_size = std::min(max_output_file_size_, preallocation_size); } @@ -538,7 +535,7 @@ std::unique_ptr Compaction::CreateCompactionFilter() const { } std::unique_ptr Compaction::CreateSstPartitioner() const { - if (!immutable_cf_options_.sst_partitioner_factory) { + if (!immutable_options_.sst_partitioner_factory) { return nullptr; } @@ -548,8 +545,7 @@ std::unique_ptr Compaction::CreateSstPartitioner() const { context.output_level = output_level_; context.smallest_user_key = smallest_user_key_; context.largest_user_key = largest_user_key_; - return immutable_cf_options_.sst_partitioner_factory->CreatePartitioner( - context); + return immutable_options_.sst_partitioner_factory->CreatePartitioner(context); } bool Compaction::IsOutputLevelEmpty() const { diff --git a/db/compaction/compaction.h b/db/compaction/compaction.h index 04e0edd17..ae4cd57e8 100644 --- a/db/compaction/compaction.h +++ b/db/compaction/compaction.h @@ -70,7 +70,7 @@ class CompactionFilter; class Compaction { public: Compaction(VersionStorageInfo* input_version, - const ImmutableCFOptions& immutable_cf_options, + const ImmutableOptions& immutable_options, const MutableCFOptions& mutable_cf_options, const MutableDBOptions& mutable_db_options, std::vector inputs, int output_level, @@ -225,8 +225,8 @@ class Compaction { // Return the ImmutableCFOptions that should be used throughout the compaction // procedure - const ImmutableCFOptions* immutable_cf_options() const { - return &immutable_cf_options_; + const ImmutableOptions* immutable_cf_options() const { + return &immutable_options_; } // Return the MutableCFOptions that should be used throughout the compaction @@ -330,7 +330,7 @@ class Compaction { uint64_t max_output_file_size_; uint64_t max_compaction_bytes_; uint32_t max_subcompactions_; - const ImmutableCFOptions immutable_cf_options_; + const ImmutableOptions immutable_options_; const MutableCFOptions mutable_cf_options_; Version* input_version_; VersionEdit edit_; diff --git a/db/compaction/compaction_job.cc b/db/compaction/compaction_job.cc index 36a70ce2e..5aefac430 100644 --- a/db/compaction/compaction_job.cc +++ b/db/compaction/compaction_job.cc @@ -969,8 +969,7 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) { compaction_filter, db_options_.info_log.get(), false /* internal key corruption is expected */, existing_snapshots_.empty() ? 0 : existing_snapshots_.back(), - snapshot_checker_, compact_->compaction->level(), - db_options_.statistics.get()); + snapshot_checker_, compact_->compaction->level(), db_options_.stats); const MutableCFOptions* mutable_cf_options = sub_compact->compaction->mutable_cf_options(); @@ -1758,7 +1757,7 @@ Status CompactionJob::OpenCompactionOutputFile( sub_compact->compaction->immutable_cf_options()->listeners; sub_compact->outfile.reset(new WritableFileWriter( std::move(writable_file), fname, file_options_, db_options_.clock, - io_tracer_, db_options_.statistics.get(), listeners, + io_tracer_, db_options_.stats, listeners, db_options_.file_checksum_gen_factory.get(), tmp_set.Contains(FileType::kTableFile))); diff --git a/db/compaction/compaction_picker.cc b/db/compaction/compaction_picker.cc index bd1ad2402..da91f6be2 100644 --- a/db/compaction/compaction_picker.cc +++ b/db/compaction/compaction_picker.cc @@ -148,7 +148,7 @@ CompressionOptions GetCompressionOptions(const MutableCFOptions& cf_options, return cf_options.compression_opts; } -CompactionPicker::CompactionPicker(const ImmutableCFOptions& ioptions, +CompactionPicker::CompactionPicker(const ImmutableOptions& ioptions, const InternalKeyComparator* icmp) : ioptions_(ioptions), icmp_(icmp) {} diff --git a/db/compaction/compaction_picker.h b/db/compaction/compaction_picker.h index 4bd431d71..70de11f94 100644 --- a/db/compaction/compaction_picker.h +++ b/db/compaction/compaction_picker.h @@ -46,7 +46,7 @@ struct CompactionInputFiles; // compaction style specific logic for them. class CompactionPicker { public: - CompactionPicker(const ImmutableCFOptions& ioptions, + CompactionPicker(const ImmutableOptions& ioptions, const InternalKeyComparator* icmp); virtual ~CompactionPicker(); @@ -218,7 +218,7 @@ class CompactionPicker { } protected: - const ImmutableCFOptions& ioptions_; + const ImmutableOptions& ioptions_; // A helper function to SanitizeCompactionInputFiles() that // sanitizes "input_files" by adding necessary files. @@ -244,7 +244,7 @@ class CompactionPicker { // compaction. class NullCompactionPicker : public CompactionPicker { public: - NullCompactionPicker(const ImmutableCFOptions& ioptions, + NullCompactionPicker(const ImmutableOptions& ioptions, const InternalKeyComparator* icmp) : CompactionPicker(ioptions, icmp) {} virtual ~NullCompactionPicker() {} diff --git a/db/compaction/compaction_picker_fifo.h b/db/compaction/compaction_picker_fifo.h index e8aec64c6..2a07f8df7 100644 --- a/db/compaction/compaction_picker_fifo.h +++ b/db/compaction/compaction_picker_fifo.h @@ -15,7 +15,7 @@ namespace ROCKSDB_NAMESPACE { class FIFOCompactionPicker : public CompactionPicker { public: - FIFOCompactionPicker(const ImmutableCFOptions& ioptions, + FIFOCompactionPicker(const ImmutableOptions& ioptions, const InternalKeyComparator* icmp) : CompactionPicker(ioptions, icmp) {} diff --git a/db/compaction/compaction_picker_level.cc b/db/compaction/compaction_picker_level.cc index 3778d6d8d..08c48c8f0 100644 --- a/db/compaction/compaction_picker_level.cc +++ b/db/compaction/compaction_picker_level.cc @@ -49,7 +49,7 @@ class LevelCompactionBuilder { CompactionPicker* compaction_picker, LogBuffer* log_buffer, const MutableCFOptions& mutable_cf_options, - const ImmutableCFOptions& ioptions, + const ImmutableOptions& ioptions, const MutableDBOptions& mutable_db_options) : cf_name_(cf_name), vstorage_(vstorage), @@ -121,7 +121,7 @@ class LevelCompactionBuilder { CompactionReason compaction_reason_ = CompactionReason::kUnknown; const MutableCFOptions& mutable_cf_options_; - const ImmutableCFOptions& ioptions_; + const ImmutableOptions& ioptions_; const MutableDBOptions& mutable_db_options_; // Pick a path ID to place a newly generated file, with its level static uint32_t GetPathId(const ImmutableCFOptions& ioptions, diff --git a/db/compaction/compaction_picker_level.h b/db/compaction/compaction_picker_level.h index 460a5ef17..42a9b60a6 100644 --- a/db/compaction/compaction_picker_level.h +++ b/db/compaction/compaction_picker_level.h @@ -17,7 +17,7 @@ namespace ROCKSDB_NAMESPACE { // for description of Leveled compaction. class LevelCompactionPicker : public CompactionPicker { public: - LevelCompactionPicker(const ImmutableCFOptions& ioptions, + LevelCompactionPicker(const ImmutableOptions& ioptions, const InternalKeyComparator* icmp) : CompactionPicker(ioptions, icmp) {} virtual Compaction* PickCompaction( diff --git a/db/compaction/compaction_picker_test.cc b/db/compaction/compaction_picker_test.cc index 008dfe11c..5d543048f 100644 --- a/db/compaction/compaction_picker_test.cc +++ b/db/compaction/compaction_picker_test.cc @@ -30,7 +30,7 @@ class CompactionPickerTest : public testing::Test { const Comparator* ucmp_; InternalKeyComparator icmp_; Options options_; - ImmutableCFOptions ioptions_; + ImmutableOptions ioptions_; MutableCFOptions mutable_cf_options_; MutableDBOptions mutable_db_options_; LevelCompactionPicker level_compaction_picker; diff --git a/db/compaction/compaction_picker_universal.cc b/db/compaction/compaction_picker_universal.cc index 079116fb9..b6f38f828 100644 --- a/db/compaction/compaction_picker_universal.cc +++ b/db/compaction/compaction_picker_universal.cc @@ -32,7 +32,7 @@ namespace { class UniversalCompactionBuilder { public: UniversalCompactionBuilder( - const ImmutableCFOptions& ioptions, const InternalKeyComparator* icmp, + const ImmutableOptions& ioptions, const InternalKeyComparator* icmp, const std::string& cf_name, const MutableCFOptions& mutable_cf_options, const MutableDBOptions& mutable_db_options, VersionStorageInfo* vstorage, UniversalCompactionPicker* picker, LogBuffer* log_buffer) @@ -108,7 +108,7 @@ class UniversalCompactionBuilder { // overlapping. bool IsInputFilesNonOverlapping(Compaction* c); - const ImmutableCFOptions& ioptions_; + const ImmutableOptions& ioptions_; const InternalKeyComparator* icmp_; double score_; std::vector sorted_runs_; diff --git a/db/compaction/compaction_picker_universal.h b/db/compaction/compaction_picker_universal.h index a06ad3b85..5f897cc9b 100644 --- a/db/compaction/compaction_picker_universal.h +++ b/db/compaction/compaction_picker_universal.h @@ -15,7 +15,7 @@ namespace ROCKSDB_NAMESPACE { class UniversalCompactionPicker : public CompactionPicker { public: - UniversalCompactionPicker(const ImmutableCFOptions& ioptions, + UniversalCompactionPicker(const ImmutableOptions& ioptions, const InternalKeyComparator* icmp) : CompactionPicker(ioptions, icmp) {} virtual Compaction* PickCompaction( diff --git a/db/convenience.cc b/db/convenience.cc index 96735d7e5..5af6515c8 100644 --- a/db/convenience.cc +++ b/db/convenience.cc @@ -44,7 +44,7 @@ Status VerifySstFileChecksum(const Options& options, std::unique_ptr file; uint64_t file_size; InternalKeyComparator internal_comparator(options.comparator); - ImmutableCFOptions ioptions(options); + ImmutableOptions ioptions(options); Status s = ioptions.fs->NewRandomAccessFile(file_path, FileOptions(env_options), diff --git a/db/corruption_test.cc b/db/corruption_test.cc index 96671b67a..5c74905e7 100644 --- a/db/corruption_test.cc +++ b/db/corruption_test.cc @@ -551,7 +551,7 @@ TEST_F(CorruptionTest, RangeDeletionCorrupted) { BlockHandle range_del_handle; ASSERT_OK(FindMetaBlock( file_reader.get(), file_size, kBlockBasedTableMagicNumber, - ImmutableCFOptions(options_), kRangeDelBlock, &range_del_handle)); + ImmutableOptions(options_), kRangeDelBlock, &range_del_handle)); ASSERT_OK(TryReopen()); ASSERT_OK(test::CorruptFile(env_, filename, diff --git a/db/db_impl/db_impl.cc b/db/db_impl/db_impl.cc index 58f54b52e..2cdab8b5a 100644 --- a/db/db_impl/db_impl.cc +++ b/db/db_impl/db_impl.cc @@ -156,7 +156,7 @@ DBImpl::DBImpl(const DBOptions& options, const std::string& dbname, immutable_db_options_(initial_db_options_), fs_(immutable_db_options_.fs, io_tracer_), mutable_db_options_(initial_db_options_), - stats_(immutable_db_options_.statistics.get()), + stats_(immutable_db_options_.stats), mutex_(stats_, immutable_db_options_.clock, DB_MUTEX_WAIT_MICROS, immutable_db_options_.use_adaptive_mutex), default_cf_handle_(nullptr), @@ -706,7 +706,7 @@ const Status DBImpl::CreateArchivalDirectory() { } void DBImpl::PrintStatistics() { - auto dbstats = immutable_db_options_.statistics.get(); + auto dbstats = immutable_db_options_.stats; if (dbstats) { ROCKS_LOG_INFO(immutable_db_options_.info_log, "STATISTICS:\n %s", dbstats->ToString().c_str()); @@ -767,7 +767,7 @@ void DBImpl::PersistStats() { uint64_t now_seconds = immutable_db_options_.clock->NowMicros() / kMicrosInSecond; - Statistics* statistics = immutable_db_options_.statistics.get(); + Statistics* statistics = immutable_db_options_.stats; if (!statistics) { return; } @@ -3277,7 +3277,7 @@ bool DBImpl::GetIntPropertyInternal(ColumnFamilyData* cfd, bool DBImpl::GetPropertyHandleOptionsStatistics(std::string* value) { assert(value != nullptr); - Statistics* statistics = immutable_db_options_.statistics.get(); + Statistics* statistics = immutable_db_options_.stats; if (!statistics) { return false; } diff --git a/db/db_impl/db_impl_write.cc b/db/db_impl/db_impl_write.cc index 99570c9c5..2bd6f7124 100644 --- a/db/db_impl/db_impl_write.cc +++ b/db/db_impl/db_impl_write.cc @@ -160,8 +160,8 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options, RecordTick(stats_, WRITE_WITH_WAL); } - StopWatch write_sw(immutable_db_options_.clock, - immutable_db_options_.statistics.get(), DB_WRITE); + StopWatch write_sw(immutable_db_options_.clock, immutable_db_options_.stats, + DB_WRITE); write_thread_.JoinBatchGroup(&w); if (w.state == WriteThread::STATE_PARALLEL_MEMTABLE_WRITER) { @@ -466,8 +466,8 @@ Status DBImpl::PipelinedWriteImpl(const WriteOptions& write_options, uint64_t* log_used, uint64_t log_ref, bool disable_memtable, uint64_t* seq_used) { PERF_TIMER_GUARD(write_pre_and_post_process_time); - StopWatch write_sw(immutable_db_options_.clock, - immutable_db_options_.statistics.get(), DB_WRITE); + StopWatch write_sw(immutable_db_options_.clock, immutable_db_options_.stats, + DB_WRITE); WriteContext write_context; @@ -623,8 +623,8 @@ Status DBImpl::UnorderedWriteMemtable(const WriteOptions& write_options, SequenceNumber seq, const size_t sub_batch_cnt) { PERF_TIMER_GUARD(write_pre_and_post_process_time); - StopWatch write_sw(immutable_db_options_.clock, - immutable_db_options_.statistics.get(), DB_WRITE); + StopWatch write_sw(immutable_db_options_.clock, immutable_db_options_.stats, + DB_WRITE); WriteThread::Writer w(write_options, my_batch, callback, log_ref, false /*disable_memtable*/); @@ -679,8 +679,8 @@ Status DBImpl::WriteImplWALOnly( WriteThread::Writer w(write_options, my_batch, callback, log_ref, disable_memtable, sub_batch_cnt, pre_release_callback); RecordTick(stats_, WRITE_WITH_WAL); - StopWatch write_sw(immutable_db_options_.clock, - immutable_db_options_.statistics.get(), DB_WRITE); + StopWatch write_sw(immutable_db_options_.clock, immutable_db_options_.stats, + DB_WRITE); write_thread->JoinBatchGroup(&w); assert(w.state != WriteThread::STATE_PARALLEL_MEMTABLE_WRITER); diff --git a/db/db_iter.cc b/db/db_iter.cc index 126273482..c302a2071 100644 --- a/db/db_iter.cc +++ b/db/db_iter.cc @@ -36,7 +36,7 @@ namespace ROCKSDB_NAMESPACE { DBIter::DBIter(Env* _env, const ReadOptions& read_options, - const ImmutableCFOptions& cf_options, + const ImmutableOptions& cf_options, const MutableCFOptions& mutable_cf_options, const Comparator* cmp, InternalIterator* iter, const Version* version, SequenceNumber s, bool arena_mode, @@ -1536,7 +1536,7 @@ void DBIter::SeekToLast() { } Iterator* NewDBIterator(Env* env, const ReadOptions& read_options, - const ImmutableCFOptions& cf_options, + const ImmutableOptions& cf_options, const MutableCFOptions& mutable_cf_options, const Comparator* user_key_comparator, InternalIterator* internal_iter, const Version* version, diff --git a/db/db_iter.h b/db/db_iter.h index 83780c685..21eaf8bd7 100644 --- a/db/db_iter.h +++ b/db/db_iter.h @@ -114,7 +114,7 @@ class DBIter final : public Iterator { }; DBIter(Env* _env, const ReadOptions& read_options, - const ImmutableCFOptions& cf_options, + const ImmutableOptions& cf_options, const MutableCFOptions& mutable_cf_options, const Comparator* cmp, InternalIterator* iter, const Version* version, SequenceNumber s, bool arena_mode, uint64_t max_sequential_skip_in_iterations, @@ -384,7 +384,7 @@ class DBIter final : public Iterator { // into appropriate user keys. extern Iterator* NewDBIterator( Env* env, const ReadOptions& read_options, - const ImmutableCFOptions& cf_options, + const ImmutableOptions& cf_options, const MutableCFOptions& mutable_cf_options, const Comparator* user_key_comparator, InternalIterator* internal_iter, const Version* version, const SequenceNumber& sequence, diff --git a/db/db_iter_stress_test.cc b/db/db_iter_stress_test.cc index d0b380f1b..f2b200f68 100644 --- a/db/db_iter_stress_test.cc +++ b/db/db_iter_stress_test.cc @@ -511,7 +511,7 @@ TEST_F(DBIteratorStressTest, StressTest) { target_hidden_fraction; internal_iter->trace = trace; db_iter.reset(NewDBIterator( - env_, ropt, ImmutableCFOptions(options), + env_, ropt, ImmutableOptions(options), MutableCFOptions(options), BytewiseComparator(), internal_iter, nullptr /* version */, sequence, options.max_sequential_skip_in_iterations, diff --git a/db/db_iter_test.cc b/db/db_iter_test.cc index 2ff0bd9a4..cc2a77b19 100644 --- a/db/db_iter_test.cc +++ b/db/db_iter_test.cc @@ -237,7 +237,7 @@ class DBIteratorTest : public testing::Test { TEST_F(DBIteratorTest, DBIteratorPrevNext) { Options options; - ImmutableCFOptions cf_options = ImmutableCFOptions(options); + ImmutableOptions cf_options = ImmutableOptions(options); MutableCFOptions mutable_cf_options = MutableCFOptions(options); { TestIterator* internal_iter = new TestIterator(BytewiseComparator()); @@ -677,7 +677,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) { TEST_F(DBIteratorTest, DBIteratorEmpty) { Options options; - ImmutableCFOptions cf_options = ImmutableCFOptions(options); + ImmutableOptions cf_options = ImmutableOptions(options); MutableCFOptions mutable_cf_options = MutableCFOptions(options); ReadOptions ro; @@ -725,7 +725,7 @@ TEST_F(DBIteratorTest, DBIteratorUseSkipCountSkips) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, ImmutableCFOptions(options), MutableCFOptions(options), + env_, ro, ImmutableOptions(options), MutableCFOptions(options), BytewiseComparator(), internal_iter, nullptr /* version */, 2 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -757,7 +757,7 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) { ReadOptions ro; Options options; options.merge_operator = MergeOperators::CreateFromStringId("stringappend"); - ImmutableCFOptions cf_options = ImmutableCFOptions(options); + ImmutableOptions cf_options = ImmutableOptions(options); MutableCFOptions mutable_cf_options = MutableCFOptions(options); { @@ -1004,7 +1004,7 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) { TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) { Options options; - ImmutableCFOptions cf_options = ImmutableCFOptions(options); + ImmutableOptions cf_options = ImmutableOptions(options); MutableCFOptions mutable_cf_options = MutableCFOptions(options); ReadOptions ro; @@ -1399,7 +1399,7 @@ TEST_F(DBIteratorTest, DBIterator1) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, ImmutableCFOptions(options), MutableCFOptions(options), + env_, ro, ImmutableOptions(options), MutableCFOptions(options), BytewiseComparator(), internal_iter, nullptr /* version */, 1 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -1428,7 +1428,7 @@ TEST_F(DBIteratorTest, DBIterator2) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, ImmutableCFOptions(options), MutableCFOptions(options), + env_, ro, ImmutableOptions(options), MutableCFOptions(options), BytewiseComparator(), internal_iter, nullptr /* version */, 0 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -1454,7 +1454,7 @@ TEST_F(DBIteratorTest, DBIterator3) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, ImmutableCFOptions(options), MutableCFOptions(options), + env_, ro, ImmutableOptions(options), MutableCFOptions(options), BytewiseComparator(), internal_iter, nullptr /* version */, 2 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -1480,7 +1480,7 @@ TEST_F(DBIteratorTest, DBIterator4) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, ImmutableCFOptions(options), MutableCFOptions(options), + env_, ro, ImmutableOptions(options), MutableCFOptions(options), BytewiseComparator(), internal_iter, nullptr /* version */, 4 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -1500,7 +1500,7 @@ TEST_F(DBIteratorTest, DBIterator5) { ReadOptions ro; Options options; options.merge_operator = MergeOperators::CreateFromStringId("stringappend"); - ImmutableCFOptions cf_options = ImmutableCFOptions(options); + ImmutableOptions cf_options = ImmutableOptions(options); MutableCFOptions mutable_cf_options = MutableCFOptions(options); { @@ -1698,7 +1698,7 @@ TEST_F(DBIteratorTest, DBIterator6) { ReadOptions ro; Options options; options.merge_operator = MergeOperators::CreateFromStringId("stringappend"); - ImmutableCFOptions cf_options = ImmutableCFOptions(options); + ImmutableOptions cf_options = ImmutableOptions(options); MutableCFOptions mutable_cf_options = MutableCFOptions(options); { @@ -1870,7 +1870,7 @@ TEST_F(DBIteratorTest, DBIterator7) { ReadOptions ro; Options options; options.merge_operator = MergeOperators::CreateFromStringId("stringappend"); - ImmutableCFOptions cf_options = ImmutableCFOptions(options); + ImmutableOptions cf_options = ImmutableOptions(options); MutableCFOptions mutable_cf_options = MutableCFOptions(options); { @@ -2283,7 +2283,7 @@ TEST_F(DBIteratorTest, DBIterator8) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, ImmutableCFOptions(options), MutableCFOptions(options), + env_, ro, ImmutableOptions(options), MutableCFOptions(options), BytewiseComparator(), internal_iter, nullptr /* version */, 10 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -2315,7 +2315,7 @@ TEST_F(DBIteratorTest, DBIterator9) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, ImmutableCFOptions(options), MutableCFOptions(options), + env_, ro, ImmutableOptions(options), MutableCFOptions(options), BytewiseComparator(), internal_iter, nullptr /* version */, 10 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -2383,7 +2383,7 @@ TEST_F(DBIteratorTest, DBIterator10) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, ImmutableCFOptions(options), MutableCFOptions(options), + env_, ro, ImmutableOptions(options), MutableCFOptions(options), BytewiseComparator(), internal_iter, nullptr /* version */, 10 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -2424,7 +2424,7 @@ TEST_F(DBIteratorTest, SeekToLastOccurrenceSeq0) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, ImmutableCFOptions(options), MutableCFOptions(options), + env_, ro, ImmutableOptions(options), MutableCFOptions(options), BytewiseComparator(), internal_iter, nullptr /* version */, 10 /* sequence */, 0 /* force seek */, nullptr /* read_callback */)); db_iter->SeekToFirst(); @@ -2453,7 +2453,7 @@ TEST_F(DBIteratorTest, DBIterator11) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, ImmutableCFOptions(options), MutableCFOptions(options), + env_, ro, ImmutableOptions(options), MutableCFOptions(options), BytewiseComparator(), internal_iter, nullptr /* version */, 1 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -2481,7 +2481,7 @@ TEST_F(DBIteratorTest, DBIterator12) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, ImmutableCFOptions(options), MutableCFOptions(options), + env_, ro, ImmutableOptions(options), MutableCFOptions(options), BytewiseComparator(), internal_iter, nullptr /* version */, 10 /* sequence */, 0 /* force seek */, nullptr /* read_callback */)); db_iter->SeekToLast(); @@ -2519,7 +2519,7 @@ TEST_F(DBIteratorTest, DBIterator13) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, ImmutableCFOptions(options), MutableCFOptions(options), + env_, ro, ImmutableOptions(options), MutableCFOptions(options), BytewiseComparator(), internal_iter, nullptr /* version */, 2 /* sequence */, 3 /* max_sequential_skip_in_iterations */, nullptr /* read_callback */)); @@ -2549,7 +2549,7 @@ TEST_F(DBIteratorTest, DBIterator14) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, ImmutableCFOptions(options), MutableCFOptions(options), + env_, ro, ImmutableOptions(options), MutableCFOptions(options), BytewiseComparator(), internal_iter, nullptr /* version */, 4 /* sequence */, 1 /* max_sequential_skip_in_iterations */, nullptr /* read_callback */)); @@ -2578,7 +2578,7 @@ TEST_F(DBIteratorTest, DBIteratorTestDifferentialSnapshots) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, ImmutableCFOptions(options), MutableCFOptions(options), + env_, ro, ImmutableOptions(options), MutableCFOptions(options), BytewiseComparator(), internal_iter, nullptr /* version */, 13 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -2614,7 +2614,7 @@ TEST_F(DBIteratorTest, DBIteratorTestDifferentialSnapshots) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, ImmutableCFOptions(options), MutableCFOptions(options), + env_, ro, ImmutableOptions(options), MutableCFOptions(options), BytewiseComparator(), internal_iter, nullptr /* version */, 13 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -2665,7 +2665,7 @@ class DBIterWithMergeIterTest : public testing::Test { NewMergingIterator(&icomp_, &child_iters[0], 2u); db_iter_.reset(NewDBIterator( - env_, ro_, ImmutableCFOptions(options_), MutableCFOptions(options_), + env_, ro_, ImmutableOptions(options_), MutableCFOptions(options_), BytewiseComparator(), merge_iter, nullptr /* version */, 8 /* read data earlier than seqId 8 */, 3 /* max iterators before reseek */, nullptr /* read_callback */)); @@ -3105,7 +3105,7 @@ TEST_F(DBIteratorTest, SeekPrefixTombstones) { ro.prefix_same_as_start = true; std::unique_ptr db_iter(NewDBIterator( - env_, ro, ImmutableCFOptions(options), MutableCFOptions(options), + env_, ro, ImmutableOptions(options), MutableCFOptions(options), BytewiseComparator(), internal_iter, nullptr /* version */, 10 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -3142,7 +3142,7 @@ TEST_F(DBIteratorTest, SeekToFirstLowerBound) { ro.iterate_lower_bound = &lower_bound; Options options; std::unique_ptr db_iter(NewDBIterator( - env_, ro, ImmutableCFOptions(options), MutableCFOptions(options), + env_, ro, ImmutableOptions(options), MutableCFOptions(options), BytewiseComparator(), internal_iter, nullptr /* version */, 10 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -3182,7 +3182,7 @@ TEST_F(DBIteratorTest, PrevLowerBound) { ro.iterate_lower_bound = &lower_bound; Options options; std::unique_ptr db_iter(NewDBIterator( - env_, ro, ImmutableCFOptions(options), MutableCFOptions(options), + env_, ro, ImmutableOptions(options), MutableCFOptions(options), BytewiseComparator(), internal_iter, nullptr /* version */, 10 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -3211,7 +3211,7 @@ TEST_F(DBIteratorTest, SeekLessLowerBound) { ro.iterate_lower_bound = &lower_bound; Options options; std::unique_ptr db_iter(NewDBIterator( - env_, ro, ImmutableCFOptions(options), MutableCFOptions(options), + env_, ro, ImmutableOptions(options), MutableCFOptions(options), BytewiseComparator(), internal_iter, nullptr /* version */, 10 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -3237,10 +3237,10 @@ TEST_F(DBIteratorTest, ReverseToForwardWithDisappearingKeys) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ReadOptions(), ImmutableCFOptions(options), - MutableCFOptions(options), BytewiseComparator(), internal_iter, - nullptr /* version */, 10 /* sequence */, - options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); + env_, ReadOptions(), ImmutableOptions(options), MutableCFOptions(options), + BytewiseComparator(), internal_iter, nullptr /* version */, + 10 /* sequence */, options.max_sequential_skip_in_iterations, + nullptr /* read_callback */)); db_iter->SeekForPrev("a"); ASSERT_TRUE(db_iter->Valid()); diff --git a/db/db_memtable_test.cc b/db/db_memtable_test.cc index ff6f8396d..cc4aaeb81 100644 --- a/db/db_memtable_test.cc +++ b/db/db_memtable_test.cc @@ -139,7 +139,7 @@ TEST_F(DBMemTableTest, DuplicateSeq) { InternalKeyComparator cmp(BytewiseComparator()); auto factory = std::make_shared(); options.memtable_factory = factory; - ImmutableCFOptions ioptions(options); + ImmutableOptions ioptions(options); WriteBufferManager wb(options.db_write_buffer_size); MemTable* mem = new MemTable(cmp, ioptions, MutableCFOptions(options), &wb, kMaxSequenceNumber, 0 /* column_family_id */); @@ -184,7 +184,7 @@ TEST_F(DBMemTableTest, DuplicateSeq) { // Test with InsertWithHint options.memtable_insert_with_hint_prefix_extractor.reset( new TestPrefixExtractor()); // which uses _ to extract the prefix - ioptions = ImmutableCFOptions(options); + ioptions = ImmutableOptions(options); mem = new MemTable(cmp, ioptions, MutableCFOptions(options), &wb, kMaxSequenceNumber, 0 /* column_family_id */); // Insert a duplicate key with _ in it @@ -197,7 +197,7 @@ TEST_F(DBMemTableTest, DuplicateSeq) { // Test when InsertConcurrently will be invoked options.allow_concurrent_memtable_write = true; - ioptions = ImmutableCFOptions(options); + ioptions = ImmutableOptions(options); mem = new MemTable(cmp, ioptions, MutableCFOptions(options), &wb, kMaxSequenceNumber, 0 /* column_family_id */); MemTablePostProcessInfo post_process_info; @@ -224,7 +224,7 @@ TEST_F(DBMemTableTest, ConcurrentMergeWrite) { auto factory = std::make_shared(); options.memtable_factory = factory; options.allow_concurrent_memtable_write = true; - ImmutableCFOptions ioptions(options); + ImmutableOptions ioptions(options); WriteBufferManager wb(options.db_write_buffer_size); MemTable* mem = new MemTable(cmp, ioptions, MutableCFOptions(options), &wb, kMaxSequenceNumber, 0 /* column_family_id */); diff --git a/db/job_context.h b/db/job_context.h index d09937d11..841155200 100644 --- a/db/job_context.h +++ b/db/job_context.h @@ -23,7 +23,7 @@ struct SuperVersion; struct SuperVersionContext { struct WriteStallNotification { WriteStallInfo write_stall_info; - const ImmutableCFOptions* immutable_cf_options; + const ImmutableOptions* immutable_cf_options; }; autovector superversions_to_free; @@ -57,9 +57,10 @@ struct SuperVersionContext { #endif } - void PushWriteStallNotification( - WriteStallCondition old_cond, WriteStallCondition new_cond, - const std::string& name, const ImmutableCFOptions* ioptions) { + void PushWriteStallNotification(WriteStallCondition old_cond, + WriteStallCondition new_cond, + const std::string& name, + const ImmutableOptions* ioptions) { #if !defined(ROCKSDB_LITE) && !defined(ROCKSDB_DISABLE_STALL_NOTIFICATION) WriteStallNotification notif; notif.write_stall_info.cf_name = name; diff --git a/db/memtable.cc b/db/memtable.cc index 4ad9717dc..2b2598658 100644 --- a/db/memtable.cc +++ b/db/memtable.cc @@ -43,7 +43,7 @@ namespace ROCKSDB_NAMESPACE { ImmutableMemTableOptions::ImmutableMemTableOptions( - const ImmutableCFOptions& ioptions, + const ImmutableOptions& ioptions, const MutableCFOptions& mutable_cf_options) : arena_block_size(mutable_cf_options.arena_block_size), memtable_prefix_bloom_bits( @@ -64,7 +64,7 @@ ImmutableMemTableOptions::ImmutableMemTableOptions( allow_data_in_errors(ioptions.allow_data_in_errors) {} MemTable::MemTable(const InternalKeyComparator& cmp, - const ImmutableCFOptions& ioptions, + const ImmutableOptions& ioptions, const MutableCFOptions& mutable_cf_options, WriteBufferManager* write_buffer_manager, SequenceNumber latest_seq, uint32_t column_family_id) diff --git a/db/memtable.h b/db/memtable.h index 486aa6302..54155f9b5 100644 --- a/db/memtable.h +++ b/db/memtable.h @@ -40,7 +40,7 @@ class MergeContext; class SystemClock; struct ImmutableMemTableOptions { - explicit ImmutableMemTableOptions(const ImmutableCFOptions& ioptions, + explicit ImmutableMemTableOptions(const ImmutableOptions& ioptions, const MutableCFOptions& mutable_cf_options); size_t arena_block_size; uint32_t memtable_prefix_bloom_bits; @@ -103,7 +103,7 @@ class MemTable { // used, but this may prevent some transactions from succeeding until the // first key is inserted into the memtable. explicit MemTable(const InternalKeyComparator& comparator, - const ImmutableCFOptions& ioptions, + const ImmutableOptions& ioptions, const MutableCFOptions& mutable_cf_options, WriteBufferManager* write_buffer_manager, SequenceNumber earliest_seq, uint32_t column_family_id); diff --git a/db/memtable_list_test.cc b/db/memtable_list_test.cc index 7c6d15bfd..9dcee8e5d 100644 --- a/db/memtable_list_test.cc +++ b/db/memtable_list_test.cc @@ -235,7 +235,7 @@ TEST_F(MemTableListTest, GetTest) { InternalKeyComparator cmp(BytewiseComparator()); auto factory = std::make_shared(); options.memtable_factory = factory; - ImmutableCFOptions ioptions(options); + ImmutableOptions ioptions(options); WriteBufferManager wb(options.db_write_buffer_size); MemTable* mem = new MemTable(cmp, ioptions, MutableCFOptions(options), &wb, @@ -358,7 +358,7 @@ TEST_F(MemTableListTest, GetFromHistoryTest) { InternalKeyComparator cmp(BytewiseComparator()); auto factory = std::make_shared(); options.memtable_factory = factory; - ImmutableCFOptions ioptions(options); + ImmutableOptions ioptions(options); WriteBufferManager wb(options.db_write_buffer_size); MemTable* mem = new MemTable(cmp, ioptions, MutableCFOptions(options), &wb, @@ -539,7 +539,7 @@ TEST_F(MemTableListTest, FlushPendingTest) { auto factory = std::make_shared(); options.memtable_factory = factory; - ImmutableCFOptions ioptions(options); + ImmutableOptions ioptions(options); InternalKeyComparator cmp(BytewiseComparator()); WriteBufferManager wb(options.db_write_buffer_size); autovector to_delete; @@ -808,7 +808,7 @@ TEST_F(MemTableListTest, AtomicFlusTest) { auto factory = std::make_shared(); options.memtable_factory = factory; - ImmutableCFOptions ioptions(options); + ImmutableOptions ioptions(options); InternalKeyComparator cmp(BytewiseComparator()); WriteBufferManager wb(options.db_write_buffer_size); diff --git a/db/plain_table_db_test.cc b/db/plain_table_db_test.cc index 379e6b6b1..7f5023127 100644 --- a/db/plain_table_db_test.cc +++ b/db/plain_table_db_test.cc @@ -262,18 +262,15 @@ extern const uint64_t kPlainTableMagicNumber; class TestPlainTableReader : public PlainTableReader { public: - TestPlainTableReader(const EnvOptions& env_options, - const InternalKeyComparator& icomparator, - EncodingType encoding_type, uint64_t file_size, - int bloom_bits_per_key, double hash_table_ratio, - size_t index_sparseness, - const TableProperties* table_properties, - std::unique_ptr&& file, - const ImmutableCFOptions& ioptions, - const SliceTransform* prefix_extractor, - bool* expect_bloom_not_match, bool store_index_in_file, - uint32_t column_family_id, - const std::string& column_family_name) + TestPlainTableReader( + const EnvOptions& env_options, const InternalKeyComparator& icomparator, + EncodingType encoding_type, uint64_t file_size, int bloom_bits_per_key, + double hash_table_ratio, size_t index_sparseness, + const TableProperties* table_properties, + std::unique_ptr&& file, + const ImmutableOptions& ioptions, const SliceTransform* prefix_extractor, + bool* expect_bloom_not_match, bool store_index_in_file, + uint32_t column_family_id, const std::string& column_family_name) : PlainTableReader(ioptions, std::move(file), env_options, icomparator, encoding_type, file_size, table_properties, prefix_extractor), diff --git a/db/repair.cc b/db/repair.cc index 9d103a710..f48c51e21 100644 --- a/db/repair.cc +++ b/db/repair.cc @@ -100,8 +100,8 @@ class Repairer { icmp_(default_cf_opts.comparator), default_cf_opts_( SanitizeOptions(immutable_db_options_, default_cf_opts)), - default_cf_iopts_( - ImmutableCFOptions(immutable_db_options_, default_cf_opts_)), + default_iopts_( + ImmutableOptions(immutable_db_options_, default_cf_opts_)), unknown_cf_opts_( SanitizeOptions(immutable_db_options_, unknown_cf_opts)), create_unknown_cfs_(create_unknown_cfs), @@ -110,7 +110,7 @@ class Repairer { // once. NewLRUCache(10, db_options_.table_cache_numshardbits)), table_cache_(new TableCache( - default_cf_iopts_, env_options_, raw_table_cache_.get(), + default_iopts_, env_options_, raw_table_cache_.get(), /*block_cache_tracer=*/nullptr, /*io_tracer=*/nullptr)), wb_(db_options_.db_write_buffer_size), wc_(db_options_.delayed_write_rate), @@ -248,7 +248,7 @@ class Repairer { const ImmutableDBOptions immutable_db_options_; const InternalKeyComparator icmp_; const ColumnFamilyOptions default_cf_opts_; - const ImmutableCFOptions default_cf_iopts_; // table_cache_ holds reference + const ImmutableOptions default_iopts_; // table_cache_ holds reference const ColumnFamilyOptions unknown_cf_opts_; const bool create_unknown_cfs_; std::shared_ptr raw_table_cache_; diff --git a/db/table_cache.cc b/db/table_cache.cc index 3f4ca6435..133a7a527 100644 --- a/db/table_cache.cc +++ b/db/table_cache.cc @@ -65,7 +65,7 @@ void AppendVarint64(IterKey* key, uint64_t v) { const int kLoadConcurency = 128; -TableCache::TableCache(const ImmutableCFOptions& ioptions, +TableCache::TableCache(const ImmutableOptions& ioptions, const FileOptions& file_options, Cache* const cache, BlockCacheTracer* const block_cache_tracer, const std::shared_ptr& io_tracer) diff --git a/db/table_cache.h b/db/table_cache.h index df459ecbe..07e405927 100644 --- a/db/table_cache.h +++ b/db/table_cache.h @@ -48,7 +48,7 @@ class HistogramImpl; // ioptions.row_cache class TableCache { public: - TableCache(const ImmutableCFOptions& ioptions, + TableCache(const ImmutableOptions& ioptions, const FileOptions& storage_options, Cache* cache, BlockCacheTracer* const block_cache_tracer, const std::shared_ptr& io_tracer); @@ -220,7 +220,7 @@ class TableCache { bool GetFromRowCache(const Slice& user_key, IterKey& row_cache_key, size_t prefix_size, GetContext* get_context); - const ImmutableCFOptions& ioptions_; + const ImmutableOptions& ioptions_; const FileOptions& file_options_; Cache* const cache_; std::string row_cache_id_; diff --git a/db/table_properties_collector_test.cc b/db/table_properties_collector_test.cc index aff95c40d..0c67c8901 100644 --- a/db/table_properties_collector_test.cc +++ b/db/table_properties_collector_test.cc @@ -41,7 +41,7 @@ namespace { static const uint32_t kTestColumnFamilyId = 66; static const std::string kTestColumnFamilyName = "test_column_fam"; -void MakeBuilder(const Options& options, const ImmutableCFOptions& ioptions, +void MakeBuilder(const Options& options, const ImmutableOptions& ioptions, const MutableCFOptions& moptions, const InternalKeyComparator& internal_comparator, const std::vector>* @@ -262,7 +262,7 @@ void TestCustomizedTablePropertiesCollector( // -- Step 1: build table std::unique_ptr builder; std::unique_ptr writer; - const ImmutableCFOptions ioptions(options); + const ImmutableOptions ioptions(options); const MutableCFOptions moptions(options); std::vector> int_tbl_prop_collector_factories; @@ -409,11 +409,11 @@ void TestInternalKeyPropertiesCollector( options.info_log = std::make_shared(); options = SanitizeOptions("db", // just a place holder options); - ImmutableCFOptions ioptions(options); + ImmutableOptions ioptions(options); GetIntTblPropCollectorFactory(ioptions, &int_tbl_prop_collector_factories); options.comparator = comparator; } - const ImmutableCFOptions ioptions(options); + const ImmutableOptions ioptions(options); MutableCFOptions moptions(options); for (int iter = 0; iter < 2; ++iter) { diff --git a/db/version_builder_test.cc b/db/version_builder_test.cc index 9dca9ec2a..26b473f0f 100644 --- a/db/version_builder_test.cc +++ b/db/version_builder_test.cc @@ -22,7 +22,7 @@ class VersionBuilderTest : public testing::Test { const Comparator* ucmp_; InternalKeyComparator icmp_; Options options_; - ImmutableCFOptions ioptions_; + ImmutableOptions ioptions_; MutableCFOptions mutable_cf_options_; VersionStorageInfo vstorage_; uint32_t file_num_; diff --git a/db/version_set.cc b/db/version_set.cc index 47cacfa70..39c2b9a89 100644 --- a/db/version_set.cc +++ b/db/version_set.cc @@ -2526,7 +2526,7 @@ void VersionStorageInfo::EstimateCompactionBytesNeeded( } namespace { -uint32_t GetExpiredTtlFilesCount(const ImmutableCFOptions& ioptions, +uint32_t GetExpiredTtlFilesCount(const ImmutableOptions& ioptions, const MutableCFOptions& mutable_cf_options, const std::vector& files) { uint32_t ttl_expired_files_count = 0; @@ -2550,7 +2550,7 @@ uint32_t GetExpiredTtlFilesCount(const ImmutableCFOptions& ioptions, } // anonymous namespace void VersionStorageInfo::ComputeCompactionScore( - const ImmutableCFOptions& immutable_cf_options, + const ImmutableOptions& immutable_cf_options, const MutableCFOptions& mutable_cf_options) { for (int level = 0; level <= MaxInputLevel(); level++) { double score; @@ -2695,7 +2695,7 @@ void VersionStorageInfo::ComputeFilesMarkedForCompaction() { } void VersionStorageInfo::ComputeExpiredTtlFiles( - const ImmutableCFOptions& ioptions, const uint64_t ttl) { + const ImmutableOptions& ioptions, const uint64_t ttl) { assert(ttl > 0); expired_ttl_files_.clear(); @@ -2721,7 +2721,7 @@ void VersionStorageInfo::ComputeExpiredTtlFiles( } void VersionStorageInfo::ComputeFilesMarkedForPeriodicCompaction( - const ImmutableCFOptions& ioptions, + const ImmutableOptions& ioptions, const uint64_t periodic_compaction_seconds) { assert(periodic_compaction_seconds > 0); @@ -3395,7 +3395,7 @@ uint64_t VersionStorageInfo::MaxBytesForLevel(int level) const { return level_max_bytes_[level]; } -void VersionStorageInfo::CalculateBaseBytes(const ImmutableCFOptions& ioptions, +void VersionStorageInfo::CalculateBaseBytes(const ImmutableOptions& ioptions, const MutableCFOptions& options) { // Special logic to set number of sorted runs. // It is to match the previous behavior when all files are in L0. diff --git a/db/version_set.h b/db/version_set.h index 7d5f306c2..74c35e82f 100644 --- a/db/version_set.h +++ b/db/version_set.h @@ -150,7 +150,7 @@ class VersionStorageInfo { // We use compaction scores to figure out which compaction to do next // REQUIRES: db_mutex held!! // TODO find a better way to pass compaction_options_fifo. - void ComputeCompactionScore(const ImmutableCFOptions& immutable_cf_options, + void ComputeCompactionScore(const ImmutableOptions& immutable_cf_options, const MutableCFOptions& mutable_cf_options); // Estimate est_comp_needed_bytes_ @@ -163,13 +163,13 @@ class VersionStorageInfo { // This computes ttl_expired_files_ and is called by // ComputeCompactionScore() - void ComputeExpiredTtlFiles(const ImmutableCFOptions& ioptions, + void ComputeExpiredTtlFiles(const ImmutableOptions& ioptions, const uint64_t ttl); // This computes files_marked_for_periodic_compaction_ and is called by // ComputeCompactionScore() void ComputeFilesMarkedForPeriodicCompaction( - const ImmutableCFOptions& ioptions, + const ImmutableOptions& ioptions, const uint64_t periodic_compaction_seconds); // This computes bottommost_files_marked_for_compaction_ and is called by @@ -482,7 +482,7 @@ class VersionStorageInfo { uint64_t MaxBytesForLevel(int level) const; // Must be called after any change to MutableCFOptions. - void CalculateBaseBytes(const ImmutableCFOptions& ioptions, + void CalculateBaseBytes(const ImmutableOptions& ioptions, const MutableCFOptions& options); // Returns an estimate of the amount of live data in bytes. diff --git a/db/version_set_test.cc b/db/version_set_test.cc index b03fe6a5e..74502668d 100644 --- a/db/version_set_test.cc +++ b/db/version_set_test.cc @@ -103,7 +103,7 @@ class VersionStorageInfoTestBase : public testing::Test { InternalKeyComparator icmp_; std::shared_ptr logger_; Options options_; - ImmutableCFOptions ioptions_; + ImmutableOptions ioptions_; MutableCFOptions mutable_cf_options_; VersionStorageInfo vstorage_; @@ -723,7 +723,8 @@ class VersionSetTestBase { db_options_.env = env_; db_options_.fs = fs_; immutable_cf_options_.env = env_; - immutable_cf_options_.fs = fs_.get(); + immutable_cf_options_.fs = fs_; + immutable_cf_options_.clock = env_->GetSystemClock().get(); versions_.reset( new VersionSet(dbname_, &db_options_, env_options_, table_cache_.get(), @@ -909,7 +910,7 @@ class VersionSetTestBase { Options options_; ImmutableDBOptions db_options_; ColumnFamilyOptions cf_options_; - ImmutableCFOptions immutable_cf_options_; + ImmutableOptions immutable_cf_options_; MutableCFOptions mutable_cf_options_; std::shared_ptr table_cache_; WriteController write_controller_; diff --git a/db/write_batch_test.cc b/db/write_batch_test.cc index ba73e206c..e4043cc40 100644 --- a/db/write_batch_test.cc +++ b/db/write_batch_test.cc @@ -33,7 +33,7 @@ static std::string PrintContents(WriteBatch* b, if (merge_operator_supported) { options.merge_operator.reset(new TestPutOperator()); } - ImmutableCFOptions ioptions(options); + ImmutableOptions ioptions(options); WriteBufferManager wb(options.db_write_buffer_size); MemTable* mem = new MemTable(cmp, ioptions, MutableCFOptions(options), &wb, kMaxSequenceNumber, 0 /* column_family_id */); diff --git a/file/filename.cc b/file/filename.cc index 0496596c6..e821a5a0b 100644 --- a/file/filename.cc +++ b/file/filename.cc @@ -424,8 +424,7 @@ Status SetIdentityFile(Env* env, const std::string& dbname, IOStatus SyncManifest(const ImmutableDBOptions* db_options, WritableFileWriter* file) { TEST_KILL_RANDOM("SyncManifest:0", rocksdb_kill_odds * REDUCE_ODDS2); - StopWatch sw(db_options->clock, db_options->statistics.get(), - MANIFEST_FILE_SYNC_MICROS); + StopWatch sw(db_options->clock, db_options->stats, MANIFEST_FILE_SYNC_MICROS); return file->Sync(db_options->use_fsync); } diff --git a/java/rocksjni/write_batch_test.cc b/java/rocksjni/write_batch_test.cc index 8b6de630c..dd6e0b36c 100644 --- a/java/rocksjni/write_batch_test.cc +++ b/java/rocksjni/write_batch_test.cc @@ -47,7 +47,7 @@ jbyteArray Java_org_rocksdb_WriteBatchTest_getContents(JNIEnv* env, ROCKSDB_NAMESPACE::WriteBufferManager wb(options.db_write_buffer_size); options.memtable_factory = factory; ROCKSDB_NAMESPACE::MemTable* mem = new ROCKSDB_NAMESPACE::MemTable( - cmp, ROCKSDB_NAMESPACE::ImmutableCFOptions(options), + cmp, ROCKSDB_NAMESPACE::ImmutableOptions(options), ROCKSDB_NAMESPACE::MutableCFOptions(options), &wb, ROCKSDB_NAMESPACE::kMaxSequenceNumber, 0 /* column_family_id */); mem->Ref(); diff --git a/options/cf_options.cc b/options/cf_options.cc index 7a10c8b42..9a62cc9df 100644 --- a/options/cf_options.cc +++ b/options/cf_options.cc @@ -701,7 +701,7 @@ class ConfigurableCFOptions : public ConfigurableMutableCFOptions { ConfigurableCFOptions(const ColumnFamilyOptions& opts, const std::unordered_map* map) : ConfigurableMutableCFOptions(MutableCFOptions(opts)), - immutable_(ImmutableDBOptions(), opts), + immutable_(opts), cf_options_(opts), opt_map_(map) { RegisterOptions(&immutable_, &cf_immutable_options_type_info); @@ -714,7 +714,8 @@ class ConfigurableCFOptions : public ConfigurableMutableCFOptions { std::unordered_map* unused) override { Status s = Configurable::ConfigureOptions(config_options, opts_map, unused); if (s.ok()) { - cf_options_ = BuildColumnFamilyOptions(immutable_, mutable_); + UpdateColumnFamilyOptions(mutable_, &cf_options_); + UpdateColumnFamilyOptions(immutable_, &cf_options_); s = PrepareOptions(config_options); } return s; @@ -788,11 +789,7 @@ std::unique_ptr CFOptionsAsConfigurable( ImmutableCFOptions::ImmutableCFOptions() : ImmutableCFOptions(Options()) {} -ImmutableCFOptions::ImmutableCFOptions(const Options& options) - : ImmutableCFOptions(ImmutableDBOptions(options), options) {} - -ImmutableCFOptions::ImmutableCFOptions(const ImmutableDBOptions& db_options, - const ColumnFamilyOptions& cf_options) +ImmutableCFOptions::ImmutableCFOptions(const ColumnFamilyOptions& cf_options) : compaction_style(cf_options.compaction_style), compaction_pri(cf_options.compaction_pri), user_comparator(cf_options.comparator), @@ -808,48 +805,45 @@ ImmutableCFOptions::ImmutableCFOptions(const ImmutableDBOptions& db_options, cf_options.max_write_buffer_size_to_maintain), inplace_update_support(cf_options.inplace_update_support), inplace_callback(cf_options.inplace_callback), - logger(db_options.logger), - stats(db_options.stats), - rate_limiter(db_options.rate_limiter), - info_log_level(db_options.info_log_level), - env(db_options.env), - fs(db_options.fs.get()), - clock(db_options.clock), - allow_mmap_reads(db_options.allow_mmap_reads), - allow_mmap_writes(db_options.allow_mmap_writes), - db_paths(db_options.db_paths), memtable_factory(cf_options.memtable_factory), table_factory(cf_options.table_factory), table_properties_collector_factories( cf_options.table_properties_collector_factories), - advise_random_on_open(db_options.advise_random_on_open), bloom_locality(cf_options.bloom_locality), purge_redundant_kvs_while_flush( cf_options.purge_redundant_kvs_while_flush), - use_fsync(db_options.use_fsync), compression_per_level(cf_options.compression_per_level), level_compaction_dynamic_level_bytes( cf_options.level_compaction_dynamic_level_bytes), - access_hint_on_compaction_start( - db_options.access_hint_on_compaction_start), - new_table_reader_for_compaction_inputs( - db_options.new_table_reader_for_compaction_inputs), num_levels(cf_options.num_levels), optimize_filters_for_hits(cf_options.optimize_filters_for_hits), force_consistency_checks(cf_options.force_consistency_checks), - allow_ingest_behind(db_options.allow_ingest_behind), - preserve_deletes(db_options.preserve_deletes), - listeners(db_options.listeners), - row_cache(db_options.row_cache), memtable_insert_with_hint_prefix_extractor( cf_options.memtable_insert_with_hint_prefix_extractor), cf_paths(cf_options.cf_paths), compaction_thread_limiter(cf_options.compaction_thread_limiter), - file_checksum_gen_factory(db_options.file_checksum_gen_factory), - sst_partitioner_factory(cf_options.sst_partitioner_factory), - allow_data_in_errors(db_options.allow_data_in_errors), - db_host_id(db_options.db_host_id), - checksum_handoff_file_types(db_options.checksum_handoff_file_types) {} + sst_partitioner_factory(cf_options.sst_partitioner_factory) {} + +ImmutableOptions::ImmutableOptions() : ImmutableOptions(Options()) {} + +ImmutableOptions::ImmutableOptions(const Options& options) + : ImmutableOptions(options, options) {} + +ImmutableOptions::ImmutableOptions(const DBOptions& db_options, + const ColumnFamilyOptions& cf_options) + : ImmutableDBOptions(db_options), ImmutableCFOptions(cf_options) {} + +ImmutableOptions::ImmutableOptions(const DBOptions& db_options, + const ImmutableCFOptions& cf_options) + : ImmutableDBOptions(db_options), ImmutableCFOptions(cf_options) {} + +ImmutableOptions::ImmutableOptions(const ImmutableDBOptions& db_options, + const ColumnFamilyOptions& cf_options) + : ImmutableDBOptions(db_options), ImmutableCFOptions(cf_options) {} + +ImmutableOptions::ImmutableOptions(const ImmutableDBOptions& db_options, + const ImmutableCFOptions& cf_options) + : ImmutableDBOptions(db_options), ImmutableCFOptions(cf_options) {} // Multiple two operands. If they overflow, return op1. uint64_t MultiplyCheckOverflow(uint64_t op1, double op2) { diff --git a/options/cf_options.h b/options/cf_options.h index 8330a4380..0cb95e619 100644 --- a/options/cf_options.h +++ b/options/cf_options.h @@ -23,10 +23,7 @@ struct ImmutableCFOptions { public: static const char* kName() { return "ImmutableCFOptions"; } explicit ImmutableCFOptions(); - explicit ImmutableCFOptions(const Options& options); - - ImmutableCFOptions(const ImmutableDBOptions& db_options, - const ColumnFamilyOptions& cf_options); + explicit ImmutableCFOptions(const ColumnFamilyOptions& cf_options); CompactionStyle compaction_style; @@ -54,28 +51,6 @@ struct ImmutableCFOptions { Slice delta_value, std::string* merged_value); - Logger* logger; // ImmutableDBOptions - - Statistics* stats; // ImmutableDBOptions - - std::shared_ptr rate_limiter; // ImmutableDBOptions - - InfoLogLevel info_log_level; // ImmutableDBOptions - - Env* env; // ImmutableDBOptions - - FileSystem* fs; // ImmutableDBOptions - - SystemClock* clock; // ImmutableDBOptions - - // Allow the OS to mmap file for reading sst tables. Default: false - bool allow_mmap_reads; // ImmutableDBOptions - - // Allow the OS to mmap file for writing. Default: false - bool allow_mmap_writes; // ImmutableDBOptions - - std::vector db_paths; // ImmutableDBOptions - std::shared_ptr memtable_factory; std::shared_ptr table_factory; @@ -83,40 +58,22 @@ struct ImmutableCFOptions { Options::TablePropertiesCollectorFactories table_properties_collector_factories; - bool advise_random_on_open; // ImmutableDBOptions - // This options is required by PlainTableReader. May need to move it // to PlainTableOptions just like bloom_bits_per_key uint32_t bloom_locality; bool purge_redundant_kvs_while_flush; - bool use_fsync; // ImmutableDBOptions - std::vector compression_per_level; bool level_compaction_dynamic_level_bytes; - Options::AccessHint access_hint_on_compaction_start; // ImmutableDBOptions - - bool new_table_reader_for_compaction_inputs; // ImmutableDBOptions - int num_levels; bool optimize_filters_for_hits; bool force_consistency_checks; - bool allow_ingest_behind; // ImmutableDBOptions - - bool preserve_deletes; // ImmutableDBOptions - - // A vector of EventListeners which callback functions will be called - // when specific RocksDB event happens. - std::vector> listeners; // ImmutableDBOptions - - std::shared_ptr row_cache; // ImmutableDBOptions - std::shared_ptr memtable_insert_with_hint_prefix_extractor; @@ -124,16 +81,24 @@ struct ImmutableCFOptions { std::shared_ptr compaction_thread_limiter; - std::shared_ptr - file_checksum_gen_factory; // ImmutableDBOptions - std::shared_ptr sst_partitioner_factory; +}; + +struct ImmutableOptions : public ImmutableDBOptions, public ImmutableCFOptions { + explicit ImmutableOptions(); + explicit ImmutableOptions(const Options& options); + + ImmutableOptions(const DBOptions& db_options, + const ColumnFamilyOptions& cf_options); - bool allow_data_in_errors; // ImmutableDBOptions + ImmutableOptions(const ImmutableDBOptions& db_options, + const ImmutableCFOptions& cf_options); - std::string db_host_id; // ImmutableDBOptions + ImmutableOptions(const DBOptions& db_options, + const ImmutableCFOptions& cf_options); - FileTypeSet checksum_handoff_file_types; // ImmutableDBOptions + ImmutableOptions(const ImmutableDBOptions& db_options, + const ColumnFamilyOptions& cf_options); }; struct MutableCFOptions { diff --git a/options/db_options.cc b/options/db_options.cc index 486558bff..d941e6c6c 100644 --- a/options/db_options.cc +++ b/options/db_options.cc @@ -580,6 +580,7 @@ ImmutableDBOptions::ImmutableDBOptions(const DBOptions& options) allow_data_in_errors(options.allow_data_in_errors), db_host_id(options.db_host_id), checksum_handoff_file_types(options.checksum_handoff_file_types) { + stats = statistics.get(); fs = env->GetFileSystem(); if (env != nullptr) { clock = env->GetSystemClock().get(); @@ -610,7 +611,7 @@ void ImmutableDBOptions::Dump(Logger* log) const { ROCKS_LOG_HEADER(log, " Options.max_file_opening_threads: %d", max_file_opening_threads); ROCKS_LOG_HEADER(log, " Options.statistics: %p", - statistics.get()); + stats); ROCKS_LOG_HEADER(log, " Options.use_fsync: %d", use_fsync); ROCKS_LOG_HEADER( diff --git a/options/options_helper.cc b/options/options_helper.cc index d39c3f3df..f56ac1b2e 100644 --- a/options/options_helper.cc +++ b/options/options_helper.cc @@ -177,190 +177,115 @@ ColumnFamilyOptions BuildColumnFamilyOptions( const ColumnFamilyOptions& options, const MutableCFOptions& mutable_cf_options) { ColumnFamilyOptions cf_opts(options); - - // Memtable related options - cf_opts.write_buffer_size = mutable_cf_options.write_buffer_size; - cf_opts.max_write_buffer_number = mutable_cf_options.max_write_buffer_number; - cf_opts.arena_block_size = mutable_cf_options.arena_block_size; - cf_opts.memtable_prefix_bloom_size_ratio = - mutable_cf_options.memtable_prefix_bloom_size_ratio; - cf_opts.memtable_whole_key_filtering = - mutable_cf_options.memtable_whole_key_filtering; - cf_opts.memtable_huge_page_size = mutable_cf_options.memtable_huge_page_size; - cf_opts.max_successive_merges = mutable_cf_options.max_successive_merges; - cf_opts.inplace_update_num_locks = - mutable_cf_options.inplace_update_num_locks; - cf_opts.prefix_extractor = mutable_cf_options.prefix_extractor; - - // Compaction related options - cf_opts.disable_auto_compactions = - mutable_cf_options.disable_auto_compactions; - cf_opts.soft_pending_compaction_bytes_limit = - mutable_cf_options.soft_pending_compaction_bytes_limit; - cf_opts.hard_pending_compaction_bytes_limit = - mutable_cf_options.hard_pending_compaction_bytes_limit; - cf_opts.level0_file_num_compaction_trigger = - mutable_cf_options.level0_file_num_compaction_trigger; - cf_opts.level0_slowdown_writes_trigger = - mutable_cf_options.level0_slowdown_writes_trigger; - cf_opts.level0_stop_writes_trigger = - mutable_cf_options.level0_stop_writes_trigger; - cf_opts.max_compaction_bytes = mutable_cf_options.max_compaction_bytes; - cf_opts.target_file_size_base = mutable_cf_options.target_file_size_base; - cf_opts.target_file_size_multiplier = - mutable_cf_options.target_file_size_multiplier; - cf_opts.max_bytes_for_level_base = - mutable_cf_options.max_bytes_for_level_base; - cf_opts.max_bytes_for_level_multiplier = - mutable_cf_options.max_bytes_for_level_multiplier; - cf_opts.ttl = mutable_cf_options.ttl; - cf_opts.periodic_compaction_seconds = - mutable_cf_options.periodic_compaction_seconds; - - cf_opts.max_bytes_for_level_multiplier_additional.clear(); - for (auto value : - mutable_cf_options.max_bytes_for_level_multiplier_additional) { - cf_opts.max_bytes_for_level_multiplier_additional.emplace_back(value); - } - - cf_opts.compaction_options_fifo = mutable_cf_options.compaction_options_fifo; - cf_opts.compaction_options_universal = - mutable_cf_options.compaction_options_universal; - - // Blob file related options - cf_opts.enable_blob_files = mutable_cf_options.enable_blob_files; - cf_opts.min_blob_size = mutable_cf_options.min_blob_size; - cf_opts.blob_file_size = mutable_cf_options.blob_file_size; - cf_opts.blob_compression_type = mutable_cf_options.blob_compression_type; - cf_opts.enable_blob_garbage_collection = - mutable_cf_options.enable_blob_garbage_collection; - cf_opts.blob_garbage_collection_age_cutoff = - mutable_cf_options.blob_garbage_collection_age_cutoff; - - // Misc options - cf_opts.max_sequential_skip_in_iterations = - mutable_cf_options.max_sequential_skip_in_iterations; - cf_opts.check_flush_compaction_key_order = - mutable_cf_options.check_flush_compaction_key_order; - cf_opts.paranoid_file_checks = mutable_cf_options.paranoid_file_checks; - cf_opts.report_bg_io_stats = mutable_cf_options.report_bg_io_stats; - cf_opts.compression = mutable_cf_options.compression; - cf_opts.compression_opts = mutable_cf_options.compression_opts; - cf_opts.bottommost_compression = mutable_cf_options.bottommost_compression; - cf_opts.bottommost_compression_opts = - mutable_cf_options.bottommost_compression_opts; - cf_opts.sample_for_compression = mutable_cf_options.sample_for_compression; - - cf_opts.table_factory = options.table_factory; + UpdateColumnFamilyOptions(mutable_cf_options, &cf_opts); // TODO(yhchiang): find some way to handle the following derived options // * max_file_size - return cf_opts; } -ColumnFamilyOptions BuildColumnFamilyOptions(const ImmutableCFOptions& ioptions, - const MutableCFOptions& moptions) { - ColumnFamilyOptions cf_opts; +void UpdateColumnFamilyOptions(const MutableCFOptions& moptions, + ColumnFamilyOptions* cf_opts) { // Memtable related options - cf_opts.write_buffer_size = moptions.write_buffer_size; - cf_opts.max_write_buffer_number = moptions.max_write_buffer_number; - cf_opts.arena_block_size = moptions.arena_block_size; - cf_opts.memtable_prefix_bloom_size_ratio = + cf_opts->write_buffer_size = moptions.write_buffer_size; + cf_opts->max_write_buffer_number = moptions.max_write_buffer_number; + cf_opts->arena_block_size = moptions.arena_block_size; + cf_opts->memtable_prefix_bloom_size_ratio = moptions.memtable_prefix_bloom_size_ratio; - cf_opts.memtable_whole_key_filtering = moptions.memtable_whole_key_filtering; - cf_opts.memtable_huge_page_size = moptions.memtable_huge_page_size; - cf_opts.max_successive_merges = moptions.max_successive_merges; - cf_opts.inplace_update_num_locks = moptions.inplace_update_num_locks; - cf_opts.prefix_extractor = moptions.prefix_extractor; + cf_opts->memtable_whole_key_filtering = moptions.memtable_whole_key_filtering; + cf_opts->memtable_huge_page_size = moptions.memtable_huge_page_size; + cf_opts->max_successive_merges = moptions.max_successive_merges; + cf_opts->inplace_update_num_locks = moptions.inplace_update_num_locks; + cf_opts->prefix_extractor = moptions.prefix_extractor; // Compaction related options - cf_opts.disable_auto_compactions = moptions.disable_auto_compactions; - cf_opts.soft_pending_compaction_bytes_limit = + cf_opts->disable_auto_compactions = moptions.disable_auto_compactions; + cf_opts->soft_pending_compaction_bytes_limit = moptions.soft_pending_compaction_bytes_limit; - cf_opts.hard_pending_compaction_bytes_limit = + cf_opts->hard_pending_compaction_bytes_limit = moptions.hard_pending_compaction_bytes_limit; - cf_opts.level0_file_num_compaction_trigger = + cf_opts->level0_file_num_compaction_trigger = moptions.level0_file_num_compaction_trigger; - cf_opts.level0_slowdown_writes_trigger = + cf_opts->level0_slowdown_writes_trigger = moptions.level0_slowdown_writes_trigger; - cf_opts.level0_stop_writes_trigger = moptions.level0_stop_writes_trigger; - cf_opts.max_compaction_bytes = moptions.max_compaction_bytes; - cf_opts.target_file_size_base = moptions.target_file_size_base; - cf_opts.target_file_size_multiplier = moptions.target_file_size_multiplier; - cf_opts.max_bytes_for_level_base = moptions.max_bytes_for_level_base; - cf_opts.max_bytes_for_level_multiplier = + cf_opts->level0_stop_writes_trigger = moptions.level0_stop_writes_trigger; + cf_opts->max_compaction_bytes = moptions.max_compaction_bytes; + cf_opts->target_file_size_base = moptions.target_file_size_base; + cf_opts->target_file_size_multiplier = moptions.target_file_size_multiplier; + cf_opts->max_bytes_for_level_base = moptions.max_bytes_for_level_base; + cf_opts->max_bytes_for_level_multiplier = moptions.max_bytes_for_level_multiplier; - cf_opts.ttl = moptions.ttl; - cf_opts.periodic_compaction_seconds = moptions.periodic_compaction_seconds; + cf_opts->ttl = moptions.ttl; + cf_opts->periodic_compaction_seconds = moptions.periodic_compaction_seconds; - cf_opts.max_bytes_for_level_multiplier_additional.clear(); + cf_opts->max_bytes_for_level_multiplier_additional.clear(); for (auto value : moptions.max_bytes_for_level_multiplier_additional) { - cf_opts.max_bytes_for_level_multiplier_additional.emplace_back(value); + cf_opts->max_bytes_for_level_multiplier_additional.emplace_back(value); } - cf_opts.compaction_options_fifo = moptions.compaction_options_fifo; - cf_opts.compaction_options_universal = moptions.compaction_options_universal; + cf_opts->compaction_options_fifo = moptions.compaction_options_fifo; + cf_opts->compaction_options_universal = moptions.compaction_options_universal; // Blob file related options - cf_opts.enable_blob_files = moptions.enable_blob_files; - cf_opts.min_blob_size = moptions.min_blob_size; - cf_opts.blob_file_size = moptions.blob_file_size; - cf_opts.blob_compression_type = moptions.blob_compression_type; - cf_opts.enable_blob_garbage_collection = + cf_opts->enable_blob_files = moptions.enable_blob_files; + cf_opts->min_blob_size = moptions.min_blob_size; + cf_opts->blob_file_size = moptions.blob_file_size; + cf_opts->blob_compression_type = moptions.blob_compression_type; + cf_opts->enable_blob_garbage_collection = moptions.enable_blob_garbage_collection; - cf_opts.blob_garbage_collection_age_cutoff = + cf_opts->blob_garbage_collection_age_cutoff = moptions.blob_garbage_collection_age_cutoff; // Misc options - cf_opts.max_sequential_skip_in_iterations = + cf_opts->max_sequential_skip_in_iterations = moptions.max_sequential_skip_in_iterations; - cf_opts.check_flush_compaction_key_order = + cf_opts->check_flush_compaction_key_order = moptions.check_flush_compaction_key_order; - cf_opts.paranoid_file_checks = moptions.paranoid_file_checks; - cf_opts.report_bg_io_stats = moptions.report_bg_io_stats; - cf_opts.compression = moptions.compression; - cf_opts.compression_opts = moptions.compression_opts; - cf_opts.bottommost_compression = moptions.bottommost_compression; - cf_opts.bottommost_compression_opts = moptions.bottommost_compression_opts; - cf_opts.sample_for_compression = moptions.sample_for_compression; - - cf_opts.compaction_style = ioptions.compaction_style; - cf_opts.compaction_pri = ioptions.compaction_pri; - cf_opts.comparator = ioptions.user_comparator; - cf_opts.merge_operator = ioptions.merge_operator; - cf_opts.compaction_filter = ioptions.compaction_filter; - cf_opts.compaction_filter_factory = ioptions.compaction_filter_factory; - cf_opts.min_write_buffer_number_to_merge = + cf_opts->paranoid_file_checks = moptions.paranoid_file_checks; + cf_opts->report_bg_io_stats = moptions.report_bg_io_stats; + cf_opts->compression = moptions.compression; + cf_opts->compression_opts = moptions.compression_opts; + cf_opts->bottommost_compression = moptions.bottommost_compression; + cf_opts->bottommost_compression_opts = moptions.bottommost_compression_opts; + cf_opts->sample_for_compression = moptions.sample_for_compression; +} + +void UpdateColumnFamilyOptions(const ImmutableCFOptions& ioptions, + ColumnFamilyOptions* cf_opts) { + cf_opts->compaction_style = ioptions.compaction_style; + cf_opts->compaction_pri = ioptions.compaction_pri; + cf_opts->comparator = ioptions.user_comparator; + cf_opts->merge_operator = ioptions.merge_operator; + cf_opts->compaction_filter = ioptions.compaction_filter; + cf_opts->compaction_filter_factory = ioptions.compaction_filter_factory; + cf_opts->min_write_buffer_number_to_merge = ioptions.min_write_buffer_number_to_merge; - cf_opts.max_write_buffer_number_to_maintain = + cf_opts->max_write_buffer_number_to_maintain = ioptions.max_write_buffer_number_to_maintain; - cf_opts.max_write_buffer_size_to_maintain = + cf_opts->max_write_buffer_size_to_maintain = ioptions.max_write_buffer_size_to_maintain; - cf_opts.inplace_update_support = ioptions.inplace_update_support; - cf_opts.inplace_callback = ioptions.inplace_callback; - cf_opts.memtable_factory = ioptions.memtable_factory; - cf_opts.table_factory = ioptions.table_factory; - cf_opts.table_properties_collector_factories = + cf_opts->inplace_update_support = ioptions.inplace_update_support; + cf_opts->inplace_callback = ioptions.inplace_callback; + cf_opts->memtable_factory = ioptions.memtable_factory; + cf_opts->table_factory = ioptions.table_factory; + cf_opts->table_properties_collector_factories = ioptions.table_properties_collector_factories; - cf_opts.bloom_locality = ioptions.bloom_locality; - cf_opts.purge_redundant_kvs_while_flush = + cf_opts->bloom_locality = ioptions.bloom_locality; + cf_opts->purge_redundant_kvs_while_flush = ioptions.purge_redundant_kvs_while_flush; - cf_opts.compression_per_level = ioptions.compression_per_level; - cf_opts.level_compaction_dynamic_level_bytes = + cf_opts->compression_per_level = ioptions.compression_per_level; + cf_opts->level_compaction_dynamic_level_bytes = ioptions.level_compaction_dynamic_level_bytes; - cf_opts.num_levels = ioptions.num_levels; - cf_opts.optimize_filters_for_hits = ioptions.optimize_filters_for_hits; - cf_opts.force_consistency_checks = ioptions.force_consistency_checks; - cf_opts.memtable_insert_with_hint_prefix_extractor = + cf_opts->num_levels = ioptions.num_levels; + cf_opts->optimize_filters_for_hits = ioptions.optimize_filters_for_hits; + cf_opts->force_consistency_checks = ioptions.force_consistency_checks; + cf_opts->memtable_insert_with_hint_prefix_extractor = ioptions.memtable_insert_with_hint_prefix_extractor; - cf_opts.cf_paths = ioptions.cf_paths; - cf_opts.compaction_thread_limiter = ioptions.compaction_thread_limiter; - cf_opts.sst_partitioner_factory = ioptions.sst_partitioner_factory; + cf_opts->cf_paths = ioptions.cf_paths; + cf_opts->compaction_thread_limiter = ioptions.compaction_thread_limiter; + cf_opts->sst_partitioner_factory = ioptions.sst_partitioner_factory; // TODO(yhchiang): find some way to handle the following derived options // * max_file_size - - return cf_opts; } std::map diff --git a/options/options_helper.h b/options/options_helper.h index f27d8f182..fa3cab41d 100644 --- a/options/options_helper.h +++ b/options/options_helper.h @@ -38,8 +38,11 @@ DBOptions BuildDBOptions(const ImmutableDBOptions& immutable_db_options, ColumnFamilyOptions BuildColumnFamilyOptions( const ColumnFamilyOptions& ioptions, const MutableCFOptions& mutable_cf_options); -ColumnFamilyOptions BuildColumnFamilyOptions(const ImmutableCFOptions& ioptions, - const MutableCFOptions& moptions); + +void UpdateColumnFamilyOptions(const ImmutableCFOptions& ioptions, + ColumnFamilyOptions* cf_opts); +void UpdateColumnFamilyOptions(const MutableCFOptions& moptions, + ColumnFamilyOptions* cf_opts); #ifndef ROCKSDB_LITE std::unique_ptr DBOptionsAsConfigurable( diff --git a/options/options_test.cc b/options/options_test.cc index 21c2df28d..e3486ac41 100644 --- a/options/options_test.cc +++ b/options/options_test.cc @@ -1321,8 +1321,9 @@ TEST_F(OptionsTest, CFOptionsComposeImmutable) { DBOptions dummy; // Needed to create ImmutableCFOptions test::RandomInitCFOptions(&base_opts, dummy, &rnd); MutableCFOptions m_opts(base_opts); - ImmutableCFOptions i_opts(ImmutableDBOptions(dummy), base_opts); - new_opts = BuildColumnFamilyOptions(i_opts, m_opts); + ImmutableCFOptions i_opts(base_opts); + UpdateColumnFamilyOptions(i_opts, &new_opts); + UpdateColumnFamilyOptions(m_opts, &new_opts); ASSERT_OK(RocksDBOptionsParser::VerifyCFOptions(config_options, base_opts, new_opts)); delete new_opts.compaction_filter; diff --git a/table/block_based/block_based_table_builder.cc b/table/block_based/block_based_table_builder.cc index 8f971446a..314b5393e 100644 --- a/table/block_based/block_based_table_builder.cc +++ b/table/block_based/block_based_table_builder.cc @@ -247,7 +247,7 @@ class BlockBasedTableBuilder::BlockBasedTablePropertiesCollector }; struct BlockBasedTableBuilder::Rep { - const ImmutableCFOptions ioptions; + const ImmutableOptions ioptions; const MutableCFOptions moptions; const BlockBasedTableOptions table_options; const InternalKeyComparator& internal_comparator; diff --git a/table/block_based/block_based_table_reader.cc b/table/block_based/block_based_table_reader.cc index 0c70f0fe6..9e8872ec8 100644 --- a/table/block_based/block_based_table_reader.cc +++ b/table/block_based/block_based_table_reader.cc @@ -150,7 +150,7 @@ template Status ReadBlockFromFile( RandomAccessFileReader* file, FilePrefetchBuffer* prefetch_buffer, const Footer& footer, const ReadOptions& options, const BlockHandle& handle, - std::unique_ptr* result, const ImmutableCFOptions& ioptions, + std::unique_ptr* result, const ImmutableOptions& ioptions, bool do_uncompress, bool maybe_compressed, BlockType block_type, const UncompressionDict& uncompression_dict, const PersistentCacheOptions& cache_options, size_t read_amp_bytes_per_bit, @@ -568,7 +568,7 @@ Slice BlockBasedTable::GetCacheKey(const char* cache_key_prefix, } Status BlockBasedTable::Open( - const ReadOptions& read_options, const ImmutableCFOptions& ioptions, + const ReadOptions& read_options, const ImmutableOptions& ioptions, const EnvOptions& env_options, const BlockBasedTableOptions& table_options, const InternalKeyComparator& internal_comparator, std::unique_ptr&& file, uint64_t file_size, @@ -1273,7 +1273,7 @@ Status BlockBasedTable::PutDataBlockToCache( const UncompressionDict& uncompression_dict, MemoryAllocator* memory_allocator, BlockType block_type, GetContext* get_context) const { - const ImmutableCFOptions& ioptions = rep_->ioptions; + const ImmutableOptions& ioptions = rep_->ioptions; const uint32_t format_version = rep_->table_options.format_version; const size_t read_amp_bytes_per_bit = block_type == BlockType::kData @@ -1640,7 +1640,7 @@ void BlockBasedTable::RetrieveMultipleBlocks( char* scratch, const UncompressionDict& uncompression_dict) const { RandomAccessFileReader* file = rep_->file.get(); const Footer& footer = rep_->footer; - const ImmutableCFOptions& ioptions = rep_->ioptions; + const ImmutableOptions& ioptions = rep_->ioptions; size_t read_amp_bytes_per_bit = rep_->table_options.read_amp_bytes_per_bit; MemoryAllocator* memory_allocator = GetMemoryAllocator(rep_->table_options); diff --git a/table/block_based/block_based_table_reader.h b/table/block_based/block_based_table_reader.h index d6fd89e0c..81ffd1cf0 100644 --- a/table/block_based/block_based_table_reader.h +++ b/table/block_based/block_based_table_reader.h @@ -84,7 +84,7 @@ class BlockBasedTable : public TableReader { // are set. // @param force_direct_prefetch if true, always prefetching to RocksDB // buffer, rather than calling RandomAccessFile::Prefetch(). - static Status Open(const ReadOptions& ro, const ImmutableCFOptions& ioptions, + static Status Open(const ReadOptions& ro, const ImmutableOptions& ioptions, const EnvOptions& env_options, const BlockBasedTableOptions& table_options, const InternalKeyComparator& internal_key_comparator, @@ -502,7 +502,7 @@ class BlockBasedTable::PartitionedIndexIteratorState // Stores all the properties associated with a BlockBasedTable. // These are immutable. struct BlockBasedTable::Rep { - Rep(const ImmutableCFOptions& _ioptions, const EnvOptions& _env_options, + Rep(const ImmutableOptions& _ioptions, const EnvOptions& _env_options, const BlockBasedTableOptions& _table_opt, const InternalKeyComparator& _internal_comparator, bool skip_filters, uint64_t _file_size, int _level, const bool _immortal_table) @@ -519,10 +519,9 @@ struct BlockBasedTable::Rep { global_seqno(kDisableGlobalSequenceNumber), file_size(_file_size), level(_level), - immortal_table(_immortal_table) { - } + immortal_table(_immortal_table) {} ~Rep() { status.PermitUncheckedError(); } - const ImmutableCFOptions& ioptions; + const ImmutableOptions& ioptions; const EnvOptions& env_options; const BlockBasedTableOptions table_options; const FilterPolicy* const filter_policy; diff --git a/table/block_based/block_based_table_reader_test.cc b/table/block_based/block_based_table_reader_test.cc index bb39df5f5..f6ea36ab1 100644 --- a/table/block_based/block_based_table_reader_test.cc +++ b/table/block_based/block_based_table_reader_test.cc @@ -59,7 +59,7 @@ class BlockBasedTableReaderTest // Create table builder. Options options; - ImmutableCFOptions ioptions(options); + ImmutableOptions ioptions(options); InternalKeyComparator comparator(options.comparator); ColumnFamilyOptions cf_options; MutableCFOptions moptions(cf_options); @@ -81,7 +81,7 @@ class BlockBasedTableReaderTest } void NewBlockBasedTableReader(const FileOptions& foptions, - const ImmutableCFOptions& ioptions, + const ImmutableOptions& ioptions, const InternalKeyComparator& comparator, const std::string& table_name, std::unique_ptr* table) { @@ -197,7 +197,7 @@ TEST_P(BlockBasedTableReaderTest, MultiGet) { std::unique_ptr table; Options options; - ImmutableCFOptions ioptions(options); + ImmutableOptions ioptions(options); FileOptions foptions; foptions.use_direct_reads = use_direct_reads_; InternalKeyComparator comparator(options.comparator); @@ -275,7 +275,7 @@ TEST_P(BlockBasedTableReaderTestVerifyChecksum, ChecksumMismatch) { std::unique_ptr table; Options options; - ImmutableCFOptions ioptions(options); + ImmutableOptions ioptions(options); FileOptions foptions; foptions.use_direct_reads = use_direct_reads_; InternalKeyComparator comparator(options.comparator); diff --git a/table/block_based/data_block_hash_index_test.cc b/table/block_based/data_block_hash_index_test.cc index 200be925a..def3d4aa7 100644 --- a/table/block_based/data_block_hash_index_test.cc +++ b/table/block_based/data_block_hash_index_test.cc @@ -539,7 +539,7 @@ void TestBoundary(InternalKey& ik1, std::string& v1, InternalKey& ik2, int level_ = -1; std::vector keys; - const ImmutableCFOptions ioptions(options); + const ImmutableOptions ioptions(options); const MutableCFOptions moptions(options); const InternalKeyComparator internal_comparator(options.comparator); diff --git a/table/block_based/hash_index_reader.cc b/table/block_based/hash_index_reader.cc index 7a281edbf..4d8544161 100644 --- a/table/block_based/hash_index_reader.cc +++ b/table/block_based/hash_index_reader.cc @@ -66,7 +66,7 @@ Status HashIndexReader::Create(const BlockBasedTable* table, RandomAccessFileReader* const file = rep->file.get(); const Footer& footer = rep->footer; - const ImmutableCFOptions& ioptions = rep->ioptions; + const ImmutableOptions& ioptions = rep->ioptions; const PersistentCacheOptions& cache_options = rep->persistent_cache_options; MemoryAllocator* const memory_allocator = GetMemoryAllocator(rep->table_options); diff --git a/table/block_based/mock_block_based_table.h b/table/block_based/mock_block_based_table.h index 412717945..e0533a717 100644 --- a/table/block_based/mock_block_based_table.h +++ b/table/block_based/mock_block_based_table.h @@ -23,7 +23,7 @@ class MockBlockBasedTableTester { public: Options options_; - ImmutableCFOptions ioptions_; + ImmutableOptions ioptions_; EnvOptions env_options_; BlockBasedTableOptions table_options_; InternalKeyComparator icomp_; diff --git a/table/block_based/partitioned_filter_block_test.cc b/table/block_based/partitioned_filter_block_test.cc index e06a38da7..7b4d49baf 100644 --- a/table/block_based/partitioned_filter_block_test.cc +++ b/table/block_based/partitioned_filter_block_test.cc @@ -58,7 +58,7 @@ class PartitionedFilterBlockTest virtual public ::testing::WithParamInterface { public: Options options_; - ImmutableCFOptions ioptions_; + ImmutableOptions ioptions_; EnvOptions env_options_; BlockBasedTableOptions table_options_; InternalKeyComparator icomp_; diff --git a/table/block_fetcher.h b/table/block_fetcher.h index 94050401a..e06d964b5 100644 --- a/table/block_fetcher.h +++ b/table/block_fetcher.h @@ -39,7 +39,7 @@ class BlockFetcher { BlockFetcher(RandomAccessFileReader* file, FilePrefetchBuffer* prefetch_buffer, const Footer& footer, const ReadOptions& read_options, const BlockHandle& handle, - BlockContents* contents, const ImmutableCFOptions& ioptions, + BlockContents* contents, const ImmutableOptions& ioptions, bool do_uncompress, bool maybe_compressed, BlockType block_type, const UncompressionDict& uncompression_dict, const PersistentCacheOptions& cache_options, @@ -90,7 +90,7 @@ class BlockFetcher { const ReadOptions read_options_; const BlockHandle& handle_; BlockContents* contents_; - const ImmutableCFOptions& ioptions_; + const ImmutableOptions& ioptions_; const bool do_uncompress_; const bool maybe_compressed_; const BlockType block_type_; diff --git a/table/block_fetcher_test.cc b/table/block_fetcher_test.cc index 963c1b359..fad877eac 100644 --- a/table/block_fetcher_test.cc +++ b/table/block_fetcher_test.cc @@ -93,7 +93,7 @@ class BlockFetcherTest : public testing::Test { NewFileWriter(table_name, &writer); // Create table builder. - ImmutableCFOptions ioptions(options_); + ImmutableOptions ioptions(options_); InternalKeyComparator comparator(options_.comparator); ColumnFamilyOptions cf_options(options_); MutableCFOptions moptions(cf_options); @@ -271,7 +271,7 @@ class BlockFetcherTest : public testing::Test { env_->GetSystemClock().get())); } - void NewTableReader(const ImmutableCFOptions& ioptions, + void NewTableReader(const ImmutableOptions& ioptions, const FileOptions& foptions, const InternalKeyComparator& comparator, const std::string& table_name, @@ -317,7 +317,7 @@ class BlockFetcherTest : public testing::Test { MemoryAllocator* compressed_buf_allocator, BlockContents* contents, MemcpyStats* stats, CompressionType* compresstion_type) { - ImmutableCFOptions ioptions(options_); + ImmutableOptions ioptions(options_); ReadOptions roptions; PersistentCacheOptions persistent_cache_options; Footer footer; @@ -348,7 +348,7 @@ class BlockFetcherTest : public testing::Test { MemoryAllocator* compressed_buf_allocator, BlockContents* block, std::string* result, MemcpyStats* memcpy_stats) { - ImmutableCFOptions ioptions(options_); + ImmutableOptions ioptions(options_); InternalKeyComparator comparator(options_.comparator); FileOptions foptions(options_); diff --git a/table/cuckoo/cuckoo_table_builder_test.cc b/table/cuckoo/cuckoo_table_builder_test.cc index 01f543dca..a86b6fb18 100644 --- a/table/cuckoo/cuckoo_table_builder_test.cc +++ b/table/cuckoo/cuckoo_table_builder_test.cc @@ -64,7 +64,7 @@ class CuckooBuilderTest : public testing::Test { Options options; options.allow_mmap_reads = true; - ImmutableCFOptions ioptions(options); + ImmutableOptions ioptions(options); // Assert Table Properties. TableProperties* props = nullptr; diff --git a/table/cuckoo/cuckoo_table_reader.cc b/table/cuckoo/cuckoo_table_reader.cc index 1345606a5..4045d4528 100644 --- a/table/cuckoo/cuckoo_table_reader.cc +++ b/table/cuckoo/cuckoo_table_reader.cc @@ -15,7 +15,9 @@ #include #include #include + #include "memory/arena.h" +#include "options/cf_options.h" #include "rocksdb/iterator.h" #include "rocksdb/table.h" #include "table/cuckoo/cuckoo_table_factory.h" @@ -33,7 +35,7 @@ const uint32_t kInvalidIndex = std::numeric_limits::max(); extern const uint64_t kCuckooTableMagicNumber; CuckooTableReader::CuckooTableReader( - const ImmutableCFOptions& ioptions, + const ImmutableOptions& ioptions, std::unique_ptr&& file, uint64_t file_size, const Comparator* comparator, uint64_t (*get_slice_hash)(const Slice&, uint32_t, uint64_t)) diff --git a/table/cuckoo/cuckoo_table_reader.h b/table/cuckoo/cuckoo_table_reader.h index 5a7c8b72d..43afd4fd7 100644 --- a/table/cuckoo/cuckoo_table_reader.h +++ b/table/cuckoo/cuckoo_table_reader.h @@ -16,7 +16,6 @@ #include "db/dbformat.h" #include "file/random_access_file_reader.h" -#include "options/cf_options.h" #include "rocksdb/env.h" #include "rocksdb/options.h" #include "table/table_reader.h" @@ -25,10 +24,11 @@ namespace ROCKSDB_NAMESPACE { class Arena; class TableReader; +struct ImmutableOptions; class CuckooTableReader: public TableReader { public: - CuckooTableReader(const ImmutableCFOptions& ioptions, + CuckooTableReader(const ImmutableOptions& ioptions, std::unique_ptr&& file, uint64_t file_size, const Comparator* user_comparator, uint64_t (*get_slice_hash)(const Slice&, uint32_t, diff --git a/table/cuckoo/cuckoo_table_reader_test.cc b/table/cuckoo/cuckoo_table_reader_test.cc index 3c6357c38..1914d26f1 100644 --- a/table/cuckoo/cuckoo_table_reader_test.cc +++ b/table/cuckoo/cuckoo_table_reader_test.cc @@ -109,7 +109,7 @@ class CuckooReaderTest : public testing::Test { std::unique_ptr file_reader; ASSERT_OK(RandomAccessFileReader::Create( env->GetFileSystem(), fname, file_options, &file_reader, nullptr)); - const ImmutableCFOptions ioptions(options); + const ImmutableOptions ioptions(options); CuckooTableReader reader(ioptions, std::move(file_reader), file_size, ucomp, GetSliceHash); ASSERT_OK(reader.status()); @@ -137,7 +137,7 @@ class CuckooReaderTest : public testing::Test { std::unique_ptr file_reader; ASSERT_OK(RandomAccessFileReader::Create( env->GetFileSystem(), fname, file_options, &file_reader, nullptr)); - const ImmutableCFOptions ioptions(options); + const ImmutableOptions ioptions(options); CuckooTableReader reader(ioptions, std::move(file_reader), file_size, ucomp, GetSliceHash); ASSERT_OK(reader.status()); @@ -209,7 +209,7 @@ class CuckooReaderTest : public testing::Test { TEST_F(CuckooReaderTest, FileNotMmaped) { options.allow_mmap_reads = false; - ImmutableCFOptions ioptions(options); + ImmutableOptions ioptions(options); CuckooTableReader reader(ioptions, nullptr, 0, nullptr, nullptr); ASSERT_TRUE(reader.status().IsInvalidArgument()); ASSERT_STREQ("File is not mmaped", reader.status().getState()); @@ -328,7 +328,7 @@ TEST_F(CuckooReaderTest, WhenKeyNotFound) { ASSERT_OK(RandomAccessFileReader::Create( env->GetFileSystem(), fname, file_options, &file_reader, nullptr)); - const ImmutableCFOptions ioptions(options); + const ImmutableOptions ioptions(options); CuckooTableReader reader(ioptions, std::move(file_reader), file_size, ucmp, GetSliceHash); ASSERT_OK(reader.status()); @@ -437,7 +437,7 @@ void WriteFile(const std::vector& keys, ASSERT_OK(RandomAccessFileReader::Create(fs, fname, file_options, &file_reader, nullptr)); - const ImmutableCFOptions ioptions(options); + const ImmutableOptions ioptions(options); CuckooTableReader reader(ioptions, std::move(file_reader), file_size, test::Uint64Comparator(), nullptr); ASSERT_OK(reader.status()); @@ -470,7 +470,7 @@ void ReadKeys(uint64_t num, uint32_t batch_size) { ASSERT_OK(RandomAccessFileReader::Create(fs, fname, file_options, &file_reader, nullptr)); - const ImmutableCFOptions ioptions(options); + const ImmutableOptions ioptions(options); CuckooTableReader reader(ioptions, std::move(file_reader), file_size, test::Uint64Comparator(), nullptr); ASSERT_OK(reader.status()); diff --git a/table/format.cc b/table/format.cc index e2e596e2f..5e0307b59 100644 --- a/table/format.cc +++ b/table/format.cc @@ -347,7 +347,7 @@ Status ReadFooterFromFile(const IOOptions& opts, RandomAccessFileReader* file, Status UncompressBlockContentsForCompressionType( const UncompressionInfo& uncompression_info, const char* data, size_t n, BlockContents* contents, uint32_t format_version, - const ImmutableCFOptions& ioptions, MemoryAllocator* allocator) { + const ImmutableOptions& ioptions, MemoryAllocator* allocator) { Status ret = Status::OK(); assert(uncompression_info.type() != kNoCompression && @@ -396,7 +396,7 @@ Status UncompressBlockContentsForCompressionType( Status UncompressBlockContents(const UncompressionInfo& uncompression_info, const char* data, size_t n, BlockContents* contents, uint32_t format_version, - const ImmutableCFOptions& ioptions, + const ImmutableOptions& ioptions, MemoryAllocator* allocator) { assert(data[n] != kNoCompression); assert(data[n] == static_cast(uncompression_info.type())); diff --git a/table/format.h b/table/format.h index d012502cc..7d7962a4d 100644 --- a/table/format.h +++ b/table/format.h @@ -305,7 +305,7 @@ struct BlockContents { extern Status ReadBlockContents( RandomAccessFileReader* file, FilePrefetchBuffer* prefetch_buffer, const Footer& footer, const ReadOptions& options, const BlockHandle& handle, - BlockContents* contents, const ImmutableCFOptions& ioptions, + BlockContents* contents, const ImmutableOptions& ioptions, bool do_uncompress = true, const Slice& compression_dict = Slice(), const PersistentCacheOptions& cache_options = PersistentCacheOptions()); @@ -320,7 +320,7 @@ extern Status UncompressBlockContents(const UncompressionInfo& info, const char* data, size_t n, BlockContents* contents, uint32_t compress_format_version, - const ImmutableCFOptions& ioptions, + const ImmutableOptions& ioptions, MemoryAllocator* allocator = nullptr); // This is an extension to UncompressBlockContents that accepts @@ -329,7 +329,7 @@ extern Status UncompressBlockContents(const UncompressionInfo& info, extern Status UncompressBlockContentsForCompressionType( const UncompressionInfo& info, const char* data, size_t n, BlockContents* contents, uint32_t compress_format_version, - const ImmutableCFOptions& ioptions, MemoryAllocator* allocator = nullptr); + const ImmutableOptions& ioptions, MemoryAllocator* allocator = nullptr); // Replace db_host_id contents with the real hostname if necessary extern Status ReifyDbHostIdProperty(Env* env, std::string* db_host_id); diff --git a/table/meta_blocks.cc b/table/meta_blocks.cc index 76f5cf31d..c073bee04 100644 --- a/table/meta_blocks.cc +++ b/table/meta_blocks.cc @@ -211,7 +211,7 @@ bool NotifyCollectTableCollectorsOnFinish( Status ReadProperties(const ReadOptions& read_options, const Slice& handle_value, RandomAccessFileReader* file, FilePrefetchBuffer* prefetch_buffer, const Footer& footer, - const ImmutableCFOptions& ioptions, + const ImmutableOptions& ioptions, TableProperties** table_properties, bool verify_checksum, BlockHandle* ret_block_handle, CacheAllocationPtr* verification_buf, @@ -383,7 +383,7 @@ Status ReadProperties(const ReadOptions& read_options, Status ReadTableProperties(RandomAccessFileReader* file, uint64_t file_size, uint64_t table_magic_number, - const ImmutableCFOptions& ioptions, + const ImmutableOptions& ioptions, TableProperties** properties, bool compression_type_missing, MemoryAllocator* memory_allocator, @@ -454,7 +454,7 @@ Status FindMetaBlock(InternalIterator* meta_index_iter, Status FindMetaBlock(RandomAccessFileReader* file, uint64_t file_size, uint64_t table_magic_number, - const ImmutableCFOptions& ioptions, + const ImmutableOptions& ioptions, const std::string& meta_block_name, BlockHandle* block_handle, bool /*compression_type_missing*/, @@ -496,7 +496,7 @@ Status FindMetaBlock(RandomAccessFileReader* file, uint64_t file_size, Status ReadMetaBlock(RandomAccessFileReader* file, FilePrefetchBuffer* prefetch_buffer, uint64_t file_size, uint64_t table_magic_number, - const ImmutableCFOptions& ioptions, + const ImmutableOptions& ioptions, const std::string& meta_block_name, BlockType block_type, BlockContents* contents, bool /*compression_type_missing*/, MemoryAllocator* memory_allocator) { diff --git a/table/meta_blocks.h b/table/meta_blocks.h index aaaa2d5ed..01b56d57c 100644 --- a/table/meta_blocks.h +++ b/table/meta_blocks.h @@ -102,7 +102,7 @@ bool NotifyCollectTableCollectorsOnFinish( Status ReadProperties(const ReadOptions& ro, const Slice& handle_value, RandomAccessFileReader* file, FilePrefetchBuffer* prefetch_buffer, const Footer& footer, - const ImmutableCFOptions& ioptions, + const ImmutableOptions& ioptions, TableProperties** table_properties, bool verify_checksum, BlockHandle* block_handle, CacheAllocationPtr* verification_buf, @@ -119,7 +119,7 @@ Status ReadProperties(const ReadOptions& ro, const Slice& handle_value, // `ReadProperties`, `FindMetaBlock`, and `ReadMetaBlock` Status ReadTableProperties(RandomAccessFileReader* file, uint64_t file_size, uint64_t table_magic_number, - const ImmutableCFOptions& ioptions, + const ImmutableOptions& ioptions, TableProperties** properties, bool compression_type_missing = false, MemoryAllocator* memory_allocator = nullptr, @@ -133,7 +133,7 @@ Status FindMetaBlock(InternalIterator* meta_index_iter, // Find the meta block Status FindMetaBlock(RandomAccessFileReader* file, uint64_t file_size, uint64_t table_magic_number, - const ImmutableCFOptions& ioptions, + const ImmutableOptions& ioptions, const std::string& meta_block_name, BlockHandle* block_handle, bool compression_type_missing = false, @@ -145,7 +145,7 @@ Status FindMetaBlock(RandomAccessFileReader* file, uint64_t file_size, Status ReadMetaBlock(RandomAccessFileReader* file, FilePrefetchBuffer* prefetch_buffer, uint64_t file_size, uint64_t table_magic_number, - const ImmutableCFOptions& ioptions, + const ImmutableOptions& ioptions, const std::string& meta_block_name, BlockType block_type, BlockContents* contents, bool compression_type_missing = false, diff --git a/table/plain/plain_table_builder.cc b/table/plain/plain_table_builder.cc index 951f8e9af..6e1e121a8 100644 --- a/table/plain/plain_table_builder.cc +++ b/table/plain/plain_table_builder.cc @@ -57,7 +57,7 @@ extern const uint64_t kPlainTableMagicNumber = 0x8242229663bf9564ull; extern const uint64_t kLegacyPlainTableMagicNumber = 0x4f3418eb7a8f13b8ull; PlainTableBuilder::PlainTableBuilder( - const ImmutableCFOptions& ioptions, const MutableCFOptions& moptions, + const ImmutableOptions& ioptions, const MutableCFOptions& moptions, const std::vector>* int_tbl_prop_collector_factories, uint32_t column_family_id, WritableFileWriter* file, uint32_t user_key_len, diff --git a/table/plain/plain_table_builder.h b/table/plain/plain_table_builder.h index 6ab5d59e3..88c3a6177 100644 --- a/table/plain/plain_table_builder.h +++ b/table/plain/plain_table_builder.h @@ -37,7 +37,7 @@ class PlainTableBuilder: public TableBuilder { // will be part of level specified by 'level'. A value of -1 means // that the caller does not know which level the output file will reside. PlainTableBuilder( - const ImmutableCFOptions& ioptions, const MutableCFOptions& moptions, + const ImmutableOptions& ioptions, const MutableCFOptions& moptions, const std::vector>* int_tbl_prop_collector_factories, uint32_t column_family_id, WritableFileWriter* file, @@ -96,7 +96,7 @@ class PlainTableBuilder: public TableBuilder { private: Arena arena_; - const ImmutableCFOptions& ioptions_; + const ImmutableOptions& ioptions_; const MutableCFOptions& moptions_; std::vector> table_properties_collectors_; diff --git a/table/plain/plain_table_index.h b/table/plain/plain_table_index.h index 1202a2f56..3ef0705d4 100644 --- a/table/plain/plain_table_index.h +++ b/table/plain/plain_table_index.h @@ -131,7 +131,7 @@ class PlainTableIndex { // The class is used by PlainTableBuilder class. class PlainTableIndexBuilder { public: - PlainTableIndexBuilder(Arena* arena, const ImmutableCFOptions& ioptions, + PlainTableIndexBuilder(Arena* arena, const ImmutableOptions& ioptions, const SliceTransform* prefix_extractor, size_t index_sparseness, double hash_table_ratio, size_t huge_page_tlb_size) @@ -222,7 +222,7 @@ class PlainTableIndexBuilder { const std::vector& entries_per_bucket); Arena* arena_; - const ImmutableCFOptions ioptions_; + const ImmutableOptions ioptions_; HistogramImpl keys_per_prefix_hist_; IndexRecordList record_list_; bool is_first_record_; diff --git a/table/plain/plain_table_reader.cc b/table/plain/plain_table_reader.cc index 178f03598..fbd624268 100644 --- a/table/plain/plain_table_reader.cc +++ b/table/plain/plain_table_reader.cc @@ -93,7 +93,7 @@ class PlainTableIterator : public InternalIterator { extern const uint64_t kPlainTableMagicNumber; PlainTableReader::PlainTableReader( - const ImmutableCFOptions& ioptions, + const ImmutableOptions& ioptions, std::unique_ptr&& file, const EnvOptions& storage_options, const InternalKeyComparator& icomparator, EncodingType encoding_type, uint64_t file_size, @@ -118,7 +118,7 @@ PlainTableReader::~PlainTableReader() { } Status PlainTableReader::Open( - const ImmutableCFOptions& ioptions, const EnvOptions& env_options, + const ImmutableOptions& ioptions, const EnvOptions& env_options, const InternalKeyComparator& internal_comparator, std::unique_ptr&& file, uint64_t file_size, std::unique_ptr* table_reader, const int bloom_bits_per_key, diff --git a/table/plain/plain_table_reader.h b/table/plain/plain_table_reader.h index e3b12a9c3..98bfa59df 100644 --- a/table/plain/plain_table_reader.h +++ b/table/plain/plain_table_reader.h @@ -67,7 +67,7 @@ class PlainTableReader: public TableReader { // whether it points to the data offset of the first key with the key prefix // or the offset of it. If there are too many keys share this prefix, it will // create a binary search-able index from the suffix to offset on disk. - static Status Open(const ImmutableCFOptions& ioptions, + static Status Open(const ImmutableOptions& ioptions, const EnvOptions& env_options, const InternalKeyComparator& internal_comparator, std::unique_ptr&& file, @@ -110,7 +110,7 @@ class PlainTableReader: public TableReader { return arena_.MemoryAllocatedBytes(); } - PlainTableReader(const ImmutableCFOptions& ioptions, + PlainTableReader(const ImmutableOptions& ioptions, std::unique_ptr&& file, const EnvOptions& env_options, const InternalKeyComparator& internal_comparator, @@ -163,7 +163,7 @@ class PlainTableReader: public TableReader { CacheAllocationPtr index_block_alloc_; CacheAllocationPtr bloom_block_alloc_; - const ImmutableCFOptions& ioptions_; + const ImmutableOptions& ioptions_; std::unique_ptr dummy_cleanable_; uint64_t file_size_; protected: // for testing diff --git a/table/sst_file_dumper.cc b/table/sst_file_dumper.cc index 816d76c51..8586934df 100644 --- a/table/sst_file_dumper.cc +++ b/table/sst_file_dumper.cc @@ -145,7 +145,7 @@ Status SstFileDumper::GetTableReader(const std::string& file_path) { } Status SstFileDumper::NewTableReader( - const ImmutableCFOptions& /*ioptions*/, const EnvOptions& /*soptions*/, + const ImmutableOptions& /*ioptions*/, const EnvOptions& /*soptions*/, const InternalKeyComparator& /*internal_comparator*/, uint64_t file_size, std::unique_ptr* /*table_reader*/) { auto t_opt = @@ -264,7 +264,7 @@ Status SstFileDumper::ShowCompressionSize( Options opts; opts.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics(); opts.statistics->set_stats_level(StatsLevel::kAll); - const ImmutableCFOptions imoptions(opts); + const ImmutableOptions imoptions(opts); const ColumnFamilyOptions cfo(opts); const MutableCFOptions moptions(cfo); ROCKSDB_NAMESPACE::InternalKeyComparator ikc(opts.comparator); diff --git a/table/sst_file_dumper.h b/table/sst_file_dumper.h index ab8f5a3e2..32aa7be94 100644 --- a/table/sst_file_dumper.h +++ b/table/sst_file_dumper.h @@ -63,7 +63,7 @@ class SstFileDumper { // Helper function to call the factory with settings specific to the // factory implementation - Status NewTableReader(const ImmutableCFOptions& ioptions, + Status NewTableReader(const ImmutableOptions& ioptions, const EnvOptions& soptions, const InternalKeyComparator& internal_comparator, uint64_t file_size, @@ -85,7 +85,7 @@ class SstFileDumper { std::unique_ptr table_reader_; std::unique_ptr file_; - const ImmutableCFOptions ioptions_; + const ImmutableOptions ioptions_; const MutableCFOptions moptions_; ReadOptions read_options_; InternalKeyComparator internal_comparator_; diff --git a/table/sst_file_reader.cc b/table/sst_file_reader.cc index 3f9344154..e106bca9d 100644 --- a/table/sst_file_reader.cc +++ b/table/sst_file_reader.cc @@ -23,7 +23,7 @@ namespace ROCKSDB_NAMESPACE { struct SstFileReader::Rep { Options options; EnvOptions soptions; - ImmutableCFOptions ioptions; + ImmutableOptions ioptions; MutableCFOptions moptions; std::unique_ptr table_reader; diff --git a/table/sst_file_writer.cc b/table/sst_file_writer.cc index af3ee9f8d..e8c0f06a1 100644 --- a/table/sst_file_writer.cc +++ b/table/sst_file_writer.cc @@ -43,7 +43,7 @@ struct SstFileWriter::Rep { std::unique_ptr file_writer; std::unique_ptr builder; EnvOptions env_options; - ImmutableCFOptions ioptions; + ImmutableOptions ioptions; MutableCFOptions mutable_cf_options; Env::IOPriority io_priority; InternalKeyComparator internal_comparator; diff --git a/table/table_builder.h b/table/table_builder.h index a0854ba08..8735124b7 100644 --- a/table/table_builder.h +++ b/table/table_builder.h @@ -30,7 +30,7 @@ class Status; struct TableReaderOptions { // @param skip_filters Disables loading/accessing the filter block - TableReaderOptions(const ImmutableCFOptions& _ioptions, + TableReaderOptions(const ImmutableOptions& _ioptions, const SliceTransform* _prefix_extractor, const EnvOptions& _env_options, const InternalKeyComparator& _internal_comparator, @@ -45,7 +45,7 @@ struct TableReaderOptions { _max_file_size_for_l0_meta_pin) {} // @param skip_filters Disables loading/accessing the filter block - TableReaderOptions(const ImmutableCFOptions& _ioptions, + TableReaderOptions(const ImmutableOptions& _ioptions, const SliceTransform* _prefix_extractor, const EnvOptions& _env_options, const InternalKeyComparator& _internal_comparator, @@ -66,7 +66,7 @@ struct TableReaderOptions { block_cache_tracer(_block_cache_tracer), max_file_size_for_l0_meta_pin(_max_file_size_for_l0_meta_pin) {} - const ImmutableCFOptions& ioptions; + const ImmutableOptions& ioptions; const SliceTransform* prefix_extractor; const EnvOptions& env_options; const InternalKeyComparator& internal_comparator; @@ -91,7 +91,7 @@ struct TableReaderOptions { struct TableBuilderOptions { TableBuilderOptions( - const ImmutableCFOptions& _ioptions, const MutableCFOptions& _moptions, + const ImmutableOptions& _ioptions, const MutableCFOptions& _moptions, const InternalKeyComparator& _internal_comparator, const std::vector>* _int_tbl_prop_collector_factories, @@ -122,7 +122,7 @@ struct TableBuilderOptions { is_bottommost(_is_bottommost), reason(_reason) {} - const ImmutableCFOptions& ioptions; + const ImmutableOptions& ioptions; const MutableCFOptions& moptions; const InternalKeyComparator& internal_comparator; const std::vector>* diff --git a/table/table_reader_bench.cc b/table/table_reader_bench.cc index 774f2edfc..1d5969148 100644 --- a/table/table_reader_bench.cc +++ b/table/table_reader_bench.cc @@ -86,7 +86,7 @@ void TableReaderBenchmark(Options& opts, EnvOptions& env_options, TableBuilder* tb = nullptr; DB* db = nullptr; Status s; - const ImmutableCFOptions ioptions(opts); + const ImmutableOptions ioptions(opts); const ColumnFamilyOptions cfo(opts); const MutableCFOptions moptions(cfo); std::unique_ptr file_writer; diff --git a/table/table_test.cc b/table/table_test.cc index e0abce8e5..1849e2e53 100644 --- a/table/table_test.cc +++ b/table/table_test.cc @@ -175,7 +175,7 @@ class Constructor { // Finish constructing the data structure with all the keys that have // been added so far. Returns the keys in sorted order in "*keys" // and stores the key/value pairs in "*kvmap" - void Finish(const Options& options, const ImmutableCFOptions& ioptions, + void Finish(const Options& options, const ImmutableOptions& ioptions, const MutableCFOptions& moptions, const BlockBasedTableOptions& table_options, const InternalKeyComparator& internal_comparator, @@ -194,7 +194,7 @@ class Constructor { // Construct the data structure from the data in "data" virtual Status FinishImpl(const Options& options, - const ImmutableCFOptions& ioptions, + const ImmutableOptions& ioptions, const MutableCFOptions& moptions, const BlockBasedTableOptions& table_options, const InternalKeyComparator& internal_comparator, @@ -286,7 +286,7 @@ class BlockConstructor : public Constructor { : Constructor(cmp), comparator_(cmp), block_(nullptr) {} ~BlockConstructor() override { delete block_; } Status FinishImpl(const Options& /*options*/, - const ImmutableCFOptions& /*ioptions*/, + const ImmutableOptions& /*ioptions*/, const MutableCFOptions& /*moptions*/, const BlockBasedTableOptions& table_options, const InternalKeyComparator& /*internal_comparator*/, @@ -341,7 +341,7 @@ class TableConstructor : public Constructor { } ~TableConstructor() override { Reset(); } - Status FinishImpl(const Options& options, const ImmutableCFOptions& ioptions, + Status FinishImpl(const Options& options, const ImmutableOptions& ioptions, const MutableCFOptions& moptions, const BlockBasedTableOptions& /*table_options*/, const InternalKeyComparator& internal_comparator, @@ -427,7 +427,7 @@ class TableConstructor : public Constructor { key, TableReaderCaller::kUncategorized); } - virtual Status Reopen(const ImmutableCFOptions& ioptions, + virtual Status Reopen(const ImmutableOptions& ioptions, const MutableCFOptions& moptions) { std::unique_ptr source(new test::StringSource( TEST_GetSink()->contents(), uniq_id_, ioptions.allow_mmap_reads)); @@ -489,20 +489,20 @@ class MemTableConstructor: public Constructor { write_buffer_manager_(wb), table_factory_(new SkipListFactory) { options_.memtable_factory = table_factory_; - ImmutableCFOptions ioptions(options_); + ImmutableOptions ioptions(options_); memtable_ = new MemTable(internal_comparator_, ioptions, MutableCFOptions(options_), wb, kMaxSequenceNumber, 0 /* column_family_id */); memtable_->Ref(); } ~MemTableConstructor() override { delete memtable_->Unref(); } - Status FinishImpl(const Options&, const ImmutableCFOptions& ioptions, + Status FinishImpl(const Options&, const ImmutableOptions& ioptions, const MutableCFOptions& /*moptions*/, const BlockBasedTableOptions& /*table_options*/, const InternalKeyComparator& /*internal_comparator*/, const stl_wrappers::KVMap& kv_map) override { delete memtable_->Unref(); - ImmutableCFOptions mem_ioptions(ioptions); + ImmutableOptions mem_ioptions(ioptions); memtable_ = new MemTable(internal_comparator_, mem_ioptions, MutableCFOptions(options_), write_buffer_manager_, kMaxSequenceNumber, 0 /* column_family_id */); @@ -565,7 +565,7 @@ class DBConstructor: public Constructor { } ~DBConstructor() override { delete db_; } Status FinishImpl(const Options& /*options*/, - const ImmutableCFOptions& /*ioptions*/, + const ImmutableOptions& /*ioptions*/, const MutableCFOptions& /*moptions*/, const BlockBasedTableOptions& /*table_options*/, const InternalKeyComparator& /*internal_comparator*/, @@ -857,7 +857,7 @@ class HarnessTest : public testing::Test { constructor_.reset(new DBConstructor(options_.comparator)); break; } - ioptions_ = ImmutableCFOptions(options_); + ioptions_ = ImmutableOptions(options_); moptions_ = MutableCFOptions(options_); } @@ -1060,7 +1060,7 @@ class HarnessTest : public testing::Test { private: TestArgs args_; Options options_; - ImmutableCFOptions ioptions_; + ImmutableOptions ioptions_; MutableCFOptions moptions_; BlockBasedTableOptions table_options_; std::unique_ptr constructor_; @@ -1411,7 +1411,7 @@ TEST_P(BlockBasedTableTest, BasicBlockBasedTableProperties) { table_options.block_restart_interval = 1; options.table_factory.reset(NewBlockBasedTableFactory(table_options)); - ImmutableCFOptions ioptions(options); + ImmutableOptions ioptions(options); MutableCFOptions moptions(options); c.Finish(options, ioptions, moptions, table_options, GetPlainInternalComparator(options.comparator), &keys, &kvmap); @@ -1459,7 +1459,7 @@ uint64_t BlockBasedTableTest::IndexUncompressedHelper(bool compressed) { table_options.enable_index_compression = compressed; options.table_factory.reset(NewBlockBasedTableFactory(table_options)); - ImmutableCFOptions ioptions(options); + ImmutableOptions ioptions(options); MutableCFOptions moptions(options); c.Finish(options, ioptions, moptions, table_options, GetPlainInternalComparator(options.comparator), &keys, &kvmap); @@ -1485,7 +1485,7 @@ TEST_P(BlockBasedTableTest, BlockBasedTableProperties2) { BlockBasedTableOptions table_options = GetBlockBasedTableOptions(); options.table_factory.reset(NewBlockBasedTableFactory(table_options)); - const ImmutableCFOptions ioptions(options); + const ImmutableOptions ioptions(options); const MutableCFOptions moptions(options); c.Finish(options, ioptions, moptions, table_options, GetPlainInternalComparator(options.comparator), &keys, &kvmap); @@ -1519,7 +1519,7 @@ TEST_P(BlockBasedTableTest, BlockBasedTableProperties2) { options.table_properties_collector_factories.emplace_back( new DummyPropertiesCollectorFactory2()); - const ImmutableCFOptions ioptions(options); + const ImmutableOptions ioptions(options); const MutableCFOptions moptions(options); c.Finish(options, ioptions, moptions, table_options, GetPlainInternalComparator(options.comparator), &keys, &kvmap); @@ -1563,7 +1563,7 @@ TEST_P(BlockBasedTableTest, RangeDelBlock) { table_options.block_restart_interval = 1; options.table_factory.reset(NewBlockBasedTableFactory(table_options)); - const ImmutableCFOptions ioptions(options); + const ImmutableOptions ioptions(options); const MutableCFOptions moptions(options); std::unique_ptr internal_cmp( new InternalKeyComparator(options.comparator)); @@ -1607,7 +1607,7 @@ TEST_P(BlockBasedTableTest, FilterPolicyNameProperties) { Options options; options.table_factory.reset(NewBlockBasedTableFactory(table_options)); - const ImmutableCFOptions ioptions(options); + const ImmutableOptions ioptions(options); const MutableCFOptions moptions(options); c.Finish(options, ioptions, moptions, table_options, GetPlainInternalComparator(options.comparator), &keys, &kvmap); @@ -1651,7 +1651,7 @@ void PrefetchRange(TableConstructor* c, Options* opt, // reset the cache and reopen the table table_options->block_cache = NewLRUCache(16 * 1024 * 1024, 4); opt->table_factory.reset(NewBlockBasedTableFactory(*table_options)); - const ImmutableCFOptions ioptions2(*opt); + const ImmutableOptions ioptions2(*opt); const MutableCFOptions moptions(*opt); ASSERT_OK(c->Reopen(ioptions2, moptions)); @@ -1709,7 +1709,7 @@ TEST_P(BlockBasedTableTest, PrefetchTest) { c.Add("k07", std::string(100000, 'x')); std::vector keys; stl_wrappers::KVMap kvmap; - const ImmutableCFOptions ioptions(opt); + const ImmutableOptions ioptions(opt); const MutableCFOptions moptions(opt); c.Finish(opt, ioptions, moptions, table_options, *ikc, &keys, &kvmap); c.ResetTableReader(); @@ -1810,7 +1810,7 @@ TEST_P(BlockBasedTableTest, TotalOrderSeekOnHashIndex) { c.Add("cccc2", std::string('a', 56)); std::vector keys; stl_wrappers::KVMap kvmap; - const ImmutableCFOptions ioptions(options); + const ImmutableOptions ioptions(options); const MutableCFOptions moptions(options); c.Finish(options, ioptions, moptions, table_options, GetPlainInternalComparator(options.comparator), &keys, &kvmap); @@ -1869,7 +1869,7 @@ TEST_P(BlockBasedTableTest, NoopTransformSeek) { c.Add(key.Encode().ToString(), "b"); std::vector keys; stl_wrappers::KVMap kvmap; - const ImmutableCFOptions ioptions(options); + const ImmutableOptions ioptions(options); const MutableCFOptions moptions(options); const InternalKeyComparator internal_comparator(options.comparator); c.Finish(options, ioptions, moptions, table_options, internal_comparator, @@ -1907,14 +1907,14 @@ TEST_P(BlockBasedTableTest, SkipPrefixBloomFilter) { c.Add(key.Encode().ToString(), "test"); std::vector keys; stl_wrappers::KVMap kvmap; - const ImmutableCFOptions ioptions(options); + const ImmutableOptions ioptions(options); const MutableCFOptions moptions(options); const InternalKeyComparator internal_comparator(options.comparator); c.Finish(options, ioptions, moptions, table_options, internal_comparator, &keys, &kvmap); // TODO(Zhongyi): update test to use MutableCFOptions options.prefix_extractor.reset(NewFixedPrefixTransform(9)); - const ImmutableCFOptions new_ioptions(options); + const ImmutableOptions new_ioptions(options); const MutableCFOptions new_moptions(options); ASSERT_OK(c.Reopen(new_ioptions, new_moptions)); auto reader = c.GetTableReader(); @@ -1971,7 +1971,7 @@ void TableTest::IndexTest(BlockBasedTableOptions table_options) { std::unique_ptr comparator( new InternalKeyComparator(BytewiseComparator())); - const ImmutableCFOptions ioptions(options); + const ImmutableOptions ioptions(options); const MutableCFOptions moptions(options); c.Finish(options, ioptions, moptions, table_options, *comparator, &keys, &kvmap); @@ -2174,7 +2174,7 @@ TEST_P(BlockBasedTableTest, IndexSeekOptimizationIncomplete) { BlockBasedTableOptions table_options = GetBlockBasedTableOptions(); Options options; options.table_factory.reset(NewBlockBasedTableFactory(table_options)); - const ImmutableCFOptions ioptions(options); + const ImmutableOptions ioptions(options); const MutableCFOptions moptions(options); TableConstructor c(BytewiseComparator()); @@ -2261,7 +2261,7 @@ TEST_P(BlockBasedTableTest, BinaryIndexWithFirstKey2) { Statistics* stats = options.statistics.get(); std::unique_ptr comparator( new InternalKeyComparator(BytewiseComparator())); - const ImmutableCFOptions ioptions(options); + const ImmutableOptions ioptions(options); const MutableCFOptions moptions(options); TableConstructor c(BytewiseComparator()); @@ -2459,7 +2459,7 @@ TEST_P(BlockBasedTableTest, BinaryIndexWithFirstKeyGlobalSeqno) { options.table_factory.reset(NewBlockBasedTableFactory(table_options)); std::unique_ptr comparator( new InternalKeyComparator(BytewiseComparator())); - const ImmutableCFOptions ioptions(options); + const ImmutableOptions ioptions(options); const MutableCFOptions moptions(options); TableConstructor c(BytewiseComparator(), /* convert_to_internal_key */ false, @@ -2534,7 +2534,7 @@ TEST_P(BlockBasedTableTest, IndexSizeStat) { table_options.block_restart_interval = 1; options.table_factory.reset(NewBlockBasedTableFactory(table_options)); - const ImmutableCFOptions ioptions(options); + const ImmutableOptions ioptions(options); const MutableCFOptions moptions(options); c.Finish(options, ioptions, moptions, table_options, GetPlainInternalComparator(options.comparator), &ks, &kvmap); @@ -2563,7 +2563,7 @@ TEST_P(BlockBasedTableTest, NumBlockStat) { std::vector ks; stl_wrappers::KVMap kvmap; - const ImmutableCFOptions ioptions(options); + const ImmutableOptions ioptions(options); const MutableCFOptions moptions(options); c.Finish(options, ioptions, moptions, table_options, GetPlainInternalComparator(options.comparator), &ks, &kvmap); @@ -2584,7 +2584,7 @@ TEST_P(BlockBasedTableTest, TracingGetTest) { SetupTracingTest(&c); std::vector keys; stl_wrappers::KVMap kvmap; - ImmutableCFOptions ioptions(options); + ImmutableOptions ioptions(options); MutableCFOptions moptions(options); c.Finish(options, ioptions, moptions, table_options, GetPlainInternalComparator(options.comparator), &keys, &kvmap); @@ -2658,7 +2658,7 @@ TEST_P(BlockBasedTableTest, TracingApproximateOffsetOfTest) { SetupTracingTest(&c); std::vector keys; stl_wrappers::KVMap kvmap; - ImmutableCFOptions ioptions(options); + ImmutableOptions ioptions(options); MutableCFOptions moptions(options); c.Finish(options, ioptions, moptions, table_options, GetPlainInternalComparator(options.comparator), &keys, &kvmap); @@ -2702,7 +2702,7 @@ TEST_P(BlockBasedTableTest, TracingIterator) { SetupTracingTest(&c); std::vector keys; stl_wrappers::KVMap kvmap; - ImmutableCFOptions ioptions(options); + ImmutableOptions ioptions(options); MutableCFOptions moptions(options); c.Finish(options, ioptions, moptions, table_options, GetPlainInternalComparator(options.comparator), &keys, &kvmap); @@ -2832,7 +2832,7 @@ TEST_P(BlockBasedTableTest, BlockCacheDisabledTest) { TableConstructor c(BytewiseComparator(), true /* convert_to_internal_key_ */); c.Add("key", "value"); - const ImmutableCFOptions ioptions(options); + const ImmutableOptions ioptions(options); const MutableCFOptions moptions(options); c.Finish(options, ioptions, moptions, table_options, GetPlainInternalComparator(options.comparator), &keys, &kvmap); @@ -2884,7 +2884,7 @@ TEST_P(BlockBasedTableTest, FilterBlockInBlockCache) { TableConstructor c(BytewiseComparator(), true /* convert_to_internal_key_ */); c.Add("key", "value"); - const ImmutableCFOptions ioptions(options); + const ImmutableOptions ioptions(options); const MutableCFOptions moptions(options); c.Finish(options, ioptions, moptions, table_options, GetPlainInternalComparator(options.comparator), &keys, &kvmap); @@ -2964,7 +2964,7 @@ TEST_P(BlockBasedTableTest, FilterBlockInBlockCache) { table_options.block_cache = NewLRUCache(1, 4); options.statistics = CreateDBStatistics(); options.table_factory.reset(new BlockBasedTableFactory(table_options)); - const ImmutableCFOptions ioptions2(options); + const ImmutableOptions ioptions2(options); const MutableCFOptions moptions2(options); ASSERT_OK(c.Reopen(ioptions2, moptions2)); { @@ -3011,7 +3011,7 @@ TEST_P(BlockBasedTableTest, FilterBlockInBlockCache) { std::string user_key = "k01"; InternalKey internal_key(user_key, 0, kTypeValue); c3.Add(internal_key.Encode().ToString(), "hello"); - ImmutableCFOptions ioptions3(options); + ImmutableOptions ioptions3(options); MutableCFOptions moptions3(options); // Generate table without filter policy c3.Finish(options, ioptions3, moptions3, table_options, @@ -3022,7 +3022,7 @@ TEST_P(BlockBasedTableTest, FilterBlockInBlockCache) { table_options.filter_policy.reset(NewBloomFilterPolicy(1)); options.table_factory.reset(new BlockBasedTableFactory(table_options)); options.statistics = CreateDBStatistics(); - ImmutableCFOptions ioptions4(options); + ImmutableOptions ioptions4(options); MutableCFOptions moptions4(options); ASSERT_OK(c3.Reopen(ioptions4, moptions4)); reader = dynamic_cast(c3.GetTableReader()); @@ -3106,7 +3106,7 @@ TEST_P(BlockBasedTableTest, BlockReadCountTest) { InternalKey internal_key(user_key, 0, kTypeValue); std::string encoded_key = internal_key.Encode().ToString(); c.Add(encoded_key, "hello"); - ImmutableCFOptions ioptions(options); + ImmutableOptions ioptions(options); MutableCFOptions moptions(options); // Generate table with filter policy c.Finish(options, ioptions, moptions, table_options, @@ -3194,7 +3194,7 @@ TEST_P(BlockBasedTableTest, BlockCacheLeak) { c.Add("k07", std::string(100000, 'x')); std::vector keys; stl_wrappers::KVMap kvmap; - const ImmutableCFOptions ioptions(opt); + const ImmutableOptions ioptions(opt); const MutableCFOptions moptions(opt); c.Finish(opt, ioptions, moptions, table_options, *ikc, &keys, &kvmap); @@ -3209,7 +3209,7 @@ TEST_P(BlockBasedTableTest, BlockCacheLeak) { ASSERT_OK(iter->status()); iter.reset(); - const ImmutableCFOptions ioptions1(opt); + const ImmutableOptions ioptions1(opt); const MutableCFOptions moptions1(opt); ASSERT_OK(c.Reopen(ioptions1, moptions1)); auto table_reader = dynamic_cast(c.GetTableReader()); @@ -3222,7 +3222,7 @@ TEST_P(BlockBasedTableTest, BlockCacheLeak) { // rerun with different block cache table_options.block_cache = NewLRUCache(16 * 1024 * 1024, 4); opt.table_factory.reset(NewBlockBasedTableFactory(table_options)); - const ImmutableCFOptions ioptions2(opt); + const ImmutableOptions ioptions2(opt); const MutableCFOptions moptions2(opt); ASSERT_OK(c.Reopen(ioptions2, moptions2)); table_reader = dynamic_cast(c.GetTableReader()); @@ -3282,7 +3282,7 @@ TEST_P(BlockBasedTableTest, MemoryAllocator) { c.Add("k07", std::string(100000, 'x')); std::vector keys; stl_wrappers::KVMap kvmap; - const ImmutableCFOptions ioptions(opt); + const ImmutableOptions ioptions(opt); const MutableCFOptions moptions(opt); c.Finish(opt, ioptions, moptions, table_options, *ikc, &keys, &kvmap); @@ -3308,7 +3308,7 @@ TEST_P(BlockBasedTableTest, MemoryAllocator) { // Test the file checksum of block based table TEST_P(BlockBasedTableTest, NoFileChecksum) { Options options; - ImmutableCFOptions ioptions(options); + ImmutableOptions ioptions(options); MutableCFOptions moptions(options); BlockBasedTableOptions table_options = GetBlockBasedTableOptions(); std::unique_ptr comparator( @@ -3339,7 +3339,7 @@ TEST_P(BlockBasedTableTest, Crc32cFileChecksum) { new FileChecksumGenCrc32cFactory(); Options options; options.file_checksum_gen_factory.reset(file_checksum_gen_factory); - ImmutableCFOptions ioptions(options); + ImmutableOptions ioptions(options); MutableCFOptions moptions(options); BlockBasedTableOptions table_options = GetBlockBasedTableOptions(); std::unique_ptr comparator( @@ -3400,7 +3400,7 @@ TEST_F(PlainTableTest, BasicPlainTableProperties) { std::unique_ptr file_writer(new WritableFileWriter( std::move(sink), "" /* don't care */, FileOptions())); Options options; - const ImmutableCFOptions ioptions(options); + const ImmutableOptions ioptions(options); const MutableCFOptions moptions(options); InternalKeyComparator ikc(options.comparator); std::vector> @@ -3453,7 +3453,7 @@ TEST_F(PlainTableTest, NoFileChecksum) { PlainTableFactory factory(plain_table_options); Options options; - const ImmutableCFOptions ioptions(options); + const ImmutableOptions ioptions(options); const MutableCFOptions moptions(options); InternalKeyComparator ikc(options.comparator); std::vector> @@ -3487,7 +3487,7 @@ TEST_F(PlainTableTest, Crc32cFileChecksum) { new FileChecksumGenCrc32cFactory(); Options options; options.file_checksum_gen_factory.reset(file_checksum_gen_factory); - const ImmutableCFOptions ioptions(options); + const ImmutableOptions ioptions(options); const MutableCFOptions moptions(options); InternalKeyComparator ikc(options.comparator); std::vector> @@ -3542,7 +3542,7 @@ TEST_F(GeneralTableTest, ApproximateOffsetOfPlain) { options.compression = kNoCompression; BlockBasedTableOptions table_options; table_options.block_size = 1024; - const ImmutableCFOptions ioptions(options); + const ImmutableOptions ioptions(options); const MutableCFOptions moptions(options); c.Finish(options, ioptions, moptions, table_options, internal_comparator, &keys, &kvmap); @@ -3578,7 +3578,7 @@ static void DoCompressionTest(CompressionType comp) { options.compression = comp; BlockBasedTableOptions table_options; table_options.block_size = 1024; - const ImmutableCFOptions ioptions(options); + const ImmutableOptions ioptions(options); const MutableCFOptions moptions(options); c.Finish(options, ioptions, moptions, table_options, ikc, &keys, &kvmap); @@ -3676,7 +3676,7 @@ class MemTableTest : public testing::Test { InternalKeyComparator cmp(BytewiseComparator()); auto table_factory = std::make_shared(); options_.memtable_factory = table_factory; - ImmutableCFOptions ioptions(options_); + ImmutableOptions ioptions(options_); wb_ = new WriteBufferManager(options_.db_write_buffer_size); memtable_ = new MemTable(cmp, ioptions, MutableCFOptions(options_), wb_, kMaxSequenceNumber, 0 /* column_family_id */); @@ -3930,7 +3930,7 @@ TEST_P(IndexBlockRestartIntervalTest, IndexBlockRestartInterval) { stl_wrappers::KVMap kvmap; std::unique_ptr comparator( new InternalKeyComparator(BytewiseComparator())); - const ImmutableCFOptions ioptions(options); + const ImmutableOptions ioptions(options); const MutableCFOptions moptions(options); c.Finish(options, ioptions, moptions, table_options, *comparator, &keys, &kvmap); @@ -4060,7 +4060,7 @@ TEST_P(BlockBasedTableTest, DISABLED_TableWithGlobalSeqno) { std::move(holder), "" /* don't care */, FileOptions())); Options options; options.table_factory.reset(NewBlockBasedTableFactory(bbto)); - const ImmutableCFOptions ioptions(options); + const ImmutableOptions ioptions(options); const MutableCFOptions moptions(options); InternalKeyComparator ikc(options.comparator); std::vector> @@ -4248,7 +4248,7 @@ TEST_P(BlockBasedTableTest, BlockAlignTest) { Options options; options.compression = kNoCompression; options.table_factory.reset(NewBlockBasedTableFactory(bbto)); - const ImmutableCFOptions ioptions(options); + const ImmutableOptions ioptions(options); const MutableCFOptions moptions(options); InternalKeyComparator ikc(options.comparator); std::vector> @@ -4299,7 +4299,7 @@ TEST_P(BlockBasedTableTest, BlockAlignTest) { bbto.block_align = false; Options options2; options2.table_factory.reset(NewBlockBasedTableFactory(bbto)); - ImmutableCFOptions ioptions2(options2); + ImmutableOptions ioptions2(options2); const MutableCFOptions moptions2(options2); ASSERT_OK(ioptions.table_factory->NewTableReader( @@ -4341,7 +4341,7 @@ TEST_P(BlockBasedTableTest, PropertiesBlockRestartPointTest) { options.compression = kNoCompression; options.table_factory.reset(NewBlockBasedTableFactory(bbto)); - const ImmutableCFOptions ioptions(options); + const ImmutableOptions ioptions(options); const MutableCFOptions moptions(options); InternalKeyComparator ikc(options.comparator); std::vector> @@ -4448,7 +4448,7 @@ TEST_P(BlockBasedTableTest, PropertiesMetaBlockLast) { table_options.filter_policy.reset(NewBloomFilterPolicy( 8 /* bits_per_key */, false /* use_block_based_filter */)); options.table_factory.reset(NewBlockBasedTableFactory(table_options)); - ImmutableCFOptions ioptions(options); + ImmutableOptions ioptions(options); MutableCFOptions moptions(options); std::vector keys; stl_wrappers::KVMap kvmap; @@ -4597,7 +4597,7 @@ TEST_P(BlockBasedTableTest, DataBlockHashIndex) { std::vector keys; stl_wrappers::KVMap kvmap; - const ImmutableCFOptions ioptions(options); + const ImmutableOptions ioptions(options); const MutableCFOptions moptions(options); const InternalKeyComparator internal_comparator(options.comparator); c.Finish(options, ioptions, moptions, table_options, internal_comparator, @@ -4680,7 +4680,7 @@ TEST_P(BlockBasedTableTest, OutOfBoundOnSeek) { Options options; BlockBasedTableOptions table_opt(GetBlockBasedTableOptions()); options.table_factory.reset(NewBlockBasedTableFactory(table_opt)); - const ImmutableCFOptions ioptions(options); + const ImmutableOptions ioptions(options); const MutableCFOptions moptions(options); c.Finish(options, ioptions, moptions, table_opt, GetPlainInternalComparator(BytewiseComparator()), &keys, &kvmap); @@ -4720,7 +4720,7 @@ TEST_P(BlockBasedTableTest, OutOfBoundOnNext) { table_opt.flush_block_policy_factory = std::make_shared(); options.table_factory.reset(NewBlockBasedTableFactory(table_opt)); - const ImmutableCFOptions ioptions(options); + const ImmutableOptions ioptions(options); const MutableCFOptions moptions(options); c.Finish(options, ioptions, moptions, table_opt, GetPlainInternalComparator(BytewiseComparator()), &keys, &kvmap); diff --git a/tools/sst_dump_test.cc b/tools/sst_dump_test.cc index dd397a701..25f26c450 100644 --- a/tools/sst_dump_test.cc +++ b/tools/sst_dump_test.cc @@ -96,7 +96,7 @@ class SSTDumpToolTest : public testing::Test { Env* test_env = opts.env; FileOptions file_options(opts); ReadOptions read_options; - const ImmutableCFOptions imoptions(opts); + const ImmutableOptions imoptions(opts); const MutableCFOptions moptions(opts); ROCKSDB_NAMESPACE::InternalKeyComparator ikc(opts.comparator); std::unique_ptr tb; diff --git a/utilities/blob_db/blob_dump_tool.cc b/utilities/blob_db/blob_dump_tool.cc index 7fb3d6b3b..d6b8930ff 100644 --- a/utilities/blob_db/blob_dump_tool.cc +++ b/utilities/blob_db/blob_dump_tool.cc @@ -215,8 +215,7 @@ Status BlobDumpTool::DumpRecord(DisplayType show_key, DisplayType show_blob, compression); s = UncompressBlockContentsForCompressionType( info, slice.data() + key_size, static_cast(value_size), - &contents, 2 /*compress_format_version*/, - ImmutableCFOptions(Options())); + &contents, 2 /*compress_format_version*/, ImmutableOptions(Options())); if (!s.ok()) { return s; }