andreacavalli/rocksdb
0
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Rename ImmutableOptions variables (#8409)

Browse Source 
Summary:
This is the next part of the ImmutableOptions cleanup.  After changing the use of ImmutableCFOptions to ImmutableOptions, there were places in the code that had did something like "ImmutableOptions* immutable_cf_options", where "cf" referred to the "old" type.

This change simply renames the variables to match the current type.  No new functionality is introduced.

Pull Request resolved: https://github.com/facebook/rocksdb/pull/8409

Reviewed By: pdillinger

Differential Revision: D29166248

Pulled By: mrambacher

fbshipit-source-id: 96de97f8e743f5c5160f02246e3ed8269556dc6f
This commit is contained in:
mrambacher 2021-06-16 16:50:43 -07:00 committed by Facebook GitHub Bot
parent 25be1ed66a
commit d5bd0039b9
21 changed files with 300 additions and 313 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
db/arena_wrapped_db_iter.cc
View File

@ -31,16 +31,15 @@ Status ArenaWrappedDBIter::GetProperty(std::string prop_name,
} }
void ArenaWrappedDBIter::Init( void ArenaWrappedDBIter::Init(
Env* env, const ReadOptions& read_options, Env* env, const ReadOptions& read_options, const ImmutableOptions& ioptions,
const ImmutableOptions& cf_options,
const MutableCFOptions& mutable_cf_options, const Version* version, const MutableCFOptions& mutable_cf_options, const Version* version,
const SequenceNumber& sequence, uint64_t max_sequential_skip_in_iteration, const SequenceNumber& sequence, uint64_t max_sequential_skip_in_iteration,
uint64_t version_number, ReadCallback* read_callback, DBImpl* db_impl, uint64_t version_number, ReadCallback* read_callback, DBImpl* db_impl,
ColumnFamilyData* cfd, bool expose_blob_index, bool allow_refresh) { ColumnFamilyData* cfd, bool expose_blob_index, bool allow_refresh) {
auto mem = arena_.AllocateAligned(sizeof(DBIter)); auto mem = arena_.AllocateAligned(sizeof(DBIter));
db_iter_ = db_iter_ =
new (mem) DBIter(env, read_options, cf_options, mutable_cf_options, new (mem) DBIter(env, read_options, ioptions, mutable_cf_options,
cf_options.user_comparator, /* iter */ nullptr, version, ioptions.user_comparator, /* iter */ nullptr, version,
sequence, true, max_sequential_skip_in_iteration, sequence, true, max_sequential_skip_in_iteration,
read_callback, db_impl, cfd, expose_blob_index); read_callback, db_impl, cfd, expose_blob_index);
sv_number_ = version_number; sv_number_ = version_number;
@ -88,16 +87,15 @@ Status ArenaWrappedDBIter::Refresh() {
} }
ArenaWrappedDBIter* NewArenaWrappedDbIterator( ArenaWrappedDBIter* NewArenaWrappedDbIterator(
Env* env, const ReadOptions& read_options, Env* env, const ReadOptions& read_options, const ImmutableOptions& ioptions,
const ImmutableOptions& cf_options,
const MutableCFOptions& mutable_cf_options, const Version* version, const MutableCFOptions& mutable_cf_options, const Version* version,
const SequenceNumber& sequence, uint64_t max_sequential_skip_in_iterations, const SequenceNumber& sequence, uint64_t max_sequential_skip_in_iterations,
uint64_t version_number, ReadCallback* read_callback, DBImpl* db_impl, uint64_t version_number, ReadCallback* read_callback, DBImpl* db_impl,
ColumnFamilyData* cfd, bool expose_blob_index, bool allow_refresh) { ColumnFamilyData* cfd, bool expose_blob_index, bool allow_refresh) {
ArenaWrappedDBIter* iter = new ArenaWrappedDBIter(); ArenaWrappedDBIter* iter = new ArenaWrappedDBIter();
iter->Init(env, read_options, cf_options, mutable_cf_options, version, iter->Init(env, read_options, ioptions, mutable_cf_options, version, sequence,
sequence, max_sequential_skip_in_iterations, version_number, max_sequential_skip_in_iterations, version_number, read_callback,
read_callback, db_impl, cfd, expose_blob_index, allow_refresh); db_impl, cfd, expose_blob_index, allow_refresh);
if (db_impl != nullptr && cfd != nullptr && allow_refresh) { if (db_impl != nullptr && cfd != nullptr && allow_refresh) {
iter->StoreRefreshInfo(db_impl, cfd, read_callback, expose_blob_index); iter->StoreRefreshInfo(db_impl, cfd, read_callback, expose_blob_index);
} }

5
db/arena_wrapped_db_iter.h
View File

@ -72,7 +72,7 @@ class ArenaWrappedDBIter : public Iterator {
Status Refresh() override; Status Refresh() override;
void Init(Env* env, const ReadOptions& read_options, void Init(Env* env, const ReadOptions& read_options,
const ImmutableOptions& cf_options, const ImmutableOptions& ioptions,
const MutableCFOptions& mutable_cf_options, const Version* version, const MutableCFOptions& mutable_cf_options, const Version* version,
const SequenceNumber& sequence, const SequenceNumber& sequence,
uint64_t max_sequential_skip_in_iterations, uint64_t version_number, uint64_t max_sequential_skip_in_iterations, uint64_t version_number,
@ -105,8 +105,7 @@ class ArenaWrappedDBIter : public Iterator {
// `db_impl` and `cfd` are used for reneweal. If left null, renewal will not // `db_impl` and `cfd` are used for reneweal. If left null, renewal will not
// be supported. // be supported.
extern ArenaWrappedDBIter* NewArenaWrappedDbIterator( extern ArenaWrappedDBIter* NewArenaWrappedDbIterator(
Env* env, const ReadOptions& read_options, Env* env, const ReadOptions& read_options, const ImmutableOptions& ioptions,
const ImmutableOptions& cf_options,
const MutableCFOptions& mutable_cf_options, const Version* version, const MutableCFOptions& mutable_cf_options, const Version* version,
const SequenceNumber& sequence, uint64_t max_sequential_skip_in_iterations, const SequenceNumber& sequence, uint64_t max_sequential_skip_in_iterations,
uint64_t version_number, ReadCallback* read_callback, uint64_t version_number, ReadCallback* read_callback,

36
db/blob/blob_file_builder.cc
View File

@ -29,7 +29,7 @@ namespace ROCKSDB_NAMESPACE {
BlobFileBuilder::BlobFileBuilder( BlobFileBuilder::BlobFileBuilder(
VersionSet* versions, FileSystem* fs, VersionSet* versions, FileSystem* fs,
const ImmutableOptions* immutable_cf_options, const ImmutableOptions* immutable_options,
const MutableCFOptions* mutable_cf_options, const FileOptions* file_options, const MutableCFOptions* mutable_cf_options, const FileOptions* file_options,
int job_id, uint32_t column_family_id, int job_id, uint32_t column_family_id,
const std::string& column_family_name, Env::IOPriority io_priority, const std::string& column_family_name, Env::IOPriority io_priority,
@ -39,14 +39,14 @@ BlobFileBuilder::BlobFileBuilder(
std::vector<std::string>* blob_file_paths, std::vector<std::string>* blob_file_paths,
std::vector<BlobFileAddition>* blob_file_additions) std::vector<BlobFileAddition>* blob_file_additions)
: BlobFileBuilder([versions]() { return versions->NewFileNumber(); }, fs, : BlobFileBuilder([versions]() { return versions->NewFileNumber(); }, fs,
immutable_cf_options, mutable_cf_options, file_options, immutable_options, mutable_cf_options, file_options,
job_id, column_family_id, column_family_name, io_priority, job_id, column_family_id, column_family_name, io_priority,
write_hint, io_tracer, blob_callback, blob_file_paths, write_hint, io_tracer, blob_callback, blob_file_paths,
blob_file_additions) {} blob_file_additions) {}
BlobFileBuilder::BlobFileBuilder( BlobFileBuilder::BlobFileBuilder(
std::function<uint64_t()> file_number_generator, FileSystem* fs, std::function<uint64_t()> file_number_generator, FileSystem* fs,
const ImmutableOptions* immutable_cf_options, const ImmutableOptions* immutable_options,
const MutableCFOptions* mutable_cf_options, const FileOptions* file_options, const MutableCFOptions* mutable_cf_options, const FileOptions* file_options,
int job_id, uint32_t column_family_id, int job_id, uint32_t column_family_id,
const std::string& column_family_name, Env::IOPriority io_priority, const std::string& column_family_name, Env::IOPriority io_priority,
@ -57,7 +57,7 @@ BlobFileBuilder::BlobFileBuilder(
std::vector<BlobFileAddition>* blob_file_additions) std::vector<BlobFileAddition>* blob_file_additions)
: file_number_generator_(std::move(file_number_generator)), : file_number_generator_(std::move(file_number_generator)),
fs_(fs), fs_(fs),
immutable_cf_options_(immutable_cf_options), immutable_options_(immutable_options),
min_blob_size_(mutable_cf_options->min_blob_size), min_blob_size_(mutable_cf_options->min_blob_size),
blob_file_size_(mutable_cf_options->blob_file_size), blob_file_size_(mutable_cf_options->blob_file_size),
blob_compression_type_(mutable_cf_options->blob_compression_type), blob_compression_type_(mutable_cf_options->blob_compression_type),
@ -75,7 +75,7 @@ BlobFileBuilder::BlobFileBuilder(
blob_bytes_(0) { blob_bytes_(0) {
assert(file_number_generator_); assert(file_number_generator_);
assert(fs_); assert(fs_);
assert(immutable_cf_options_); assert(immutable_options_);
assert(file_options_); assert(file_options_);
assert(blob_file_paths_); assert(blob_file_paths_);
assert(blob_file_paths_->empty()); assert(blob_file_paths_->empty());
@ -156,10 +156,10 @@ Status BlobFileBuilder::OpenBlobFileIfNeeded() {
assert(file_number_generator_); assert(file_number_generator_);
const uint64_t blob_file_number = file_number_generator_(); const uint64_t blob_file_number = file_number_generator_();
assert(immutable_cf_options_); assert(immutable_options_);
assert(!immutable_cf_options_->cf_paths.empty()); assert(!immutable_options_->cf_paths.empty());
std::string blob_file_path = BlobFileName( std::string blob_file_path =
immutable_cf_options_->cf_paths.front().path, blob_file_number); BlobFileName(immutable_options_->cf_paths.front().path, blob_file_number);
std::unique_ptr<FSWritableFile> file; std::unique_ptr<FSWritableFile> file;
@ -184,20 +184,20 @@ Status BlobFileBuilder::OpenBlobFileIfNeeded() {
assert(file); assert(file);
file->SetIOPriority(io_priority_); file->SetIOPriority(io_priority_);
file->SetWriteLifeTimeHint(write_hint_); file->SetWriteLifeTimeHint(write_hint_);
FileTypeSet tmp_set = immutable_cf_options_->checksum_handoff_file_types; FileTypeSet tmp_set = immutable_options_->checksum_handoff_file_types;
Statistics* const statistics = immutable_cf_options_->stats; Statistics* const statistics = immutable_options_->stats;
std::unique_ptr<WritableFileWriter> file_writer(new WritableFileWriter( std::unique_ptr<WritableFileWriter> file_writer(new WritableFileWriter(
std::move(file), blob_file_paths_->back(), *file_options_, std::move(file), blob_file_paths_->back(), *file_options_,
immutable_cf_options_->clock, io_tracer_, statistics, immutable_options_->clock, io_tracer_, statistics,
immutable_cf_options_->listeners, immutable_options_->listeners,
immutable_cf_options_->file_checksum_gen_factory.get(), immutable_options_->file_checksum_gen_factory.get(),
tmp_set.Contains(FileType::kBlobFile))); tmp_set.Contains(FileType::kBlobFile)));
constexpr bool do_flush = false; constexpr bool do_flush = false;
std::unique_ptr<BlobLogWriter> blob_log_writer(new BlobLogWriter( std::unique_ptr<BlobLogWriter> blob_log_writer(new BlobLogWriter(
std::move(file_writer), immutable_cf_options_->clock, statistics, std::move(file_writer), immutable_options_->clock, statistics,
blob_file_number, immutable_cf_options_->use_fsync, do_flush)); blob_file_number, immutable_options_->use_fsync, do_flush));
constexpr bool has_ttl = false; constexpr bool has_ttl = false;
constexpr ExpirationRange expiration_range; constexpr ExpirationRange expiration_range;
@ -300,8 +300,8 @@ Status BlobFileBuilder::CloseBlobFile() {
std::move(checksum_method), std::move(checksum_method),
std::move(checksum_value)); std::move(checksum_value));
assert(immutable_cf_options_); assert(immutable_options_);
ROCKS_LOG_INFO(immutable_cf_options_->logger, ROCKS_LOG_INFO(immutable_options_->logger,
"[%s] [JOB %d] Generated blob file #%" PRIu64 ": %" PRIu64 "[%s] [JOB %d] Generated blob file #%" PRIu64 ": %" PRIu64
" total blobs, %" PRIu64 " total bytes", " total blobs, %" PRIu64 " total bytes",
column_family_name_.c_str(), job_id_, blob_file_number, column_family_name_.c_str(), job_id_, blob_file_number,

2
db/blob/blob_file_builder.h
View File

@ -77,7 +77,7 @@ class BlobFileBuilder {
std::function<uint64_t()> file_number_generator_; std::function<uint64_t()> file_number_generator_;
FileSystem* fs_; FileSystem* fs_;
const ImmutableOptions* immutable_cf_options_; const ImmutableOptions* immutable_options_;
uint64_t min_blob_size_; uint64_t min_blob_size_;
uint64_t blob_file_size_; uint64_t blob_file_size_;
CompressionType blob_compression_type_; CompressionType blob_compression_type_;

119
db/blob/blob_file_builder_test.cc
View File

@ -129,7 +129,7 @@ TEST_F(BlobFileBuilderTest, BuildAndCheckOneFile) {
options.enable_blob_files = true; options.enable_blob_files = true;
options.env = &mock_env_; options.env = &mock_env_;
ImmutableOptions immutable_cf_options(options); ImmutableOptions immutable_options(options);
MutableCFOptions mutable_cf_options(options); MutableCFOptions mutable_cf_options(options);
constexpr int job_id = 1; constexpr int job_id = 1;
@ -141,12 +141,11 @@ TEST_F(BlobFileBuilderTest, BuildAndCheckOneFile) {
std::vector<std::string> blob_file_paths; std::vector<std::string> blob_file_paths;
std::vector<BlobFileAddition> blob_file_additions; std::vector<BlobFileAddition> blob_file_additions;
BlobFileBuilder builder(TestFileNumberGenerator(), fs_, &immutable_cf_options, BlobFileBuilder builder(
&mutable_cf_options, &file_options_, job_id, TestFileNumberGenerator(), fs_, &immutable_options, &mutable_cf_options,
column_family_id, column_family_name, io_priority, &file_options_, job_id, column_family_id, column_family_name, io_priority,
write_hint, nullptr /*IOTracer*/, write_hint, nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/,
nullptr /*BlobFileCompletionCallback*/, &blob_file_paths, &blob_file_additions);
&blob_file_paths, &blob_file_additions);
std::vector<std::pair<std::string, std::string>> expected_key_value_pairs( std::vector<std::pair<std::string, std::string>> expected_key_value_pairs(
number_of_blobs); number_of_blobs);
@ -178,9 +177,9 @@ TEST_F(BlobFileBuilderTest, BuildAndCheckOneFile) {
const std::string& blob_file_path = blob_file_paths[0]; const std::string& blob_file_path = blob_file_paths[0];
ASSERT_EQ(blob_file_path, ASSERT_EQ(
BlobFileName(immutable_cf_options.cf_paths.front().path, blob_file_path,
blob_file_number)); BlobFileName(immutable_options.cf_paths.front().path, blob_file_number));
ASSERT_EQ(blob_file_additions.size(), 1); ASSERT_EQ(blob_file_additions.size(), 1);
@ -214,7 +213,7 @@ TEST_F(BlobFileBuilderTest, BuildAndCheckMultipleFiles) {
options.blob_file_size = value_size; options.blob_file_size = value_size;
options.env = &mock_env_; options.env = &mock_env_;
ImmutableOptions immutable_cf_options(options); ImmutableOptions immutable_options(options);
MutableCFOptions mutable_cf_options(options); MutableCFOptions mutable_cf_options(options);
constexpr int job_id = 1; constexpr int job_id = 1;
@ -226,12 +225,11 @@ TEST_F(BlobFileBuilderTest, BuildAndCheckMultipleFiles) {
std::vector<std::string> blob_file_paths; std::vector<std::string> blob_file_paths;
std::vector<BlobFileAddition> blob_file_additions; std::vector<BlobFileAddition> blob_file_additions;
BlobFileBuilder builder(TestFileNumberGenerator(), fs_, &immutable_cf_options, BlobFileBuilder builder(
&mutable_cf_options, &file_options_, job_id, TestFileNumberGenerator(), fs_, &immutable_options, &mutable_cf_options,
column_family_id, column_family_name, io_priority, &file_options_, job_id, column_family_id, column_family_name, io_priority,
write_hint, nullptr /*IOTracer*/, write_hint, nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/,
nullptr /*BlobFileCompletionCallback*/, &blob_file_paths, &blob_file_additions);
&blob_file_paths, &blob_file_additions);
std::vector<std::pair<std::string, std::string>> expected_key_value_pairs( std::vector<std::pair<std::string, std::string>> expected_key_value_pairs(
number_of_blobs); number_of_blobs);
@ -264,7 +262,7 @@ TEST_F(BlobFileBuilderTest, BuildAndCheckMultipleFiles) {
const uint64_t blob_file_number = i + 2; const uint64_t blob_file_number = i + 2;
ASSERT_EQ(blob_file_paths[i], ASSERT_EQ(blob_file_paths[i],
BlobFileName(immutable_cf_options.cf_paths.front().path, BlobFileName(immutable_options.cf_paths.front().path,
blob_file_number)); blob_file_number));
const auto& blob_file_addition = blob_file_additions[i]; const auto& blob_file_addition = blob_file_additions[i];
@ -301,7 +299,7 @@ TEST_F(BlobFileBuilderTest, InlinedValues) {
options.min_blob_size = 1024; options.min_blob_size = 1024;
options.env = &mock_env_; options.env = &mock_env_;
ImmutableOptions immutable_cf_options(options); ImmutableOptions immutable_options(options);
MutableCFOptions mutable_cf_options(options); MutableCFOptions mutable_cf_options(options);
constexpr int job_id = 1; constexpr int job_id = 1;
@ -313,12 +311,11 @@ TEST_F(BlobFileBuilderTest, InlinedValues) {
std::vector<std::string> blob_file_paths; std::vector<std::string> blob_file_paths;
std::vector<BlobFileAddition> blob_file_additions; std::vector<BlobFileAddition> blob_file_additions;
BlobFileBuilder builder(TestFileNumberGenerator(), fs_, &immutable_cf_options, BlobFileBuilder builder(
&mutable_cf_options, &file_options_, job_id, TestFileNumberGenerator(), fs_, &immutable_options, &mutable_cf_options,
column_family_id, column_family_name, io_priority, &file_options_, job_id, column_family_id, column_family_name, io_priority,
write_hint, nullptr /*IOTracer*/, write_hint, nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/,
nullptr /*BlobFileCompletionCallback*/, &blob_file_paths, &blob_file_additions);
&blob_file_paths, &blob_file_additions);
for (size_t i = 0; i < number_of_blobs; ++i) { for (size_t i = 0; i < number_of_blobs; ++i) {
const std::string key = std::to_string(i); const std::string key = std::to_string(i);
@ -355,7 +352,7 @@ TEST_F(BlobFileBuilderTest, Compression) {
options.blob_compression_type = kSnappyCompression; options.blob_compression_type = kSnappyCompression;
options.env = &mock_env_; options.env = &mock_env_;
ImmutableOptions immutable_cf_options(options); ImmutableOptions immutable_options(options);
MutableCFOptions mutable_cf_options(options); MutableCFOptions mutable_cf_options(options);
constexpr int job_id = 1; constexpr int job_id = 1;
@ -367,12 +364,11 @@ TEST_F(BlobFileBuilderTest, Compression) {
std::vector<std::string> blob_file_paths; std::vector<std::string> blob_file_paths;
std::vector<BlobFileAddition> blob_file_additions; std::vector<BlobFileAddition> blob_file_additions;
BlobFileBuilder builder(TestFileNumberGenerator(), fs_, &immutable_cf_options, BlobFileBuilder builder(
&mutable_cf_options, &file_options_, job_id, TestFileNumberGenerator(), fs_, &immutable_options, &mutable_cf_options,
column_family_id, column_family_name, io_priority, &file_options_, job_id, column_family_id, column_family_name, io_priority,
write_hint, nullptr /*IOTracer*/, write_hint, nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/,
nullptr /*BlobFileCompletionCallback*/, &blob_file_paths, &blob_file_additions);
&blob_file_paths, &blob_file_additions);
const std::string key("1"); const std::string key("1");
const std::string uncompressed_value(value_size, 'x'); const std::string uncompressed_value(value_size, 'x');
@ -391,9 +387,9 @@ TEST_F(BlobFileBuilderTest, Compression) {
const std::string& blob_file_path = blob_file_paths[0]; const std::string& blob_file_path = blob_file_paths[0];
ASSERT_EQ(blob_file_path, ASSERT_EQ(
BlobFileName(immutable_cf_options.cf_paths.front().path, blob_file_path,
blob_file_number)); BlobFileName(immutable_options.cf_paths.front().path, blob_file_number));
ASSERT_EQ(blob_file_additions.size(), 1); ASSERT_EQ(blob_file_additions.size(), 1);
@ -438,7 +434,7 @@ TEST_F(BlobFileBuilderTest, CompressionError) {
options.enable_blob_files = true; options.enable_blob_files = true;
options.blob_compression_type = kSnappyCompression; options.blob_compression_type = kSnappyCompression;
options.env = &mock_env_; options.env = &mock_env_;
ImmutableOptions immutable_cf_options(options); ImmutableOptions immutable_options(options);
MutableCFOptions mutable_cf_options(options); MutableCFOptions mutable_cf_options(options);
constexpr int job_id = 1; constexpr int job_id = 1;
@ -450,12 +446,11 @@ TEST_F(BlobFileBuilderTest, CompressionError) {
std::vector<std::string> blob_file_paths; std::vector<std::string> blob_file_paths;
std::vector<BlobFileAddition> blob_file_additions; std::vector<BlobFileAddition> blob_file_additions;
BlobFileBuilder builder(TestFileNumberGenerator(), fs_, &immutable_cf_options, BlobFileBuilder builder(
&mutable_cf_options, &file_options_, job_id, TestFileNumberGenerator(), fs_, &immutable_options, &mutable_cf_options,
column_family_id, column_family_name, io_priority, &file_options_, job_id, column_family_id, column_family_name, io_priority,
write_hint, nullptr /*IOTracer*/, write_hint, nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/,
nullptr /*BlobFileCompletionCallback*/, &blob_file_paths, &blob_file_additions);
&blob_file_paths, &blob_file_additions);
SyncPoint::GetInstance()->SetCallBack("CompressData:TamperWithReturnValue", SyncPoint::GetInstance()->SetCallBack("CompressData:TamperWithReturnValue",
[](void* arg) { [](void* arg) {
@ -477,9 +472,9 @@ TEST_F(BlobFileBuilderTest, CompressionError) {
constexpr uint64_t blob_file_number = 2; constexpr uint64_t blob_file_number = 2;
ASSERT_EQ(blob_file_paths.size(), 1); ASSERT_EQ(blob_file_paths.size(), 1);
ASSERT_EQ(blob_file_paths[0], ASSERT_EQ(
BlobFileName(immutable_cf_options.cf_paths.front().path, blob_file_paths[0],
blob_file_number)); BlobFileName(immutable_options.cf_paths.front().path, blob_file_number));
ASSERT_TRUE(blob_file_additions.empty()); ASSERT_TRUE(blob_file_additions.empty());
} }
@ -517,7 +512,7 @@ TEST_F(BlobFileBuilderTest, Checksum) {
std::make_shared<DummyFileChecksumGenFactory>(); std::make_shared<DummyFileChecksumGenFactory>();
options.env = &mock_env_; options.env = &mock_env_;
ImmutableOptions immutable_cf_options(options); ImmutableOptions immutable_options(options);
MutableCFOptions mutable_cf_options(options); MutableCFOptions mutable_cf_options(options);
constexpr int job_id = 1; constexpr int job_id = 1;
@ -529,12 +524,11 @@ TEST_F(BlobFileBuilderTest, Checksum) {
std::vector<std::string> blob_file_paths; std::vector<std::string> blob_file_paths;
std::vector<BlobFileAddition> blob_file_additions; std::vector<BlobFileAddition> blob_file_additions;
BlobFileBuilder builder(TestFileNumberGenerator(), fs_, &immutable_cf_options, BlobFileBuilder builder(
&mutable_cf_options, &file_options_, job_id, TestFileNumberGenerator(), fs_, &immutable_options, &mutable_cf_options,
column_family_id, column_family_name, io_priority, &file_options_, job_id, column_family_id, column_family_name, io_priority,
write_hint, nullptr /*IOTracer*/, write_hint, nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/,
nullptr /*BlobFileCompletionCallback*/, &blob_file_paths, &blob_file_additions);
&blob_file_paths, &blob_file_additions);
const std::string key("1"); const std::string key("1");
const std::string value("deadbeef"); const std::string value("deadbeef");
@ -553,9 +547,9 @@ TEST_F(BlobFileBuilderTest, Checksum) {
const std::string& blob_file_path = blob_file_paths[0]; const std::string& blob_file_path = blob_file_paths[0];
ASSERT_EQ(blob_file_path, ASSERT_EQ(
BlobFileName(immutable_cf_options.cf_paths.front().path, blob_file_path,
blob_file_number)); BlobFileName(immutable_options.cf_paths.front().path, blob_file_number));
ASSERT_EQ(blob_file_additions.size(), 1); ASSERT_EQ(blob_file_additions.size(), 1);
@ -614,7 +608,7 @@ TEST_P(BlobFileBuilderIOErrorTest, IOError) {
options.blob_file_size = value_size; options.blob_file_size = value_size;
options.env = &mock_env_; options.env = &mock_env_;
ImmutableOptions immutable_cf_options(options); ImmutableOptions immutable_options(options);
MutableCFOptions mutable_cf_options(options); MutableCFOptions mutable_cf_options(options);
constexpr int job_id = 1; constexpr int job_id = 1;
@ -626,12 +620,11 @@ TEST_P(BlobFileBuilderIOErrorTest, IOError) {
std::vector<std::string> blob_file_paths; std::vector<std::string> blob_file_paths;
std::vector<BlobFileAddition> blob_file_additions; std::vector<BlobFileAddition> blob_file_additions;
BlobFileBuilder builder(TestFileNumberGenerator(), fs_, &immutable_cf_options, BlobFileBuilder builder(
&mutable_cf_options, &file_options_, job_id, TestFileNumberGenerator(), fs_, &immutable_options, &mutable_cf_options,
column_family_id, column_family_name, io_priority, &file_options_, job_id, column_family_id, column_family_name, io_priority,
write_hint, nullptr /*IOTracer*/, write_hint, nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/,
nullptr /*BlobFileCompletionCallback*/, &blob_file_paths, &blob_file_additions);
&blob_file_paths, &blob_file_additions);
SyncPoint::GetInstance()->SetCallBack(sync_point_, [this](void* arg) { SyncPoint::GetInstance()->SetCallBack(sync_point_, [this](void* arg) {
Status* const s = static_cast<Status*>(arg); Status* const s = static_cast<Status*>(arg);
@ -658,7 +651,7 @@ TEST_P(BlobFileBuilderIOErrorTest, IOError) {
ASSERT_EQ(blob_file_paths.size(), 1); ASSERT_EQ(blob_file_paths.size(), 1);
ASSERT_EQ(blob_file_paths[0], ASSERT_EQ(blob_file_paths[0],
BlobFileName(immutable_cf_options.cf_paths.front().path, BlobFileName(immutable_options.cf_paths.front().path,
blob_file_number)); blob_file_number));
} }

10
db/blob/blob_file_cache.cc
View File

@ -26,13 +26,13 @@ BlobFileCache::BlobFileCache(Cache* cache,
const std::shared_ptr<IOTracer>& io_tracer) const std::shared_ptr<IOTracer>& io_tracer)
: cache_(cache), : cache_(cache),
mutex_(kNumberOfMutexStripes, kGetSliceNPHash64UnseededFnPtr), mutex_(kNumberOfMutexStripes, kGetSliceNPHash64UnseededFnPtr),
immutable_cf_options_(immutable_options), immutable_options_(immutable_options),
file_options_(file_options), file_options_(file_options),
column_family_id_(column_family_id), column_family_id_(column_family_id),
blob_file_read_hist_(blob_file_read_hist), blob_file_read_hist_(blob_file_read_hist),
io_tracer_(io_tracer) { io_tracer_(io_tracer) {
assert(cache_); assert(cache_);
assert(immutable_cf_options_); assert(immutable_options_);
assert(file_options_); assert(file_options_);
} }
@ -63,8 +63,8 @@ Status BlobFileCache::GetBlobFileReader(
return Status::OK(); return Status::OK();
} }
assert(immutable_cf_options_); assert(immutable_options_);
Statistics* const statistics = immutable_cf_options_->stats; Statistics* const statistics = immutable_options_->stats;
RecordTick(statistics, NO_FILE_OPENS); RecordTick(statistics, NO_FILE_OPENS);
@ -73,7 +73,7 @@ Status BlobFileCache::GetBlobFileReader(
{ {
assert(file_options_); assert(file_options_);
const Status s = BlobFileReader::Create( const Status s = BlobFileReader::Create(
*immutable_cf_options_, *file_options_, column_family_id_, *immutable_options_, *file_options_, column_family_id_,
blob_file_read_hist_, blob_file_number, io_tracer_, &reader); blob_file_read_hist_, blob_file_number, io_tracer_, &reader);
if (!s.ok()) { if (!s.ok()) {
RecordTick(statistics, NO_FILE_ERRORS); RecordTick(statistics, NO_FILE_ERRORS);

2
db/blob/blob_file_cache.h
View File

@ -40,7 +40,7 @@ class BlobFileCache {
// Note: mutex_ below is used to guard against multiple threads racing to open // Note: mutex_ below is used to guard against multiple threads racing to open
// the same file. // the same file.
Striped<port::Mutex, Slice> mutex_; Striped<port::Mutex, Slice> mutex_;
const ImmutableOptions* immutable_cf_options_; const ImmutableOptions* immutable_options_;
const FileOptions* file_options_; const FileOptions* file_options_;
uint32_t column_family_id_; uint32_t column_family_id_;
HistogramImpl* blob_file_read_hist_; HistogramImpl* blob_file_read_hist_;

45
db/blob/blob_file_cache_test.cc
View File

@ -29,28 +29,27 @@ namespace {
// Creates a test blob file with a single blob in it. // Creates a test blob file with a single blob in it.
void WriteBlobFile(uint32_t column_family_id, void WriteBlobFile(uint32_t column_family_id,
const ImmutableOptions& immutable_cf_options, const ImmutableOptions& immutable_options,
uint64_t blob_file_number) { uint64_t blob_file_number) {
assert(!immutable_cf_options.cf_paths.empty()); assert(!immutable_options.cf_paths.empty());
const std::string blob_file_path = BlobFileName( const std::string blob_file_path =
immutable_cf_options.cf_paths.front().path, blob_file_number); BlobFileName(immutable_options.cf_paths.front().path, blob_file_number);
std::unique_ptr<FSWritableFile> file; std::unique_ptr<FSWritableFile> file;
ASSERT_OK(NewWritableFile(immutable_cf_options.fs.get(), blob_file_path, ASSERT_OK(NewWritableFile(immutable_options.fs.get(), blob_file_path, &file,
&file, FileOptions())); FileOptions()));
std::unique_ptr<WritableFileWriter> file_writer( std::unique_ptr<WritableFileWriter> file_writer(new WritableFileWriter(
new WritableFileWriter(std::move(file), blob_file_path, FileOptions(), std::move(file), blob_file_path, FileOptions(), immutable_options.clock));
immutable_cf_options.clock));
constexpr Statistics* statistics = nullptr; constexpr Statistics* statistics = nullptr;
constexpr bool use_fsync = false; constexpr bool use_fsync = false;
constexpr bool do_flush = false; constexpr bool do_flush = false;
BlobLogWriter blob_log_writer(std::move(file_writer), BlobLogWriter blob_log_writer(std::move(file_writer), immutable_options.clock,
immutable_cf_options.clock, statistics, statistics, blob_file_number, use_fsync,
blob_file_number, use_fsync, do_flush); do_flush);
constexpr bool has_ttl = false; constexpr bool has_ttl = false;
constexpr ExpirationRange expiration_range; constexpr ExpirationRange expiration_range;
@ -100,10 +99,10 @@ TEST_F(BlobFileCacheTest, GetBlobFileReader) {
options.enable_blob_files = true; options.enable_blob_files = true;
constexpr uint32_t column_family_id = 1; constexpr uint32_t column_family_id = 1;
ImmutableOptions immutable_cf_options(options); ImmutableOptions immutable_options(options);
constexpr uint64_t blob_file_number = 123; constexpr uint64_t blob_file_number = 123;
WriteBlobFile(column_family_id, immutable_cf_options, blob_file_number); WriteBlobFile(column_family_id, immutable_options, blob_file_number);
constexpr size_t capacity = 10; constexpr size_t capacity = 10;
std::shared_ptr<Cache> backing_cache = NewLRUCache(capacity); std::shared_ptr<Cache> backing_cache = NewLRUCache(capacity);
@ -111,7 +110,7 @@ TEST_F(BlobFileCacheTest, GetBlobFileReader) {
FileOptions file_options; FileOptions file_options;
constexpr HistogramImpl* blob_file_read_hist = nullptr; constexpr HistogramImpl* blob_file_read_hist = nullptr;
BlobFileCache blob_file_cache(backing_cache.get(), &immutable_cf_options, BlobFileCache blob_file_cache(backing_cache.get(), &immutable_options,
&file_options, column_family_id, &file_options, column_family_id,
blob_file_read_hist, nullptr /*IOTracer*/); blob_file_read_hist, nullptr /*IOTracer*/);
@ -145,10 +144,10 @@ TEST_F(BlobFileCacheTest, GetBlobFileReader_Race) {
options.enable_blob_files = true; options.enable_blob_files = true;
constexpr uint32_t column_family_id = 1; constexpr uint32_t column_family_id = 1;
ImmutableOptions immutable_cf_options(options); ImmutableOptions immutable_options(options);
constexpr uint64_t blob_file_number = 123; constexpr uint64_t blob_file_number = 123;
WriteBlobFile(column_family_id, immutable_cf_options, blob_file_number); WriteBlobFile(column_family_id, immutable_options, blob_file_number);
constexpr size_t capacity = 10; constexpr size_t capacity = 10;
std::shared_ptr<Cache> backing_cache = NewLRUCache(capacity); std::shared_ptr<Cache> backing_cache = NewLRUCache(capacity);
@ -156,7 +155,7 @@ TEST_F(BlobFileCacheTest, GetBlobFileReader_Race) {
FileOptions file_options; FileOptions file_options;
constexpr HistogramImpl* blob_file_read_hist = nullptr; constexpr HistogramImpl* blob_file_read_hist = nullptr;
BlobFileCache blob_file_cache(backing_cache.get(), &immutable_cf_options, BlobFileCache blob_file_cache(backing_cache.get(), &immutable_options,
&file_options, column_family_id, &file_options, column_family_id,
blob_file_read_hist, nullptr /*IOTracer*/); blob_file_read_hist, nullptr /*IOTracer*/);
@ -199,12 +198,12 @@ TEST_F(BlobFileCacheTest, GetBlobFileReader_IOError) {
constexpr size_t capacity = 10; constexpr size_t capacity = 10;
std::shared_ptr<Cache> backing_cache = NewLRUCache(capacity); std::shared_ptr<Cache> backing_cache = NewLRUCache(capacity);
ImmutableOptions immutable_cf_options(options); ImmutableOptions immutable_options(options);
FileOptions file_options; FileOptions file_options;
constexpr uint32_t column_family_id = 1; constexpr uint32_t column_family_id = 1;
constexpr HistogramImpl* blob_file_read_hist = nullptr; constexpr HistogramImpl* blob_file_read_hist = nullptr;
BlobFileCache blob_file_cache(backing_cache.get(), &immutable_cf_options, BlobFileCache blob_file_cache(backing_cache.get(), &immutable_options,
&file_options, column_family_id, &file_options, column_family_id,
blob_file_read_hist, nullptr /*IOTracer*/); blob_file_read_hist, nullptr /*IOTracer*/);
@ -231,10 +230,10 @@ TEST_F(BlobFileCacheTest, GetBlobFileReader_CacheFull) {
options.enable_blob_files = true; options.enable_blob_files = true;
constexpr uint32_t column_family_id = 1; constexpr uint32_t column_family_id = 1;
ImmutableOptions immutable_cf_options(options); ImmutableOptions immutable_options(options);
constexpr uint64_t blob_file_number = 123; constexpr uint64_t blob_file_number = 123;
WriteBlobFile(column_family_id, immutable_cf_options, blob_file_number); WriteBlobFile(column_family_id, immutable_options, blob_file_number);
constexpr size_t capacity = 0; constexpr size_t capacity = 0;
constexpr int num_shard_bits = -1; // determined automatically constexpr int num_shard_bits = -1; // determined automatically
@ -245,7 +244,7 @@ TEST_F(BlobFileCacheTest, GetBlobFileReader_CacheFull) {
FileOptions file_options; FileOptions file_options;
constexpr HistogramImpl* blob_file_read_hist = nullptr; constexpr HistogramImpl* blob_file_read_hist = nullptr;
BlobFileCache blob_file_cache(backing_cache.get(), &immutable_cf_options, BlobFileCache blob_file_cache(backing_cache.get(), &immutable_options,
&file_options, column_family_id, &file_options, column_family_id,
blob_file_read_hist, nullptr /*IOTracer*/); blob_file_read_hist, nullptr /*IOTracer*/);

25
db/blob/blob_file_reader.cc
View File

@ -21,10 +21,9 @@
namespace ROCKSDB_NAMESPACE { namespace ROCKSDB_NAMESPACE {
Status BlobFileReader::Create( Status BlobFileReader::Create(
const ImmutableOptions& immutable_cf_options, const ImmutableOptions& immutable_options, const FileOptions& file_options,
const FileOptions& file_options, uint32_t column_family_id, uint32_t column_family_id, HistogramImpl* blob_file_read_hist,
HistogramImpl* blob_file_read_hist, uint64_t blob_file_number, uint64_t blob_file_number, const std::shared_ptr<IOTracer>& io_tracer,
const std::shared_ptr<IOTracer>& io_tracer,
std::unique_ptr<BlobFileReader>* blob_file_reader) { std::unique_ptr<BlobFileReader>* blob_file_reader) {
assert(blob_file_reader); assert(blob_file_reader);
assert(!*blob_file_reader); assert(!*blob_file_reader);
@ -34,7 +33,7 @@ Status BlobFileReader::Create(
{ {
const Status s = const Status s =
OpenFile(immutable_cf_options, file_options, blob_file_read_hist, OpenFile(immutable_options, file_options, blob_file_read_hist,
blob_file_number, io_tracer, &file_size, &file_reader); blob_file_number, io_tracer, &file_size, &file_reader);
if (!s.ok()) { if (!s.ok()) {
return s; return s;
@ -67,20 +66,20 @@ Status BlobFileReader::Create(
} }
Status BlobFileReader::OpenFile( Status BlobFileReader::OpenFile(
const ImmutableOptions& immutable_cf_options, const FileOptions& file_opts, const ImmutableOptions& immutable_options, const FileOptions& file_opts,
HistogramImpl* blob_file_read_hist, uint64_t blob_file_number, HistogramImpl* blob_file_read_hist, uint64_t blob_file_number,
const std::shared_ptr<IOTracer>& io_tracer, uint64_t* file_size, const std::shared_ptr<IOTracer>& io_tracer, uint64_t* file_size,
std::unique_ptr<RandomAccessFileReader>* file_reader) { std::unique_ptr<RandomAccessFileReader>* file_reader) {
assert(file_size); assert(file_size);
assert(file_reader); assert(file_reader);
const auto& cf_paths = immutable_cf_options.cf_paths; const auto& cf_paths = immutable_options.cf_paths;
assert(!cf_paths.empty()); assert(!cf_paths.empty());
const std::string blob_file_path = const std::string blob_file_path =
BlobFileName(cf_paths.front().path, blob_file_number); BlobFileName(cf_paths.front().path, blob_file_number);
FileSystem* const fs = immutable_cf_options.fs.get(); FileSystem* const fs = immutable_options.fs.get();
assert(fs); assert(fs);
constexpr IODebugContext* dbg = nullptr; constexpr IODebugContext* dbg = nullptr;
@ -113,15 +112,15 @@ Status BlobFileReader::OpenFile(
assert(file); assert(file);
if (immutable_cf_options.advise_random_on_open) { if (immutable_options.advise_random_on_open) {
file->Hint(FSRandomAccessFile::kRandom); file->Hint(FSRandomAccessFile::kRandom);
} }
file_reader->reset(new RandomAccessFileReader( file_reader->reset(new RandomAccessFileReader(
std::move(file), blob_file_path, immutable_cf_options.clock, io_tracer, std::move(file), blob_file_path, immutable_options.clock, io_tracer,
immutable_cf_options.stats, BLOB_DB_BLOB_FILE_READ_MICROS, immutable_options.stats, BLOB_DB_BLOB_FILE_READ_MICROS,
blob_file_read_hist, immutable_cf_options.rate_limiter.get(), blob_file_read_hist, immutable_options.rate_limiter.get(),
immutable_cf_options.listeners)); immutable_options.listeners));
return Status::OK(); return Status::OK();
} }

139
db/blob/blob_file_reader_test.cc
View File

@ -30,35 +30,34 @@ namespace {
// Creates a test blob file with a single blob in it. Note: this method // 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 // makes it possible to test various corner cases by allowing the caller
// to specify the contents of various blob file header/footer fields. // to specify the contents of various blob file header/footer fields.
void WriteBlobFile(const ImmutableOptions& immutable_cf_options, void WriteBlobFile(const ImmutableOptions& immutable_options,
uint32_t column_family_id, bool has_ttl, uint32_t column_family_id, bool has_ttl,
const ExpirationRange& expiration_range_header, const ExpirationRange& expiration_range_header,
const ExpirationRange& expiration_range_footer, const ExpirationRange& expiration_range_footer,
uint64_t blob_file_number, const Slice& key, uint64_t blob_file_number, const Slice& key,
const Slice& blob, CompressionType compression_type, const Slice& blob, CompressionType compression_type,
uint64_t* blob_offset, uint64_t* blob_size) { uint64_t* blob_offset, uint64_t* blob_size) {
assert(!immutable_cf_options.cf_paths.empty()); assert(!immutable_options.cf_paths.empty());
assert(blob_offset); assert(blob_offset);
assert(blob_size); assert(blob_size);
const std::string blob_file_path = BlobFileName( const std::string blob_file_path =
immutable_cf_options.cf_paths.front().path, blob_file_number); BlobFileName(immutable_options.cf_paths.front().path, blob_file_number);
std::unique_ptr<FSWritableFile> file; std::unique_ptr<FSWritableFile> file;
ASSERT_OK(NewWritableFile(immutable_cf_options.fs.get(), blob_file_path, ASSERT_OK(NewWritableFile(immutable_options.fs.get(), blob_file_path, &file,
&file, FileOptions())); FileOptions()));
std::unique_ptr<WritableFileWriter> file_writer( std::unique_ptr<WritableFileWriter> file_writer(new WritableFileWriter(
new WritableFileWriter(std::move(file), blob_file_path, FileOptions(), std::move(file), blob_file_path, FileOptions(), immutable_options.clock));
immutable_cf_options.clock));
constexpr Statistics* statistics = nullptr; constexpr Statistics* statistics = nullptr;
constexpr bool use_fsync = false; constexpr bool use_fsync = false;
constexpr bool do_flush = false; constexpr bool do_flush = false;
BlobLogWriter blob_log_writer(std::move(file_writer), BlobLogWriter blob_log_writer(std::move(file_writer), immutable_options.clock,
immutable_cf_options.clock, statistics, statistics, blob_file_number, use_fsync,
blob_file_number, use_fsync, do_flush); do_flush);
BlobLogHeader header(column_family_id, compression_type, has_ttl, BlobLogHeader header(column_family_id, compression_type, has_ttl,
expiration_range_header); expiration_range_header);
@ -122,7 +121,7 @@ TEST_F(BlobFileReaderTest, CreateReaderAndGetBlob) {
0); 0);
options.enable_blob_files = true; options.enable_blob_files = true;
ImmutableOptions immutable_cf_options(options); ImmutableOptions immutable_options(options);
constexpr uint32_t column_family_id = 1; constexpr uint32_t column_family_id = 1;
constexpr bool has_ttl = false; constexpr bool has_ttl = false;
@ -134,17 +133,17 @@ TEST_F(BlobFileReaderTest, CreateReaderAndGetBlob) {
uint64_t blob_offset = 0; uint64_t blob_offset = 0;
uint64_t blob_size = 0; uint64_t blob_size = 0;
WriteBlobFile(immutable_cf_options, column_family_id, has_ttl, WriteBlobFile(immutable_options, column_family_id, has_ttl, expiration_range,
expiration_range, expiration_range, blob_file_number, key, blob, expiration_range, blob_file_number, key, blob, kNoCompression,
kNoCompression, &blob_offset, &blob_size); &blob_offset, &blob_size);
constexpr HistogramImpl* blob_file_read_hist = nullptr; constexpr HistogramImpl* blob_file_read_hist = nullptr;
std::unique_ptr<BlobFileReader> reader; std::unique_ptr<BlobFileReader> reader;
ASSERT_OK(BlobFileReader::Create( ASSERT_OK(BlobFileReader::Create(
immutable_cf_options, FileOptions(), column_family_id, immutable_options, FileOptions(), column_family_id, blob_file_read_hist,
blob_file_read_hist, blob_file_number, nullptr /*IOTracer*/, &reader)); blob_file_number, nullptr /*IOTracer*/, &reader));
// Make sure the blob can be retrieved with and without checksum verification // Make sure the blob can be retrieved with and without checksum verification
ReadOptions read_options; ReadOptions read_options;
@ -262,7 +261,7 @@ TEST_F(BlobFileReaderTest, Malformed) {
test::PerThreadDBPath(&mock_env_, "BlobFileReaderTest_Malformed"), 0); test::PerThreadDBPath(&mock_env_, "BlobFileReaderTest_Malformed"), 0);
options.enable_blob_files = true; options.enable_blob_files = true;
ImmutableOptions immutable_cf_options(options); ImmutableOptions immutable_options(options);
constexpr uint32_t column_family_id = 1; constexpr uint32_t column_family_id = 1;
constexpr uint64_t blob_file_number = 1; constexpr uint64_t blob_file_number = 1;
@ -271,23 +270,23 @@ TEST_F(BlobFileReaderTest, Malformed) {
constexpr bool has_ttl = false; constexpr bool has_ttl = false;
constexpr ExpirationRange expiration_range; constexpr ExpirationRange expiration_range;
const std::string blob_file_path = BlobFileName( const std::string blob_file_path =
immutable_cf_options.cf_paths.front().path, blob_file_number); BlobFileName(immutable_options.cf_paths.front().path, blob_file_number);
std::unique_ptr<FSWritableFile> file; std::unique_ptr<FSWritableFile> file;
ASSERT_OK(NewWritableFile(immutable_cf_options.fs.get(), blob_file_path, ASSERT_OK(NewWritableFile(immutable_options.fs.get(), blob_file_path, &file,
&file, FileOptions())); FileOptions()));
std::unique_ptr<WritableFileWriter> file_writer( std::unique_ptr<WritableFileWriter> file_writer(
new WritableFileWriter(std::move(file), blob_file_path, FileOptions(), new WritableFileWriter(std::move(file), blob_file_path, FileOptions(),
immutable_cf_options.clock)); immutable_options.clock));
constexpr Statistics* statistics = nullptr; constexpr Statistics* statistics = nullptr;
constexpr bool use_fsync = false; constexpr bool use_fsync = false;
constexpr bool do_flush = false; constexpr bool do_flush = false;
BlobLogWriter blob_log_writer(std::move(file_writer), BlobLogWriter blob_log_writer(std::move(file_writer),
immutable_cf_options.clock, statistics, immutable_options.clock, statistics,
blob_file_number, use_fsync, do_flush); blob_file_number, use_fsync, do_flush);
BlobLogHeader header(column_family_id, kNoCompression, has_ttl, BlobLogHeader header(column_family_id, kNoCompression, has_ttl,
@ -300,7 +299,7 @@ TEST_F(BlobFileReaderTest, Malformed) {
std::unique_ptr<BlobFileReader> reader; std::unique_ptr<BlobFileReader> reader;
ASSERT_TRUE(BlobFileReader::Create(immutable_cf_options, FileOptions(), ASSERT_TRUE(BlobFileReader::Create(immutable_options, FileOptions(),
column_family_id, blob_file_read_hist, column_family_id, blob_file_read_hist,
blob_file_number, nullptr /*IOTracer*/, blob_file_number, nullptr /*IOTracer*/,
&reader) &reader)
@ -314,7 +313,7 @@ TEST_F(BlobFileReaderTest, TTL) {
test::PerThreadDBPath(&mock_env_, "BlobFileReaderTest_TTL"), 0); test::PerThreadDBPath(&mock_env_, "BlobFileReaderTest_TTL"), 0);
options.enable_blob_files = true; options.enable_blob_files = true;
ImmutableOptions immutable_cf_options(options); ImmutableOptions immutable_options(options);
constexpr uint32_t column_family_id = 1; constexpr uint32_t column_family_id = 1;
constexpr bool has_ttl = true; constexpr bool has_ttl = true;
@ -326,15 +325,15 @@ TEST_F(BlobFileReaderTest, TTL) {
uint64_t blob_offset = 0; uint64_t blob_offset = 0;
uint64_t blob_size = 0; uint64_t blob_size = 0;
WriteBlobFile(immutable_cf_options, column_family_id, has_ttl, WriteBlobFile(immutable_options, column_family_id, has_ttl, expiration_range,
expiration_range, expiration_range, blob_file_number, key, blob, expiration_range, blob_file_number, key, blob, kNoCompression,
kNoCompression, &blob_offset, &blob_size); &blob_offset, &blob_size);
constexpr HistogramImpl* blob_file_read_hist = nullptr; constexpr HistogramImpl* blob_file_read_hist = nullptr;
std::unique_ptr<BlobFileReader> reader; std::unique_ptr<BlobFileReader> reader;
ASSERT_TRUE(BlobFileReader::Create(immutable_cf_options, FileOptions(), ASSERT_TRUE(BlobFileReader::Create(immutable_options, FileOptions(),
column_family_id, blob_file_read_hist, column_family_id, blob_file_read_hist,
blob_file_number, nullptr /*IOTracer*/, blob_file_number, nullptr /*IOTracer*/,
&reader) &reader)
@ -350,7 +349,7 @@ TEST_F(BlobFileReaderTest, ExpirationRangeInHeader) {
0); 0);
options.enable_blob_files = true; options.enable_blob_files = true;
ImmutableOptions immutable_cf_options(options); ImmutableOptions immutable_options(options);
constexpr uint32_t column_family_id = 1; constexpr uint32_t column_family_id = 1;
constexpr bool has_ttl = false; constexpr bool has_ttl = false;
@ -364,7 +363,7 @@ TEST_F(BlobFileReaderTest, ExpirationRangeInHeader) {
uint64_t blob_offset = 0; uint64_t blob_offset = 0;
uint64_t blob_size = 0; uint64_t blob_size = 0;
WriteBlobFile(immutable_cf_options, column_family_id, has_ttl, WriteBlobFile(immutable_options, column_family_id, has_ttl,
expiration_range_header, expiration_range_footer, expiration_range_header, expiration_range_footer,
blob_file_number, key, blob, kNoCompression, &blob_offset, blob_file_number, key, blob, kNoCompression, &blob_offset,
&blob_size); &blob_size);
@ -373,7 +372,7 @@ TEST_F(BlobFileReaderTest, ExpirationRangeInHeader) {
std::unique_ptr<BlobFileReader> reader; std::unique_ptr<BlobFileReader> reader;
ASSERT_TRUE(BlobFileReader::Create(immutable_cf_options, FileOptions(), ASSERT_TRUE(BlobFileReader::Create(immutable_options, FileOptions(),
column_family_id, blob_file_read_hist, column_family_id, blob_file_read_hist,
blob_file_number, nullptr /*IOTracer*/, blob_file_number, nullptr /*IOTracer*/,
&reader) &reader)
@ -389,7 +388,7 @@ TEST_F(BlobFileReaderTest, ExpirationRangeInFooter) {
0); 0);
options.enable_blob_files = true; options.enable_blob_files = true;
ImmutableOptions immutable_cf_options(options); ImmutableOptions immutable_options(options);
constexpr uint32_t column_family_id = 1; constexpr uint32_t column_family_id = 1;
constexpr bool has_ttl = false; constexpr bool has_ttl = false;
@ -403,7 +402,7 @@ TEST_F(BlobFileReaderTest, ExpirationRangeInFooter) {
uint64_t blob_offset = 0; uint64_t blob_offset = 0;
uint64_t blob_size = 0; uint64_t blob_size = 0;
WriteBlobFile(immutable_cf_options, column_family_id, has_ttl, WriteBlobFile(immutable_options, column_family_id, has_ttl,
expiration_range_header, expiration_range_footer, expiration_range_header, expiration_range_footer,
blob_file_number, key, blob, kNoCompression, &blob_offset, blob_file_number, key, blob, kNoCompression, &blob_offset,
&blob_size); &blob_size);
@ -412,7 +411,7 @@ TEST_F(BlobFileReaderTest, ExpirationRangeInFooter) {
std::unique_ptr<BlobFileReader> reader; std::unique_ptr<BlobFileReader> reader;
ASSERT_TRUE(BlobFileReader::Create(immutable_cf_options, FileOptions(), ASSERT_TRUE(BlobFileReader::Create(immutable_options, FileOptions(),
column_family_id, blob_file_read_hist, column_family_id, blob_file_read_hist,
blob_file_number, nullptr /*IOTracer*/, blob_file_number, nullptr /*IOTracer*/,
&reader) &reader)
@ -428,7 +427,7 @@ TEST_F(BlobFileReaderTest, IncorrectColumnFamily) {
0); 0);
options.enable_blob_files = true; options.enable_blob_files = true;
ImmutableOptions immutable_cf_options(options); ImmutableOptions immutable_options(options);
constexpr uint32_t column_family_id = 1; constexpr uint32_t column_family_id = 1;
constexpr bool has_ttl = false; constexpr bool has_ttl = false;
@ -440,9 +439,9 @@ TEST_F(BlobFileReaderTest, IncorrectColumnFamily) {
uint64_t blob_offset = 0; uint64_t blob_offset = 0;
uint64_t blob_size = 0; uint64_t blob_size = 0;
WriteBlobFile(immutable_cf_options, column_family_id, has_ttl, WriteBlobFile(immutable_options, column_family_id, has_ttl, expiration_range,
expiration_range, expiration_range, blob_file_number, key, blob, expiration_range, blob_file_number, key, blob, kNoCompression,
kNoCompression, &blob_offset, &blob_size); &blob_offset, &blob_size);
constexpr HistogramImpl* blob_file_read_hist = nullptr; constexpr HistogramImpl* blob_file_read_hist = nullptr;
@ -450,7 +449,7 @@ TEST_F(BlobFileReaderTest, IncorrectColumnFamily) {
constexpr uint32_t incorrect_column_family_id = 2; constexpr uint32_t incorrect_column_family_id = 2;
ASSERT_TRUE(BlobFileReader::Create(immutable_cf_options, FileOptions(), ASSERT_TRUE(BlobFileReader::Create(immutable_options, FileOptions(),
incorrect_column_family_id, incorrect_column_family_id,
blob_file_read_hist, blob_file_number, blob_file_read_hist, blob_file_number,
nullptr /*IOTracer*/, &reader) nullptr /*IOTracer*/, &reader)
@ -464,7 +463,7 @@ TEST_F(BlobFileReaderTest, BlobCRCError) {
test::PerThreadDBPath(&mock_env_, "BlobFileReaderTest_BlobCRCError"), 0); test::PerThreadDBPath(&mock_env_, "BlobFileReaderTest_BlobCRCError"), 0);
options.enable_blob_files = true; options.enable_blob_files = true;
ImmutableOptions immutable_cf_options(options); ImmutableOptions immutable_options(options);
constexpr uint32_t column_family_id = 1; constexpr uint32_t column_family_id = 1;
constexpr bool has_ttl = false; constexpr bool has_ttl = false;
@ -476,17 +475,17 @@ TEST_F(BlobFileReaderTest, BlobCRCError) {
uint64_t blob_offset = 0; uint64_t blob_offset = 0;
uint64_t blob_size = 0; uint64_t blob_size = 0;
WriteBlobFile(immutable_cf_options, column_family_id, has_ttl, WriteBlobFile(immutable_options, column_family_id, has_ttl, expiration_range,
expiration_range, expiration_range, blob_file_number, key, blob, expiration_range, blob_file_number, key, blob, kNoCompression,
kNoCompression, &blob_offset, &blob_size); &blob_offset, &blob_size);
constexpr HistogramImpl* blob_file_read_hist = nullptr; constexpr HistogramImpl* blob_file_read_hist = nullptr;
std::unique_ptr<BlobFileReader> reader; std::unique_ptr<BlobFileReader> reader;
ASSERT_OK(BlobFileReader::Create( ASSERT_OK(BlobFileReader::Create(
immutable_cf_options, FileOptions(), column_family_id, immutable_options, FileOptions(), column_family_id, blob_file_read_hist,
blob_file_read_hist, blob_file_number, nullptr /*IOTracer*/, &reader)); blob_file_number, nullptr /*IOTracer*/, &reader));
SyncPoint::GetInstance()->SetCallBack( SyncPoint::GetInstance()->SetCallBack(
"BlobFileReader::VerifyBlob:CheckBlobCRC", [](void* arg) { "BlobFileReader::VerifyBlob:CheckBlobCRC", [](void* arg) {
@ -522,7 +521,7 @@ TEST_F(BlobFileReaderTest, Compression) {
test::PerThreadDBPath(&mock_env_, "BlobFileReaderTest_Compression"), 0); test::PerThreadDBPath(&mock_env_, "BlobFileReaderTest_Compression"), 0);
options.enable_blob_files = true; options.enable_blob_files = true;
ImmutableOptions immutable_cf_options(options); ImmutableOptions immutable_options(options);
constexpr uint32_t column_family_id = 1; constexpr uint32_t column_family_id = 1;
constexpr bool has_ttl = false; constexpr bool has_ttl = false;
@ -534,8 +533,8 @@ TEST_F(BlobFileReaderTest, Compression) {
uint64_t blob_offset = 0; uint64_t blob_offset = 0;
uint64_t blob_size = 0; uint64_t blob_size = 0;
WriteBlobFile(immutable_cf_options, column_family_id, has_ttl, WriteBlobFile(immutable_options, column_family_id, has_ttl, expiration_range,
expiration_range, expiration_range, blob_file_number, key, blob, expiration_range, blob_file_number, key, blob,
kSnappyCompression, &blob_offset, &blob_size); kSnappyCompression, &blob_offset, &blob_size);
constexpr HistogramImpl* blob_file_read_hist = nullptr; constexpr HistogramImpl* blob_file_read_hist = nullptr;
@ -543,8 +542,8 @@ TEST_F(BlobFileReaderTest, Compression) {
std::unique_ptr<BlobFileReader> reader; std::unique_ptr<BlobFileReader> reader;
ASSERT_OK(BlobFileReader::Create( ASSERT_OK(BlobFileReader::Create(
immutable_cf_options, FileOptions(), column_family_id, immutable_options, FileOptions(), column_family_id, blob_file_read_hist,
blob_file_read_hist, blob_file_number, nullptr /*IOTracer*/, &reader)); blob_file_number, nullptr /*IOTracer*/, &reader));
// Make sure the blob can be retrieved with and without checksum verification // Make sure the blob can be retrieved with and without checksum verification
ReadOptions read_options; ReadOptions read_options;
@ -590,7 +589,7 @@ TEST_F(BlobFileReaderTest, UncompressionError) {
0); 0);
options.enable_blob_files = true; options.enable_blob_files = true;
ImmutableOptions immutable_cf_options(options); ImmutableOptions immutable_options(options);
constexpr uint32_t column_family_id = 1; constexpr uint32_t column_family_id = 1;
constexpr bool has_ttl = false; constexpr bool has_ttl = false;
@ -602,8 +601,8 @@ TEST_F(BlobFileReaderTest, UncompressionError) {
uint64_t blob_offset = 0; uint64_t blob_offset = 0;
uint64_t blob_size = 0; uint64_t blob_size = 0;
WriteBlobFile(immutable_cf_options, column_family_id, has_ttl, WriteBlobFile(immutable_options, column_family_id, has_ttl, expiration_range,
expiration_range, expiration_range, blob_file_number, key, blob, expiration_range, blob_file_number, key, blob,
kSnappyCompression, &blob_offset, &blob_size); kSnappyCompression, &blob_offset, &blob_size);
constexpr HistogramImpl* blob_file_read_hist = nullptr; constexpr HistogramImpl* blob_file_read_hist = nullptr;
@ -611,8 +610,8 @@ TEST_F(BlobFileReaderTest, UncompressionError) {
std::unique_ptr<BlobFileReader> reader; std::unique_ptr<BlobFileReader> reader;
ASSERT_OK(BlobFileReader::Create( ASSERT_OK(BlobFileReader::Create(
immutable_cf_options, FileOptions(), column_family_id, immutable_options, FileOptions(), column_family_id, blob_file_read_hist,
blob_file_read_hist, blob_file_number, nullptr /*IOTracer*/, &reader)); blob_file_number, nullptr /*IOTracer*/, &reader));
SyncPoint::GetInstance()->SetCallBack( SyncPoint::GetInstance()->SetCallBack(
"BlobFileReader::UncompressBlobIfNeeded:TamperWithResult", [](void* arg) { "BlobFileReader::UncompressBlobIfNeeded:TamperWithResult", [](void* arg) {
@ -671,7 +670,7 @@ TEST_P(BlobFileReaderIOErrorTest, IOError) {
0); 0);
options.enable_blob_files = true; options.enable_blob_files = true;
ImmutableOptions immutable_cf_options(options); ImmutableOptions immutable_options(options);
constexpr uint32_t column_family_id = 1; constexpr uint32_t column_family_id = 1;
constexpr bool has_ttl = false; constexpr bool has_ttl = false;
@ -683,9 +682,9 @@ TEST_P(BlobFileReaderIOErrorTest, IOError) {
uint64_t blob_offset = 0; uint64_t blob_offset = 0;
uint64_t blob_size = 0; uint64_t blob_size = 0;
WriteBlobFile(immutable_cf_options, column_family_id, has_ttl, WriteBlobFile(immutable_options, column_family_id, has_ttl, expiration_range,
expiration_range, expiration_range, blob_file_number, key, blob, expiration_range, blob_file_number, key, blob, kNoCompression,
kNoCompression, &blob_offset, &blob_size); &blob_offset, &blob_size);
SyncPoint::GetInstance()->SetCallBack(sync_point_, [this](void* /* arg */) { SyncPoint::GetInstance()->SetCallBack(sync_point_, [this](void* /* arg */) {
fault_injection_env_.SetFilesystemActive(false, fault_injection_env_.SetFilesystemActive(false,
@ -698,8 +697,8 @@ TEST_P(BlobFileReaderIOErrorTest, IOError) {
std::unique_ptr<BlobFileReader> reader; std::unique_ptr<BlobFileReader> reader;
const Status s = BlobFileReader::Create( const Status s = BlobFileReader::Create(
immutable_cf_options, FileOptions(), column_family_id, immutable_options, FileOptions(), column_family_id, blob_file_read_hist,
blob_file_read_hist, blob_file_number, nullptr /*IOTracer*/, &reader); blob_file_number, nullptr /*IOTracer*/, &reader);
const bool fail_during_create = const bool fail_during_create =
(sync_point_ != "BlobFileReader::GetBlob:ReadFromFile"); (sync_point_ != "BlobFileReader::GetBlob:ReadFromFile");
@ -749,7 +748,7 @@ TEST_P(BlobFileReaderDecodingErrorTest, DecodingError) {
0); 0);
options.enable_blob_files = true; options.enable_blob_files = true;
ImmutableOptions immutable_cf_options(options); ImmutableOptions immutable_options(options);
constexpr uint32_t column_family_id = 1; constexpr uint32_t column_family_id = 1;
constexpr bool has_ttl = false; constexpr bool has_ttl = false;
@ -761,9 +760,9 @@ TEST_P(BlobFileReaderDecodingErrorTest, DecodingError) {
uint64_t blob_offset = 0; uint64_t blob_offset = 0;
uint64_t blob_size = 0; uint64_t blob_size = 0;
WriteBlobFile(immutable_cf_options, column_family_id, has_ttl, WriteBlobFile(immutable_options, column_family_id, has_ttl, expiration_range,
expiration_range, expiration_range, blob_file_number, key, blob, expiration_range, blob_file_number, key, blob, kNoCompression,
kNoCompression, &blob_offset, &blob_size); &blob_offset, &blob_size);
SyncPoint::GetInstance()->SetCallBack(sync_point_, [](void* arg) { SyncPoint::GetInstance()->SetCallBack(sync_point_, [](void* arg) {
Slice* const slice = static_cast<Slice*>(arg); Slice* const slice = static_cast<Slice*>(arg);
@ -780,8 +779,8 @@ TEST_P(BlobFileReaderDecodingErrorTest, DecodingError) {
std::unique_ptr<BlobFileReader> reader; std::unique_ptr<BlobFileReader> reader;
const Status s = BlobFileReader::Create( const Status s = BlobFileReader::Create(
immutable_cf_options, FileOptions(), column_family_id, immutable_options, FileOptions(), column_family_id, blob_file_read_hist,
blob_file_read_hist, blob_file_number, nullptr /*IOTracer*/, &reader); blob_file_number, nullptr /*IOTracer*/, &reader);
const bool fail_during_create = const bool fail_during_create =
sync_point_ != "BlobFileReader::GetBlob:TamperWithResult"; sync_point_ != "BlobFileReader::GetBlob:TamperWithResult";

4
db/compaction/compaction.h
View File

@ -223,9 +223,9 @@ class Compaction {
// How many total levels are there? // How many total levels are there?
int number_levels() const { return number_levels_; } int number_levels() const { return number_levels_; }
// Return the ImmutableCFOptions that should be used throughout the compaction // Return the ImmutableOptions that should be used throughout the compaction
// procedure // procedure
const ImmutableOptions* immutable_cf_options() const { const ImmutableOptions* immutable_options() const {
return &immutable_options_; return &immutable_options_;
} }

6
db/compaction/compaction_iterator.h
View File

@ -104,7 +104,7 @@ class CompactionIterator {
explicit RealCompaction(const Compaction* compaction) explicit RealCompaction(const Compaction* compaction)
: compaction_(compaction) { : compaction_(compaction) {
assert(compaction_); assert(compaction_);
assert(compaction_->immutable_cf_options()); assert(compaction_->immutable_options());
assert(compaction_->mutable_cf_options()); assert(compaction_->mutable_cf_options());
} }
@ -126,11 +126,11 @@ class CompactionIterator {
} }
bool allow_ingest_behind() const override { bool allow_ingest_behind() const override {
return compaction_->immutable_cf_options()->allow_ingest_behind; return compaction_->immutable_options()->allow_ingest_behind;
} }
bool preserve_deletes() const override { bool preserve_deletes() const override {
return compaction_->immutable_cf_options()->preserve_deletes; return compaction_->immutable_options()->preserve_deletes;
} }
bool enable_blob_garbage_collection() const override { bool enable_blob_garbage_collection() const override {

19
db/compaction/compaction_job.cc
View File

@ -553,9 +553,10 @@ void CompactionJob::GenSubcompactionBoundaries() {
int base_level = v->storage_info()->base_level(); int base_level = v->storage_info()->base_level();
uint64_t max_output_files = static_cast<uint64_t>(std::ceil( uint64_t max_output_files = static_cast<uint64_t>(std::ceil(
sum / min_file_fill_percent / sum / min_file_fill_percent /
MaxFileSizeForLevel(*(c->mutable_cf_options()), out_lvl, MaxFileSizeForLevel(
c->immutable_cf_options()->compaction_style, base_level, *(c->mutable_cf_options()), out_lvl,
c->immutable_cf_options()->level_compaction_dynamic_level_bytes))); c->immutable_options()->compaction_style, base_level,
c->immutable_options()->level_compaction_dynamic_level_bytes)));
uint64_t subcompactions = uint64_t subcompactions =
std::min({static_cast<uint64_t>(ranges.size()), std::min({static_cast<uint64_t>(ranges.size()),
static_cast<uint64_t>(c->max_subcompactions()), static_cast<uint64_t>(c->max_subcompactions()),
@ -754,7 +755,7 @@ Status CompactionJob::Run() {
for (const auto& state : compact_->sub_compact_states) { for (const auto& state : compact_->sub_compact_states) {
for (const auto& output : state.outputs) { for (const auto& output : state.outputs) {
auto fn = auto fn =
TableFileName(state.compaction->immutable_cf_options()->cf_paths, TableFileName(state.compaction->immutable_options()->cf_paths,
output.meta.fd.GetNumber(), output.meta.fd.GetPathId()); output.meta.fd.GetNumber(), output.meta.fd.GetPathId());
tp[fn] = output.table_properties; tp[fn] = output.table_properties;
} }
@ -1017,7 +1018,7 @@ void CompactionJob::ProcessKeyValueCompactionWithCompactionService(
for (const auto& file : compaction_result.output_files) { for (const auto& file : compaction_result.output_files) {
uint64_t file_num = versions_->NewFileNumber(); uint64_t file_num = versions_->NewFileNumber();
auto src_file = compaction_result.output_path + "/" + file.file_name; auto src_file = compaction_result.output_path + "/" + file.file_name;
auto tgt_file = TableFileName(compaction->immutable_cf_options()->cf_paths, auto tgt_file = TableFileName(compaction->immutable_options()->cf_paths,
file_num, compaction->output_path_id()); file_num, compaction->output_path_id());
s = fs_->RenameFile(src_file, tgt_file, IOOptions(), nullptr); s = fs_->RenameFile(src_file, tgt_file, IOOptions(), nullptr);
if (!s.ok()) { if (!s.ok()) {
@ -1176,7 +1177,7 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
std::unique_ptr<BlobFileBuilder> blob_file_builder( std::unique_ptr<BlobFileBuilder> blob_file_builder(
mutable_cf_options->enable_blob_files mutable_cf_options->enable_blob_files
? new BlobFileBuilder(versions_, fs_.get(), ? new BlobFileBuilder(versions_, fs_.get(),
sub_compact->compaction->immutable_cf_options(), sub_compact->compaction->immutable_options(),
mutable_cf_options, &file_options_, job_id_, mutable_cf_options, &file_options_, job_id_,
cfd->GetID(), cfd->GetName(), cfd->GetID(), cfd->GetName(),
Env::IOPriority::IO_LOW, write_hint_, Env::IOPriority::IO_LOW, write_hint_,
@ -1698,7 +1699,7 @@ Status CompactionJob::FinishCompactionOutputFile(
// This happens when the output level is bottom level, at the same time // This happens when the output level is bottom level, at the same time
// the sub_compact output nothing. // the sub_compact output nothing.
std::string fname = std::string fname =
TableFileName(sub_compact->compaction->immutable_cf_options()->cf_paths, TableFileName(sub_compact->compaction->immutable_options()->cf_paths,
meta->fd.GetNumber(), meta->fd.GetPathId()); meta->fd.GetNumber(), meta->fd.GetPathId());
// TODO(AR) it is not clear if there are any larger implications if // TODO(AR) it is not clear if there are any larger implications if
@ -1942,7 +1943,7 @@ Status CompactionJob::OpenCompactionOutputFile(
writable_file->SetPreallocationBlockSize(static_cast<size_t>( writable_file->SetPreallocationBlockSize(static_cast<size_t>(
sub_compact->compaction->OutputFilePreallocationSize())); sub_compact->compaction->OutputFilePreallocationSize()));
const auto& listeners = const auto& listeners =
sub_compact->compaction->immutable_cf_options()->listeners; sub_compact->compaction->immutable_options()->listeners;
sub_compact->outfile.reset(new WritableFileWriter( sub_compact->outfile.reset(new WritableFileWriter(
std::move(writable_file), fname, file_options_, db_options_.clock, std::move(writable_file), fname, file_options_, db_options_.clock,
io_tracer_, db_options_.stats, listeners, io_tracer_, db_options_.stats, listeners,
@ -2124,7 +2125,7 @@ void CompactionJob::LogCompaction() {
} }
std::string CompactionJob::GetTableFileName(uint64_t file_number) { std::string CompactionJob::GetTableFileName(uint64_t file_number) {
return TableFileName(compact_->compaction->immutable_cf_options()->cf_paths, return TableFileName(compact_->compaction->immutable_options()->cf_paths,
file_number, compact_->compaction->output_path_id()); file_number, compact_->compaction->output_path_id());
} }

10
db/db_impl/db_impl_compaction_flush.cc
View File

@ -1332,7 +1332,7 @@ Status DBImpl::CompactFilesImpl(
if (output_file_names != nullptr) { if (output_file_names != nullptr) {
for (const auto& newf : c->edit()->GetNewFiles()) { for (const auto& newf : c->edit()->GetNewFiles()) {
(*output_file_names) (*output_file_names)
.push_back(TableFileName(c->immutable_cf_options()->cf_paths, .push_back(TableFileName(c->immutable_options()->cf_paths,
newf.second.fd.GetNumber(), newf.second.fd.GetNumber(),
newf.second.fd.GetPathId())); newf.second.fd.GetPathId()));
} }
@ -2957,7 +2957,7 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
c->column_family_data() c->column_family_data()
->current() ->current()
->storage_info() ->storage_info()
->ComputeCompactionScore(*(c->immutable_cf_options()), ->ComputeCompactionScore(*(c->immutable_options()),
*(c->mutable_cf_options())); *(c->mutable_cf_options()));
AddToCompactionQueue(cfd); AddToCompactionQueue(cfd);
++unscheduled_compactions_; ++unscheduled_compactions_;
@ -3232,7 +3232,7 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
c->column_family_data() c->column_family_data()
->current() ->current()
->storage_info() ->storage_info()
->ComputeCompactionScore(*(c->immutable_cf_options()), ->ComputeCompactionScore(*(c->immutable_options()),
*(c->mutable_cf_options())); *(c->mutable_cf_options()));
if (!cfd->queued_for_compaction()) { if (!cfd->queued_for_compaction()) {
AddToCompactionQueue(cfd); AddToCompactionQueue(cfd);
@ -3397,7 +3397,7 @@ void DBImpl::BuildCompactionJobInfo(
for (const auto fmd : *c->inputs(i)) { for (const auto fmd : *c->inputs(i)) {
const FileDescriptor& desc = fmd->fd; const FileDescriptor& desc = fmd->fd;
const uint64_t file_number = desc.GetNumber(); const uint64_t file_number = desc.GetNumber();
auto fn = TableFileName(c->immutable_cf_options()->cf_paths, file_number, auto fn = TableFileName(c->immutable_options()->cf_paths, file_number,
desc.GetPathId()); desc.GetPathId());
compaction_job_info->input_files.push_back(fn); compaction_job_info->input_files.push_back(fn);
compaction_job_info->input_file_infos.push_back(CompactionFileInfo{ compaction_job_info->input_file_infos.push_back(CompactionFileInfo{
@ -3416,7 +3416,7 @@ void DBImpl::BuildCompactionJobInfo(
const FileDescriptor& desc = meta.fd; const FileDescriptor& desc = meta.fd;
const uint64_t file_number = desc.GetNumber(); const uint64_t file_number = desc.GetNumber();
compaction_job_info->output_files.push_back(TableFileName( compaction_job_info->output_files.push_back(TableFileName(
c->immutable_cf_options()->cf_paths, file_number, desc.GetPathId())); c->immutable_options()->cf_paths, file_number, desc.GetPathId()));
compaction_job_info->output_file_infos.push_back(CompactionFileInfo{ compaction_job_info->output_file_infos.push_back(CompactionFileInfo{
newf.first, file_number, meta.oldest_blob_file_number}); newf.first, file_number, meta.oldest_blob_file_number});
} }

16
db/db_iter.cc
View File

@ -36,7 +36,7 @@
namespace ROCKSDB_NAMESPACE { namespace ROCKSDB_NAMESPACE {
DBIter::DBIter(Env* _env, const ReadOptions& read_options, DBIter::DBIter(Env* _env, const ReadOptions& read_options,
const ImmutableOptions& cf_options, const ImmutableOptions& ioptions,
const MutableCFOptions& mutable_cf_options, const MutableCFOptions& mutable_cf_options,
const Comparator* cmp, InternalIterator* iter, const Comparator* cmp, InternalIterator* iter,
const Version* version, SequenceNumber s, bool arena_mode, const Version* version, SequenceNumber s, bool arena_mode,
@ -45,15 +45,15 @@ DBIter::DBIter(Env* _env, const ReadOptions& read_options,
ColumnFamilyData* cfd, bool expose_blob_index) ColumnFamilyData* cfd, bool expose_blob_index)
: prefix_extractor_(mutable_cf_options.prefix_extractor.get()), : prefix_extractor_(mutable_cf_options.prefix_extractor.get()),
env_(_env), env_(_env),
clock_(cf_options.clock), clock_(ioptions.clock),
logger_(cf_options.logger), logger_(ioptions.logger),
user_comparator_(cmp), user_comparator_(cmp),
merge_operator_(cf_options.merge_operator.get()), merge_operator_(ioptions.merge_operator.get()),
iter_(iter), iter_(iter),
version_(version), version_(version),
read_callback_(read_callback), read_callback_(read_callback),
sequence_(s), sequence_(s),
statistics_(cf_options.stats), statistics_(ioptions.stats),
max_skip_(max_sequential_skip_in_iterations), max_skip_(max_sequential_skip_in_iterations),
max_skippable_internal_keys_(read_options.max_skippable_internal_keys), max_skippable_internal_keys_(read_options.max_skippable_internal_keys),
num_internal_keys_skipped_(0), num_internal_keys_skipped_(0),
@ -75,7 +75,7 @@ DBIter::DBIter(Env* _env, const ReadOptions& read_options,
expose_blob_index_(expose_blob_index), expose_blob_index_(expose_blob_index),
is_blob_(false), is_blob_(false),
arena_mode_(arena_mode), arena_mode_(arena_mode),
range_del_agg_(&cf_options.internal_comparator, s), range_del_agg_(&ioptions.internal_comparator, s),
db_impl_(db_impl), db_impl_(db_impl),
cfd_(cfd), cfd_(cfd),
start_seqnum_(read_options.iter_start_seqnum), start_seqnum_(read_options.iter_start_seqnum),
@ -1578,7 +1578,7 @@ void DBIter::SeekToLast() {
} }
Iterator* NewDBIterator(Env* env, const ReadOptions& read_options, Iterator* NewDBIterator(Env* env, const ReadOptions& read_options,
const ImmutableOptions& cf_options, const ImmutableOptions& ioptions,
const MutableCFOptions& mutable_cf_options, const MutableCFOptions& mutable_cf_options,
const Comparator* user_key_comparator, const Comparator* user_key_comparator,
InternalIterator* internal_iter, const Version* version, InternalIterator* internal_iter, const Version* version,
@ -1587,7 +1587,7 @@ Iterator* NewDBIterator(Env* env, const ReadOptions& read_options,
ReadCallback* read_callback, DBImpl* db_impl, ReadCallback* read_callback, DBImpl* db_impl,
ColumnFamilyData* cfd, bool expose_blob_index) { ColumnFamilyData* cfd, bool expose_blob_index) {
DBIter* db_iter = DBIter* db_iter =
new DBIter(env, read_options, cf_options, mutable_cf_options, new DBIter(env, read_options, ioptions, mutable_cf_options,
user_key_comparator, internal_iter, version, sequence, false, user_key_comparator, internal_iter, version, sequence, false,
max_sequential_skip_in_iterations, read_callback, db_impl, cfd, max_sequential_skip_in_iterations, read_callback, db_impl, cfd,
expose_blob_index); expose_blob_index);

5
db/db_iter.h
View File

@ -114,7 +114,7 @@ class DBIter final : public Iterator {
}; };
DBIter(Env* _env, const ReadOptions& read_options, DBIter(Env* _env, const ReadOptions& read_options,
const ImmutableOptions& cf_options, const ImmutableOptions& ioptions,
const MutableCFOptions& mutable_cf_options, const Comparator* cmp, const MutableCFOptions& mutable_cf_options, const Comparator* cmp,
InternalIterator* iter, const Version* version, SequenceNumber s, InternalIterator* iter, const Version* version, SequenceNumber s,
bool arena_mode, uint64_t max_sequential_skip_in_iterations, bool arena_mode, uint64_t max_sequential_skip_in_iterations,
@ -385,8 +385,7 @@ class DBIter final : public Iterator {
// "*internal_iter") that were live at the specified `sequence` number // "*internal_iter") that were live at the specified `sequence` number
// into appropriate user keys. // into appropriate user keys.
extern Iterator* NewDBIterator( extern Iterator* NewDBIterator(
Env* env, const ReadOptions& read_options, Env* env, const ReadOptions& read_options, const ImmutableOptions& ioptions,
const ImmutableOptions& cf_options,
const MutableCFOptions& mutable_cf_options, const MutableCFOptions& mutable_cf_options,
const Comparator* user_key_comparator, InternalIterator* internal_iter, const Comparator* user_key_comparator, InternalIterator* internal_iter,
const Version* version, const SequenceNumber& sequence, const Version* version, const SequenceNumber& sequence,

124
db/db_iter_test.cc
View File

@ -237,7 +237,7 @@ class DBIteratorTest : public testing::Test {
TEST_F(DBIteratorTest, DBIteratorPrevNext) { TEST_F(DBIteratorTest, DBIteratorPrevNext) {
Options options; Options options;
ImmutableOptions cf_options = ImmutableOptions(options); ImmutableOptions ioptions = ImmutableOptions(options);
MutableCFOptions mutable_cf_options = MutableCFOptions(options); MutableCFOptions mutable_cf_options = MutableCFOptions(options);
{ {
TestIterator* internal_iter = new TestIterator(BytewiseComparator()); TestIterator* internal_iter = new TestIterator(BytewiseComparator());
@ -252,7 +252,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
ReadOptions ro; ReadOptions ro;
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 10 /* sequence */, internal_iter, nullptr /* version */, 10 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -286,7 +286,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
ReadOptions ro; ReadOptions ro;
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 10 /* sequence */, internal_iter, nullptr /* version */, 10 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -314,7 +314,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
ro.iterate_upper_bound = &prefix; ro.iterate_upper_bound = &prefix;
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 10 /* sequence */, internal_iter, nullptr /* version */, 10 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -348,7 +348,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
ro.iterate_upper_bound = &prefix; ro.iterate_upper_bound = &prefix;
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 10 /* sequence */, internal_iter, nullptr /* version */, 10 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -385,7 +385,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
ro.iterate_upper_bound = &prefix; ro.iterate_upper_bound = &prefix;
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 10 /* sequence */, internal_iter, nullptr /* version */, 10 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -417,7 +417,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
ro.iterate_upper_bound = &prefix; ro.iterate_upper_bound = &prefix;
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 7 /* sequence */, internal_iter, nullptr /* version */, 7 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -456,7 +456,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
ro.iterate_upper_bound = &prefix; ro.iterate_upper_bound = &prefix;
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 4 /* sequence */, internal_iter, nullptr /* version */, 4 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -483,7 +483,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
ro.iterate_upper_bound = &prefix; ro.iterate_upper_bound = &prefix;
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 10 /* sequence */, internal_iter, nullptr /* version */, 10 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -508,7 +508,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
ro.iterate_upper_bound = &prefix; ro.iterate_upper_bound = &prefix;
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 10 /* sequence */, internal_iter, nullptr /* version */, 10 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -545,7 +545,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
ro.iterate_upper_bound = &prefix; ro.iterate_upper_bound = &prefix;
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 7 /* sequence */, internal_iter, nullptr /* version */, 7 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -576,7 +576,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
ReadOptions ro; ReadOptions ro;
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 10 /* sequence */, internal_iter, nullptr /* version */, 10 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -621,7 +621,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
ReadOptions ro; ReadOptions ro;
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 2 /* sequence */, internal_iter, nullptr /* version */, 2 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -654,7 +654,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
ReadOptions ro; ReadOptions ro;
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 10 /* sequence */, internal_iter, nullptr /* version */, 10 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -677,7 +677,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
TEST_F(DBIteratorTest, DBIteratorEmpty) { TEST_F(DBIteratorTest, DBIteratorEmpty) {
Options options; Options options;
ImmutableOptions cf_options = ImmutableOptions(options); ImmutableOptions ioptions = ImmutableOptions(options);
MutableCFOptions mutable_cf_options = MutableCFOptions(options); MutableCFOptions mutable_cf_options = MutableCFOptions(options);
ReadOptions ro; ReadOptions ro;
@ -686,7 +686,7 @@ TEST_F(DBIteratorTest, DBIteratorEmpty) {
internal_iter->Finish(); internal_iter->Finish();
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 0 /* sequence */, internal_iter, nullptr /* version */, 0 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -700,7 +700,7 @@ TEST_F(DBIteratorTest, DBIteratorEmpty) {
internal_iter->Finish(); internal_iter->Finish();
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 0 /* sequence */, internal_iter, nullptr /* version */, 0 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -757,7 +757,7 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) {
ReadOptions ro; ReadOptions ro;
Options options; Options options;
options.merge_operator = MergeOperators::CreateFromStringId("stringappend"); options.merge_operator = MergeOperators::CreateFromStringId("stringappend");
ImmutableOptions cf_options = ImmutableOptions(options); ImmutableOptions ioptions = ImmutableOptions(options);
MutableCFOptions mutable_cf_options = MutableCFOptions(options); MutableCFOptions mutable_cf_options = MutableCFOptions(options);
{ {
@ -772,7 +772,7 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) {
options.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics(); options.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, i + 2 /* sequence */, internal_iter, nullptr /* version */, i + 2 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -810,7 +810,7 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) {
internal_iter->Finish(); internal_iter->Finish();
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, i + 2 /* sequence */, internal_iter, nullptr /* version */, i + 2 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -841,7 +841,7 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) {
internal_iter->Finish(); internal_iter->Finish();
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 202 /* sequence */, internal_iter, nullptr /* version */, 202 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -876,7 +876,7 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) {
internal_iter->AddPut("c", "200"); internal_iter->AddPut("c", "200");
internal_iter->Finish(); internal_iter->Finish();
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, i /* sequence */, internal_iter, nullptr /* version */, i /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -896,7 +896,7 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) {
internal_iter->AddPut("c", "200"); internal_iter->AddPut("c", "200");
internal_iter->Finish(); internal_iter->Finish();
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 200 /* sequence */, internal_iter, nullptr /* version */, 200 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -934,7 +934,7 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) {
internal_iter->Finish(); internal_iter->Finish();
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, i + 2 /* sequence */, internal_iter, nullptr /* version */, i + 2 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -971,7 +971,7 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) {
internal_iter->Finish(); internal_iter->Finish();
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, i + 2 /* sequence */, internal_iter, nullptr /* version */, i + 2 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -1004,7 +1004,7 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) {
TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) { TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) {
Options options; Options options;
ImmutableOptions cf_options = ImmutableOptions(options); ImmutableOptions ioptions = ImmutableOptions(options);
MutableCFOptions mutable_cf_options = MutableCFOptions(options); MutableCFOptions mutable_cf_options = MutableCFOptions(options);
ReadOptions ro; ReadOptions ro;
@ -1023,7 +1023,7 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) {
ro.max_skippable_internal_keys = 0; ro.max_skippable_internal_keys = 0;
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 10 /* sequence */, internal_iter, nullptr /* version */, 10 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -1071,7 +1071,7 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) {
ro.max_skippable_internal_keys = 2; ro.max_skippable_internal_keys = 2;
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 10 /* sequence */, internal_iter, nullptr /* version */, 10 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -1117,7 +1117,7 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) {
ro.max_skippable_internal_keys = 2; ro.max_skippable_internal_keys = 2;
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 10 /* sequence */, internal_iter, nullptr /* version */, 10 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -1157,7 +1157,7 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) {
ro.max_skippable_internal_keys = 2; ro.max_skippable_internal_keys = 2;
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 10 /* sequence */, internal_iter, nullptr /* version */, 10 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -1194,7 +1194,7 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) {
ro.max_skippable_internal_keys = 2; ro.max_skippable_internal_keys = 2;
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 10 /* sequence */, internal_iter, nullptr /* version */, 10 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -1226,7 +1226,7 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) {
ro.max_skippable_internal_keys = 2; ro.max_skippable_internal_keys = 2;
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 10 /* sequence */, internal_iter, nullptr /* version */, 10 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -1265,7 +1265,7 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) {
ro.max_skippable_internal_keys = 2; ro.max_skippable_internal_keys = 2;
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 10 /* sequence */, internal_iter, nullptr /* version */, 10 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -1304,7 +1304,7 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) {
ro.max_skippable_internal_keys = i; ro.max_skippable_internal_keys = i;
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 2 * i + 1 /* sequence */, internal_iter, nullptr /* version */, 2 * i + 1 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -1359,7 +1359,7 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) {
options.max_sequential_skip_in_iterations = 1000; options.max_sequential_skip_in_iterations = 1000;
ro.max_skippable_internal_keys = i; ro.max_skippable_internal_keys = i;
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 2 * i + 1 /* sequence */, internal_iter, nullptr /* version */, 2 * i + 1 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -1500,7 +1500,7 @@ TEST_F(DBIteratorTest, DBIterator5) {
ReadOptions ro; ReadOptions ro;
Options options; Options options;
options.merge_operator = MergeOperators::CreateFromStringId("stringappend"); options.merge_operator = MergeOperators::CreateFromStringId("stringappend");
ImmutableOptions cf_options = ImmutableOptions(options); ImmutableOptions ioptions = ImmutableOptions(options);
MutableCFOptions mutable_cf_options = MutableCFOptions(options); MutableCFOptions mutable_cf_options = MutableCFOptions(options);
{ {
@ -1515,7 +1515,7 @@ TEST_F(DBIteratorTest, DBIterator5) {
internal_iter->Finish(); internal_iter->Finish();
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 0 /* sequence */, internal_iter, nullptr /* version */, 0 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -1539,7 +1539,7 @@ TEST_F(DBIteratorTest, DBIterator5) {
internal_iter->Finish(); internal_iter->Finish();
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 1 /* sequence */, internal_iter, nullptr /* version */, 1 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -1563,7 +1563,7 @@ TEST_F(DBIteratorTest, DBIterator5) {
internal_iter->Finish(); internal_iter->Finish();
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 2 /* sequence */, internal_iter, nullptr /* version */, 2 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -1587,7 +1587,7 @@ TEST_F(DBIteratorTest, DBIterator5) {
internal_iter->Finish(); internal_iter->Finish();
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 3 /* sequence */, internal_iter, nullptr /* version */, 3 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -1611,7 +1611,7 @@ TEST_F(DBIteratorTest, DBIterator5) {
internal_iter->Finish(); internal_iter->Finish();
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 4 /* sequence */, internal_iter, nullptr /* version */, 4 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -1635,7 +1635,7 @@ TEST_F(DBIteratorTest, DBIterator5) {
internal_iter->Finish(); internal_iter->Finish();
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 5 /* sequence */, internal_iter, nullptr /* version */, 5 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -1659,7 +1659,7 @@ TEST_F(DBIteratorTest, DBIterator5) {
internal_iter->Finish(); internal_iter->Finish();
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 6 /* sequence */, internal_iter, nullptr /* version */, 6 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -1681,7 +1681,7 @@ TEST_F(DBIteratorTest, DBIterator5) {
internal_iter->AddPut("b", "val_b"); internal_iter->AddPut("b", "val_b");
internal_iter->Finish(); internal_iter->Finish();
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 10 /* sequence */, internal_iter, nullptr /* version */, 10 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -1698,7 +1698,7 @@ TEST_F(DBIteratorTest, DBIterator6) {
ReadOptions ro; ReadOptions ro;
Options options; Options options;
options.merge_operator = MergeOperators::CreateFromStringId("stringappend"); options.merge_operator = MergeOperators::CreateFromStringId("stringappend");
ImmutableOptions cf_options = ImmutableOptions(options); ImmutableOptions ioptions = ImmutableOptions(options);
MutableCFOptions mutable_cf_options = MutableCFOptions(options); MutableCFOptions mutable_cf_options = MutableCFOptions(options);
{ {
@ -1713,7 +1713,7 @@ TEST_F(DBIteratorTest, DBIterator6) {
internal_iter->Finish(); internal_iter->Finish();
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 0 /* sequence */, internal_iter, nullptr /* version */, 0 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -1737,7 +1737,7 @@ TEST_F(DBIteratorTest, DBIterator6) {
internal_iter->Finish(); internal_iter->Finish();
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 1 /* sequence */, internal_iter, nullptr /* version */, 1 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -1761,7 +1761,7 @@ TEST_F(DBIteratorTest, DBIterator6) {
internal_iter->Finish(); internal_iter->Finish();
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 2 /* sequence */, internal_iter, nullptr /* version */, 2 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -1785,7 +1785,7 @@ TEST_F(DBIteratorTest, DBIterator6) {
internal_iter->Finish(); internal_iter->Finish();
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 3 /* sequence */, internal_iter, nullptr /* version */, 3 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -1805,7 +1805,7 @@ TEST_F(DBIteratorTest, DBIterator6) {
internal_iter->Finish(); internal_iter->Finish();
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 4 /* sequence */, internal_iter, nullptr /* version */, 4 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -1829,7 +1829,7 @@ TEST_F(DBIteratorTest, DBIterator6) {
internal_iter->Finish(); internal_iter->Finish();
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 5 /* sequence */, internal_iter, nullptr /* version */, 5 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -1853,7 +1853,7 @@ TEST_F(DBIteratorTest, DBIterator6) {
internal_iter->Finish(); internal_iter->Finish();
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 6 /* sequence */, internal_iter, nullptr /* version */, 6 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -1870,7 +1870,7 @@ TEST_F(DBIteratorTest, DBIterator7) {
ReadOptions ro; ReadOptions ro;
Options options; Options options;
options.merge_operator = MergeOperators::CreateFromStringId("stringappend"); options.merge_operator = MergeOperators::CreateFromStringId("stringappend");
ImmutableOptions cf_options = ImmutableOptions(options); ImmutableOptions ioptions = ImmutableOptions(options);
MutableCFOptions mutable_cf_options = MutableCFOptions(options); MutableCFOptions mutable_cf_options = MutableCFOptions(options);
{ {
@ -1897,7 +1897,7 @@ TEST_F(DBIteratorTest, DBIterator7) {
internal_iter->Finish(); internal_iter->Finish();
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 0 /* sequence */, internal_iter, nullptr /* version */, 0 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -1933,7 +1933,7 @@ TEST_F(DBIteratorTest, DBIterator7) {
internal_iter->Finish(); internal_iter->Finish();
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 2 /* sequence */, internal_iter, nullptr /* version */, 2 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -1975,7 +1975,7 @@ TEST_F(DBIteratorTest, DBIterator7) {
internal_iter->Finish(); internal_iter->Finish();
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 4 /* sequence */, internal_iter, nullptr /* version */, 4 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -2017,7 +2017,7 @@ TEST_F(DBIteratorTest, DBIterator7) {
internal_iter->Finish(); internal_iter->Finish();
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 5 /* sequence */, internal_iter, nullptr /* version */, 5 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -2064,7 +2064,7 @@ TEST_F(DBIteratorTest, DBIterator7) {
internal_iter->Finish(); internal_iter->Finish();
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 6 /* sequence */, internal_iter, nullptr /* version */, 6 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -2112,7 +2112,7 @@ TEST_F(DBIteratorTest, DBIterator7) {
internal_iter->Finish(); internal_iter->Finish();
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 7 /* sequence */, internal_iter, nullptr /* version */, 7 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -2154,7 +2154,7 @@ TEST_F(DBIteratorTest, DBIterator7) {
internal_iter->Finish(); internal_iter->Finish();
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 9 /* sequence */, internal_iter, nullptr /* version */, 9 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -2202,7 +2202,7 @@ TEST_F(DBIteratorTest, DBIterator7) {
internal_iter->Finish(); internal_iter->Finish();
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 13 /* sequence */, internal_iter, nullptr /* version */, 13 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));
@ -2251,7 +2251,7 @@ TEST_F(DBIteratorTest, DBIterator7) {
internal_iter->Finish(); internal_iter->Finish();
std::unique_ptr<Iterator> db_iter(NewDBIterator( std::unique_ptr<Iterator> db_iter(NewDBIterator(
env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
internal_iter, nullptr /* version */, 14 /* sequence */, internal_iter, nullptr /* version */, 14 /* sequence */,
options.max_sequential_skip_in_iterations, options.max_sequential_skip_in_iterations,
nullptr /* read_callback */)); nullptr /* read_callback */));

6
db/job_context.h
View File

@ -23,7 +23,7 @@ struct SuperVersion;
struct SuperVersionContext { struct SuperVersionContext {
struct WriteStallNotification { struct WriteStallNotification {
WriteStallInfo write_stall_info; WriteStallInfo write_stall_info;
const ImmutableOptions* immutable_cf_options; const ImmutableOptions* immutable_options;
}; };
autovector<SuperVersion*> superversions_to_free; autovector<SuperVersion*> superversions_to_free;
@ -66,7 +66,7 @@ struct SuperVersionContext {
notif.write_stall_info.cf_name = name; notif.write_stall_info.cf_name = name;
notif.write_stall_info.condition.prev = old_cond; notif.write_stall_info.condition.prev = old_cond;
notif.write_stall_info.condition.cur = new_cond; notif.write_stall_info.condition.cur = new_cond;
notif.immutable_cf_options = ioptions; notif.immutable_options = ioptions;
write_stall_notifications.push_back(notif); write_stall_notifications.push_back(notif);
#else #else
(void)old_cond; (void)old_cond;
@ -80,7 +80,7 @@ struct SuperVersionContext {
#if !defined(ROCKSDB_LITE) && !defined(ROCKSDB_DISABLE_STALL_NOTIFICATION) #if !defined(ROCKSDB_LITE) && !defined(ROCKSDB_DISABLE_STALL_NOTIFICATION)
// notify listeners on changed write stall conditions // notify listeners on changed write stall conditions
for (auto& notif : write_stall_notifications) { for (auto& notif : write_stall_notifications) {
for (auto& listener : notif.immutable_cf_options->listeners) { for (auto& listener : notif.immutable_options->listeners) {
listener->OnStallConditionsChanged(notif.write_stall_info); listener->OnStallConditionsChanged(notif.write_stall_info);
} }
} }

10
db/version_set.cc
View File

@ -2554,7 +2554,7 @@ uint32_t GetExpiredTtlFilesCount(const ImmutableOptions& ioptions,
} // anonymous namespace } // anonymous namespace
void VersionStorageInfo::ComputeCompactionScore( void VersionStorageInfo::ComputeCompactionScore(
const ImmutableOptions& immutable_cf_options, const ImmutableOptions& immutable_options,
const MutableCFOptions& mutable_cf_options) { const MutableCFOptions& mutable_cf_options) {
for (int level = 0; level <= MaxInputLevel(); level++) { for (int level = 0; level <= MaxInputLevel(); level++) {
double score; double score;
@ -2606,7 +2606,7 @@ void VersionStorageInfo::ComputeCompactionScore(
if (mutable_cf_options.ttl > 0) { if (mutable_cf_options.ttl > 0) {
score = std::max( score = std::max(
static_cast<double>(GetExpiredTtlFilesCount( static_cast<double>(GetExpiredTtlFilesCount(
immutable_cf_options, mutable_cf_options, files_[level])), immutable_options, mutable_cf_options, files_[level])),
score); score);
} }
@ -2618,7 +2618,7 @@ void VersionStorageInfo::ComputeCompactionScore(
// L0 files. Take into account size as well to avoid later giant // L0 files. Take into account size as well to avoid later giant
// compactions to the base level. // compactions to the base level.
uint64_t l0_target_size = mutable_cf_options.max_bytes_for_level_base; uint64_t l0_target_size = mutable_cf_options.max_bytes_for_level_base;
if (immutable_cf_options.level_compaction_dynamic_level_bytes && if (immutable_options.level_compaction_dynamic_level_bytes &&
level_multiplier_ != 0.0) { level_multiplier_ != 0.0) {
// Prevent L0 to Lbase fanout from growing larger than // Prevent L0 to Lbase fanout from growing larger than
// `level_multiplier_`. This prevents us from getting stuck picking // `level_multiplier_`. This prevents us from getting stuck picking
@ -2666,11 +2666,11 @@ void VersionStorageInfo::ComputeCompactionScore(
ComputeFilesMarkedForCompaction(); ComputeFilesMarkedForCompaction();
ComputeBottommostFilesMarkedForCompaction(); ComputeBottommostFilesMarkedForCompaction();
if (mutable_cf_options.ttl > 0) { if (mutable_cf_options.ttl > 0) {
ComputeExpiredTtlFiles(immutable_cf_options, mutable_cf_options.ttl); ComputeExpiredTtlFiles(immutable_options, mutable_cf_options.ttl);
} }
if (mutable_cf_options.periodic_compaction_seconds > 0) { if (mutable_cf_options.periodic_compaction_seconds > 0) {
ComputeFilesMarkedForPeriodicCompaction( ComputeFilesMarkedForPeriodicCompaction(
immutable_cf_options, mutable_cf_options.periodic_compaction_seconds); immutable_options, mutable_cf_options.periodic_compaction_seconds);
} }
EstimateCompactionBytesNeeded(mutable_cf_options); EstimateCompactionBytesNeeded(mutable_cf_options);
} }

2
db/version_set.h
View File

@ -150,7 +150,7 @@ class VersionStorageInfo {
// We use compaction scores to figure out which compaction to do next // We use compaction scores to figure out which compaction to do next
// REQUIRES: db_mutex held!! // REQUIRES: db_mutex held!!
// TODO find a better way to pass compaction_options_fifo. // TODO find a better way to pass compaction_options_fifo.
void ComputeCompactionScore(const ImmutableOptions& immutable_cf_options, void ComputeCompactionScore(const ImmutableOptions& immutable_options,
const MutableCFOptions& mutable_cf_options); const MutableCFOptions& mutable_cf_options);
// Estimate est_comp_needed_bytes_ // Estimate est_comp_needed_bytes_

12
db/version_set_test.cc
View File

@ -699,7 +699,7 @@ class VersionSetTestBase {
options_(), options_(),
db_options_(options_), db_options_(options_),
cf_options_(options_), cf_options_(options_),
immutable_cf_options_(db_options_, cf_options_), immutable_options_(db_options_, cf_options_),
mutable_cf_options_(cf_options_), mutable_cf_options_(cf_options_),
table_cache_(NewLRUCache(50000, 16)), table_cache_(NewLRUCache(50000, 16)),
write_buffer_manager_(db_options_.db_write_buffer_size), write_buffer_manager_(db_options_.db_write_buffer_size),
@ -718,9 +718,9 @@ class VersionSetTestBase {
options_.env = env_; options_.env = env_;
db_options_.env = env_; db_options_.env = env_;
db_options_.fs = fs_; db_options_.fs = fs_;
immutable_cf_options_.env = env_; immutable_options_.env = env_;
immutable_cf_options_.fs = fs_; immutable_options_.fs = fs_;
immutable_cf_options_.clock = env_->GetSystemClock().get(); immutable_options_.clock = env_->GetSystemClock().get();
versions_.reset( versions_.reset(
new VersionSet(dbname_, &db_options_, env_options_, table_cache_.get(), new VersionSet(dbname_, &db_options_, env_options_, table_cache_.get(),
@ -908,7 +908,7 @@ class VersionSetTestBase {
Options options_; Options options_;
ImmutableDBOptions db_options_; ImmutableDBOptions db_options_;
ColumnFamilyOptions cf_options_; ColumnFamilyOptions cf_options_;
ImmutableOptions immutable_cf_options_; ImmutableOptions immutable_options_;
MutableCFOptions mutable_cf_options_; MutableCFOptions mutable_cf_options_;
std::shared_ptr<Cache> table_cache_; std::shared_ptr<Cache> table_cache_;
WriteController write_controller_; WriteController write_controller_;
@ -2785,7 +2785,7 @@ class VersionSetTestMissingFiles : public VersionSetTestBase,
std::unique_ptr<TableBuilder> builder(table_factory_->NewTableBuilder( std::unique_ptr<TableBuilder> builder(table_factory_->NewTableBuilder(
TableBuilderOptions( TableBuilderOptions(
immutable_cf_options_, mutable_cf_options_, *internal_comparator_, immutable_options_, mutable_cf_options_, *internal_comparator_,
&int_tbl_prop_collector_factories, kNoCompression, &int_tbl_prop_collector_factories, kNoCompression,
CompressionOptions(), CompressionOptions(),
TablePropertiesCollectorFactory::Context::kUnknownColumnFamily, TablePropertiesCollectorFactory::Context::kUnknownColumnFamily,