NextGraph
/
rocksdb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update test to cover a new case in file ingestion (#4614)

Browse Source 
Summary:
The new case is directIO = true, write_global_seqno = false in which we no longer write global_seqno to the external SST file.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/4614

Differential Revision: D12885001

Pulled By: riversand963

fbshipit-source-id: 7541bdc608b3a0c93d3c3c435da1b162b36673d4
main
Yanqin Jin 6 years ago committed by Facebook Github Bot
parent 3f8f81cfeb
commit de18a2d82e
4 changed files with 234 additions and 137 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 41
      db/db_test_util.cc
  2. 3
      db/db_test_util.h
  3. 206
      db/external_sst_file_basic_test.cc
  4. 121
      db/external_sst_file_test.cc

41
db/db_test_util.cc
Unescape View File

@ -259,6 +259,47 @@ bool DBTestBase::ChangeFilterOptions() {
return true; return true;
} }
// Switch between different DB options for file ingestion tests.
bool DBTestBase::ChangeOptionsForFileIngestionTest() {
if (option_config_ == kDefault) {
option_config_ = kUniversalCompaction;
Destroy(last_options_);
auto options = CurrentOptions();
options.create_if_missing = true;
TryReopen(options);
return true;
} else if (option_config_ == kUniversalCompaction) {
option_config_ = kUniversalCompactionMultiLevel;
Destroy(last_options_);
auto options = CurrentOptions();
options.create_if_missing = true;
TryReopen(options);
return true;
} else if (option_config_ == kUniversalCompactionMultiLevel) {
option_config_ = kLevelSubcompactions;
Destroy(last_options_);
auto options = CurrentOptions();
assert(options.max_subcompactions > 1);
TryReopen(options);
return true;
} else if (option_config_ == kLevelSubcompactions) {
option_config_ = kUniversalSubcompactions;
Destroy(last_options_);
auto options = CurrentOptions();
assert(options.max_subcompactions > 1);
TryReopen(options);
return true;
} else if (option_config_ == kUniversalSubcompactions) {
option_config_ = kDirectIO;
Destroy(last_options_);
auto options = CurrentOptions();
TryReopen(options);
return true;
} else {
return false;
}
}
// Return the current option configuration. // Return the current option configuration.
Options DBTestBase::CurrentOptions( Options DBTestBase::CurrentOptions(
const anon::OptionsOverride& options_override) const { const anon::OptionsOverride& options_override) const {

3
db/db_test_util.h
Unescape View File

@ -747,6 +747,9 @@ class DBTestBase : public testing::Test {
// Jump from kDefault to kFilter to kFullFilter // Jump from kDefault to kFilter to kFullFilter
bool ChangeFilterOptions(); bool ChangeFilterOptions();
// Switch between different DB options for file ingestion tests.
bool ChangeOptionsForFileIngestionTest();
// Return the current option configuration. // Return the current option configuration.
Options CurrentOptions(const anon::OptionsOverride& options_override = Options CurrentOptions(const anon::OptionsOverride& options_override =
anon::OptionsOverride()) const; anon::OptionsOverride()) const;

206
db/external_sst_file_basic_test.cc
Unescape View File

@ -14,7 +14,8 @@
namespace rocksdb { namespace rocksdb {
#ifndef ROCKSDB_LITE #ifndef ROCKSDB_LITE
class ExternalSSTFileBasicTest : public DBTestBase { class ExternalSSTFileBasicTest : public DBTestBase,
public ::testing::WithParamInterface<bool> {
public: public:
ExternalSSTFileBasicTest() : DBTestBase("/external_sst_file_test") { ExternalSSTFileBasicTest() : DBTestBase("/external_sst_file_test") {
sst_files_dir_ = dbname_ + "/sst_files/"; sst_files_dir_ = dbname_ + "/sst_files/";
@ -41,7 +42,7 @@ class ExternalSSTFileBasicTest : public DBTestBase {
const Options options, std::vector<int> keys, const Options options, std::vector<int> keys,
const std::vector<ValueType>& value_types, const std::vector<ValueType>& value_types,
std::vector<std::pair<int, int>> range_deletions, int file_id, std::vector<std::pair<int, int>> range_deletions, int file_id,
std::map<std::string, std::string>* true_data) { bool write_global_seqno, std::map<std::string, std::string>* true_data) {
assert(value_types.size() == 1 || keys.size() == value_types.size()); assert(value_types.size() == 1 || keys.size() == value_types.size());
std::string file_path = sst_files_dir_ + ToString(file_id); std::string file_path = sst_files_dir_ + ToString(file_id);
SstFileWriter sst_file_writer(EnvOptions(), options); SstFileWriter sst_file_writer(EnvOptions(), options);
@ -105,6 +106,7 @@ class ExternalSSTFileBasicTest : public DBTestBase {
if (s.ok()) { if (s.ok()) {
IngestExternalFileOptions ifo; IngestExternalFileOptions ifo;
ifo.allow_global_seqno = true; ifo.allow_global_seqno = true;
ifo.write_global_seqno = write_global_seqno;
s = db_->IngestExternalFile({file_path}, ifo); s = db_->IngestExternalFile({file_path}, ifo);
} }
return s; return s;
@ -113,17 +115,18 @@ class ExternalSSTFileBasicTest : public DBTestBase {
Status GenerateAndAddExternalFile( Status GenerateAndAddExternalFile(
const Options options, std::vector<int> keys, const Options options, std::vector<int> keys,
const std::vector<ValueType>& value_types, int file_id, const std::vector<ValueType>& value_types, int file_id,
std::map<std::string, std::string>* true_data) { bool write_global_seqno, std::map<std::string, std::string>* true_data) {
return GenerateAndAddExternalFile(options, keys, value_types, {}, file_id, return GenerateAndAddExternalFile(options, keys, value_types, {}, file_id,
true_data); write_global_seqno, true_data);
} }
Status GenerateAndAddExternalFile( Status GenerateAndAddExternalFile(
const Options options, std::vector<int> keys, const ValueType value_type, const Options options, std::vector<int> keys, const ValueType value_type,
int file_id, std::map<std::string, std::string>* true_data) { int file_id, bool write_global_seqno,
std::map<std::string, std::string>* true_data) {
return GenerateAndAddExternalFile(options, keys, return GenerateAndAddExternalFile(options, keys,
std::vector<ValueType>(1, value_type), std::vector<ValueType>(1, value_type),
file_id, true_data); file_id, write_global_seqno, true_data);
} }
~ExternalSSTFileBasicTest() { test::DestroyDir(env_, sst_files_dir_); } ~ExternalSSTFileBasicTest() { test::DestroyDir(env_, sst_files_dir_); }
@ -245,7 +248,8 @@ TEST_F(ExternalSSTFileBasicTest, NoCopy) {
} }
} }
TEST_F(ExternalSSTFileBasicTest, IngestFileWithGlobalSeqnoPickedSeqno) { TEST_P(ExternalSSTFileBasicTest, IngestFileWithGlobalSeqnoPickedSeqno) {
bool write_global_seqno = GetParam();
do { do {
Options options = CurrentOptions(); Options options = CurrentOptions();
DestroyAndReopen(options); DestroyAndReopen(options);
@ -255,33 +259,37 @@ TEST_F(ExternalSSTFileBasicTest, IngestFileWithGlobalSeqnoPickedSeqno) {
ASSERT_OK(GenerateAndAddExternalFile(options, {1, 2, 3, 4, 5, 6}, ASSERT_OK(GenerateAndAddExternalFile(options, {1, 2, 3, 4, 5, 6},
ValueType::kTypeValue, file_id++, ValueType::kTypeValue, file_id++,
&true_data)); write_global_seqno, &true_data));
// File doesn't overwrite any keys, no seqno needed // File doesn't overwrite any keys, no seqno needed
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 0); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 0);
ASSERT_OK(GenerateAndAddExternalFile(options, {10, 11, 12, 13}, ASSERT_OK(GenerateAndAddExternalFile(options, {10, 11, 12, 13},
ValueType::kTypeValue, file_id++, ValueType::kTypeValue, file_id++,
&true_data)); write_global_seqno, &true_data));
// File doesn't overwrite any keys, no seqno needed // File doesn't overwrite any keys, no seqno needed
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 0); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 0);
ASSERT_OK(GenerateAndAddExternalFile( ASSERT_OK(GenerateAndAddExternalFile(options, {1, 4, 6},
options, {1, 4, 6}, ValueType::kTypeValue, file_id++, &true_data)); ValueType::kTypeValue, file_id++,
write_global_seqno, &true_data));
// File overwrites some keys, a seqno will be assigned // File overwrites some keys, a seqno will be assigned
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 1); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 1);
ASSERT_OK(GenerateAndAddExternalFile( ASSERT_OK(GenerateAndAddExternalFile(options, {11, 15, 19},
options, {11, 15, 19}, ValueType::kTypeValue, file_id++, &true_data)); ValueType::kTypeValue, file_id++,
write_global_seqno, &true_data));
// File overwrites some keys, a seqno will be assigned // File overwrites some keys, a seqno will be assigned
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 2); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 2);
ASSERT_OK(GenerateAndAddExternalFile( ASSERT_OK(GenerateAndAddExternalFile(options, {120, 130},
options, {120, 130}, ValueType::kTypeValue, file_id++, &true_data)); ValueType::kTypeValue, file_id++,
write_global_seqno, &true_data));
// File doesn't overwrite any keys, no seqno needed // File doesn't overwrite any keys, no seqno needed
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 2); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 2);
ASSERT_OK(GenerateAndAddExternalFile( ASSERT_OK(GenerateAndAddExternalFile(options, {1, 130},
options, {1, 130}, ValueType::kTypeValue, file_id++, &true_data)); ValueType::kTypeValue, file_id++,
write_global_seqno, &true_data));
// File overwrites some keys, a seqno will be assigned // File overwrites some keys, a seqno will be assigned
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 3); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 3);
@ -292,18 +300,21 @@ TEST_F(ExternalSSTFileBasicTest, IngestFileWithGlobalSeqnoPickedSeqno) {
} }
SequenceNumber last_seqno = dbfull()->GetLatestSequenceNumber(); SequenceNumber last_seqno = dbfull()->GetLatestSequenceNumber();
ASSERT_OK(GenerateAndAddExternalFile( ASSERT_OK(GenerateAndAddExternalFile(options, {60, 61, 62},
options, {60, 61, 62}, ValueType::kTypeValue, file_id++, &true_data)); ValueType::kTypeValue, file_id++,
write_global_seqno, &true_data));
// File doesn't overwrite any keys, no seqno needed // File doesn't overwrite any keys, no seqno needed
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno);
ASSERT_OK(GenerateAndAddExternalFile( ASSERT_OK(GenerateAndAddExternalFile(options, {40, 41, 42},
options, {40, 41, 42}, ValueType::kTypeValue, file_id++, &true_data)); ValueType::kTypeValue, file_id++,
write_global_seqno, &true_data));
// File overwrites some keys, a seqno will be assigned // File overwrites some keys, a seqno will be assigned
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 1); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 1);
ASSERT_OK(GenerateAndAddExternalFile( ASSERT_OK(GenerateAndAddExternalFile(options, {20, 30, 40},
options, {20, 30, 40}, ValueType::kTypeValue, file_id++, &true_data)); ValueType::kTypeValue, file_id++,
write_global_seqno, &true_data));
// File overwrites some keys, a seqno will be assigned // File overwrites some keys, a seqno will be assigned
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 2); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 2);
@ -311,35 +322,39 @@ TEST_F(ExternalSSTFileBasicTest, IngestFileWithGlobalSeqnoPickedSeqno) {
// We will need a seqno for the file regardless if the file overwrite // We will need a seqno for the file regardless if the file overwrite
// keys in the DB or not because we have a snapshot // keys in the DB or not because we have a snapshot
ASSERT_OK(GenerateAndAddExternalFile( ASSERT_OK(GenerateAndAddExternalFile(options, {1000, 1002},
options, {1000, 1002}, ValueType::kTypeValue, file_id++, &true_data)); ValueType::kTypeValue, file_id++,
write_global_seqno, &true_data));
// A global seqno will be assigned anyway because of the snapshot // A global seqno will be assigned anyway because of the snapshot
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 3); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 3);
ASSERT_OK(GenerateAndAddExternalFile( ASSERT_OK(GenerateAndAddExternalFile(options, {2000, 3002},
options, {2000, 3002}, ValueType::kTypeValue, file_id++, &true_data)); ValueType::kTypeValue, file_id++,
write_global_seqno, &true_data));
// A global seqno will be assigned anyway because of the snapshot // A global seqno will be assigned anyway because of the snapshot
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 4); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 4);
ASSERT_OK(GenerateAndAddExternalFile(options, {1, 20, 40, 100, 150}, ASSERT_OK(GenerateAndAddExternalFile(options, {1, 20, 40, 100, 150},
ValueType::kTypeValue, file_id++, ValueType::kTypeValue, file_id++,
&true_data)); write_global_seqno, &true_data));
// A global seqno will be assigned anyway because of the snapshot // A global seqno will be assigned anyway because of the snapshot
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 5); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 5);
db_->ReleaseSnapshot(snapshot); db_->ReleaseSnapshot(snapshot);
ASSERT_OK(GenerateAndAddExternalFile( ASSERT_OK(GenerateAndAddExternalFile(options, {5000, 5001},
options, {5000, 5001}, ValueType::kTypeValue, file_id++, &true_data)); ValueType::kTypeValue, file_id++,
write_global_seqno, &true_data));
// No snapshot anymore, no need to assign a seqno // No snapshot anymore, no need to assign a seqno
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 5); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 5);
size_t kcnt = 0; size_t kcnt = 0;
VerifyDBFromMap(true_data, &kcnt, false); VerifyDBFromMap(true_data, &kcnt, false);
} while (ChangeCompactOptions()); } while (ChangeOptionsForFileIngestionTest());
} }
TEST_F(ExternalSSTFileBasicTest, IngestFileWithMultipleValueType) { TEST_P(ExternalSSTFileBasicTest, IngestFileWithMultipleValueType) {
bool write_global_seqno = GetParam();
do { do {
Options options = CurrentOptions(); Options options = CurrentOptions();
options.merge_operator.reset(new TestPutOperator()); options.merge_operator.reset(new TestPutOperator());
@ -350,52 +365,57 @@ TEST_F(ExternalSSTFileBasicTest, IngestFileWithMultipleValueType) {
ASSERT_OK(GenerateAndAddExternalFile(options, {1, 2, 3, 4, 5, 6}, ASSERT_OK(GenerateAndAddExternalFile(options, {1, 2, 3, 4, 5, 6},
ValueType::kTypeValue, file_id++, ValueType::kTypeValue, file_id++,
&true_data)); write_global_seqno, &true_data));
// File doesn't overwrite any keys, no seqno needed // File doesn't overwrite any keys, no seqno needed
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 0); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 0);
ASSERT_OK(GenerateAndAddExternalFile(options, {10, 11, 12, 13}, ASSERT_OK(GenerateAndAddExternalFile(options, {10, 11, 12, 13},
ValueType::kTypeValue, file_id++, ValueType::kTypeValue, file_id++,
&true_data)); write_global_seqno, &true_data));
// File doesn't overwrite any keys, no seqno needed // File doesn't overwrite any keys, no seqno needed
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 0); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 0);
ASSERT_OK(GenerateAndAddExternalFile( ASSERT_OK(GenerateAndAddExternalFile(options, {1, 4, 6},
options, {1, 4, 6}, ValueType::kTypeMerge, file_id++, &true_data)); ValueType::kTypeMerge, file_id++,
write_global_seqno, &true_data));
// File overwrites some keys, a seqno will be assigned // File overwrites some keys, a seqno will be assigned
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 1); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 1);
ASSERT_OK(GenerateAndAddExternalFile(options, {11, 15, 19}, ASSERT_OK(GenerateAndAddExternalFile(options, {11, 15, 19},
ValueType::kTypeDeletion, file_id++, ValueType::kTypeDeletion, file_id++,
&true_data)); write_global_seqno, &true_data));
// File overwrites some keys, a seqno will be assigned // File overwrites some keys, a seqno will be assigned
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 2); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 2);
ASSERT_OK(GenerateAndAddExternalFile( ASSERT_OK(GenerateAndAddExternalFile(options, {120, 130},
options, {120, 130}, ValueType::kTypeMerge, file_id++, &true_data)); ValueType::kTypeMerge, file_id++,
write_global_seqno, &true_data));
// File doesn't overwrite any keys, no seqno needed // File doesn't overwrite any keys, no seqno needed
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 2); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 2);
ASSERT_OK(GenerateAndAddExternalFile( ASSERT_OK(GenerateAndAddExternalFile(options, {1, 130},
options, {1, 130}, ValueType::kTypeDeletion, file_id++, &true_data)); ValueType::kTypeDeletion, file_id++,
write_global_seqno, &true_data));
// File overwrites some keys, a seqno will be assigned // File overwrites some keys, a seqno will be assigned
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 3); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 3);
ASSERT_OK(GenerateAndAddExternalFile(options, {120}, ASSERT_OK(GenerateAndAddExternalFile(
{ValueType::kTypeValue}, {{120, 135}}, options, {120}, {ValueType::kTypeValue}, {{120, 135}}, file_id++,
file_id++, &true_data)); write_global_seqno, &true_data));
// File overwrites some keys, a seqno will be assigned // File overwrites some keys, a seqno will be assigned
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 4); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 4);
ASSERT_OK(GenerateAndAddExternalFile(options, {}, {}, {{110, 120}}, ASSERT_OK(GenerateAndAddExternalFile(options, {}, {}, {{110, 120}},
file_id++, &true_data)); file_id++, write_global_seqno,
&true_data));
// The range deletion ends on a key, but it doesn't actually delete // The range deletion ends on a key, but it doesn't actually delete
// this key because the largest key in the range is exclusive. Still, // this key because the largest key in the range is exclusive. Still,
// it counts as an overlap so a new seqno will be assigned. // it counts as an overlap so a new seqno will be assigned.
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 5); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 5);
ASSERT_OK(GenerateAndAddExternalFile(options, {}, {}, {{100, 109}}, ASSERT_OK(GenerateAndAddExternalFile(options, {}, {}, {{100, 109}},
file_id++, &true_data)); file_id++, write_global_seqno,
&true_data));
// File doesn't overwrite any keys, no seqno needed // File doesn't overwrite any keys, no seqno needed
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 5); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 5);
@ -406,19 +426,21 @@ TEST_F(ExternalSSTFileBasicTest, IngestFileWithMultipleValueType) {
} }
SequenceNumber last_seqno = dbfull()->GetLatestSequenceNumber(); SequenceNumber last_seqno = dbfull()->GetLatestSequenceNumber();
ASSERT_OK(GenerateAndAddExternalFile( ASSERT_OK(GenerateAndAddExternalFile(options, {60, 61, 62},
options, {60, 61, 62}, ValueType::kTypeValue, file_id++, &true_data)); ValueType::kTypeValue, file_id++,
write_global_seqno, &true_data));
// File doesn't overwrite any keys, no seqno needed // File doesn't overwrite any keys, no seqno needed
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno);
ASSERT_OK(GenerateAndAddExternalFile( ASSERT_OK(GenerateAndAddExternalFile(options, {40, 41, 42},
options, {40, 41, 42}, ValueType::kTypeMerge, file_id++, &true_data)); ValueType::kTypeMerge, file_id++,
write_global_seqno, &true_data));
// File overwrites some keys, a seqno will be assigned // File overwrites some keys, a seqno will be assigned
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 1); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 1);
ASSERT_OK(GenerateAndAddExternalFile(options, {20, 30, 40}, ASSERT_OK(GenerateAndAddExternalFile(options, {20, 30, 40},
ValueType::kTypeDeletion, file_id++, ValueType::kTypeDeletion, file_id++,
&true_data)); write_global_seqno, &true_data));
// File overwrites some keys, a seqno will be assigned // File overwrites some keys, a seqno will be assigned
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 2); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 2);
@ -426,35 +448,39 @@ TEST_F(ExternalSSTFileBasicTest, IngestFileWithMultipleValueType) {
// We will need a seqno for the file regardless if the file overwrite // We will need a seqno for the file regardless if the file overwrite
// keys in the DB or not because we have a snapshot // keys in the DB or not because we have a snapshot
ASSERT_OK(GenerateAndAddExternalFile( ASSERT_OK(GenerateAndAddExternalFile(options, {1000, 1002},
options, {1000, 1002}, ValueType::kTypeMerge, file_id++, &true_data)); ValueType::kTypeMerge, file_id++,
write_global_seqno, &true_data));
// A global seqno will be assigned anyway because of the snapshot // A global seqno will be assigned anyway because of the snapshot
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 3); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 3);
ASSERT_OK(GenerateAndAddExternalFile( ASSERT_OK(GenerateAndAddExternalFile(options, {2000, 3002},
options, {2000, 3002}, ValueType::kTypeMerge, file_id++, &true_data)); ValueType::kTypeMerge, file_id++,
write_global_seqno, &true_data));
// A global seqno will be assigned anyway because of the snapshot // A global seqno will be assigned anyway because of the snapshot
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 4); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 4);
ASSERT_OK(GenerateAndAddExternalFile(options, {1, 20, 40, 100, 150}, ASSERT_OK(GenerateAndAddExternalFile(options, {1, 20, 40, 100, 150},
ValueType::kTypeMerge, file_id++, ValueType::kTypeMerge, file_id++,
&true_data)); write_global_seqno, &true_data));
// A global seqno will be assigned anyway because of the snapshot // A global seqno will be assigned anyway because of the snapshot
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 5); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 5);
db_->ReleaseSnapshot(snapshot); db_->ReleaseSnapshot(snapshot);
ASSERT_OK(GenerateAndAddExternalFile( ASSERT_OK(GenerateAndAddExternalFile(options, {5000, 5001},
options, {5000, 5001}, ValueType::kTypeValue, file_id++, &true_data)); ValueType::kTypeValue, file_id++,
write_global_seqno, &true_data));
// No snapshot anymore, no need to assign a seqno // No snapshot anymore, no need to assign a seqno
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 5); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 5);
size_t kcnt = 0; size_t kcnt = 0;
VerifyDBFromMap(true_data, &kcnt, false); VerifyDBFromMap(true_data, &kcnt, false);
} while (ChangeCompactOptions()); } while (ChangeOptionsForFileIngestionTest());
} }
TEST_F(ExternalSSTFileBasicTest, IngestFileWithMixedValueType) { TEST_P(ExternalSSTFileBasicTest, IngestFileWithMixedValueType) {
bool write_global_seqno = GetParam();
do { do {
Options options = CurrentOptions(); Options options = CurrentOptions();
options.merge_operator.reset(new TestPutOperator()); options.merge_operator.reset(new TestPutOperator());
@ -467,7 +493,7 @@ TEST_F(ExternalSSTFileBasicTest, IngestFileWithMixedValueType) {
options, {1, 2, 3, 4, 5, 6}, options, {1, 2, 3, 4, 5, 6},
{ValueType::kTypeValue, ValueType::kTypeMerge, ValueType::kTypeValue, {ValueType::kTypeValue, ValueType::kTypeMerge, ValueType::kTypeValue,
ValueType::kTypeMerge, ValueType::kTypeValue, ValueType::kTypeMerge}, ValueType::kTypeMerge, ValueType::kTypeValue, ValueType::kTypeMerge},
file_id++, &true_data)); file_id++, write_global_seqno, &true_data));
// File doesn't overwrite any keys, no seqno needed // File doesn't overwrite any keys, no seqno needed
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 0); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 0);
@ -475,33 +501,35 @@ TEST_F(ExternalSSTFileBasicTest, IngestFileWithMixedValueType) {
options, {10, 11, 12, 13}, options, {10, 11, 12, 13},
{ValueType::kTypeValue, ValueType::kTypeMerge, ValueType::kTypeValue, {ValueType::kTypeValue, ValueType::kTypeMerge, ValueType::kTypeValue,
ValueType::kTypeMerge}, ValueType::kTypeMerge},
file_id++, &true_data)); file_id++, write_global_seqno, &true_data));
// File doesn't overwrite any keys, no seqno needed // File doesn't overwrite any keys, no seqno needed
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 0); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 0);
ASSERT_OK(GenerateAndAddExternalFile( ASSERT_OK(GenerateAndAddExternalFile(
options, {1, 4, 6}, {ValueType::kTypeDeletion, ValueType::kTypeValue, options, {1, 4, 6},
ValueType::kTypeMerge}, {ValueType::kTypeDeletion, ValueType::kTypeValue,
file_id++, &true_data)); ValueType::kTypeMerge},
file_id++, write_global_seqno, &true_data));
// File overwrites some keys, a seqno will be assigned // File overwrites some keys, a seqno will be assigned
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 1); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 1);
ASSERT_OK(GenerateAndAddExternalFile( ASSERT_OK(GenerateAndAddExternalFile(
options, {11, 15, 19}, {ValueType::kTypeDeletion, ValueType::kTypeMerge, options, {11, 15, 19},
ValueType::kTypeValue}, {ValueType::kTypeDeletion, ValueType::kTypeMerge,
file_id++, &true_data)); ValueType::kTypeValue},
file_id++, write_global_seqno, &true_data));
// File overwrites some keys, a seqno will be assigned // File overwrites some keys, a seqno will be assigned
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 2); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 2);
ASSERT_OK(GenerateAndAddExternalFile( ASSERT_OK(GenerateAndAddExternalFile(
options, {120, 130}, {ValueType::kTypeValue, ValueType::kTypeMerge}, options, {120, 130}, {ValueType::kTypeValue, ValueType::kTypeMerge},
file_id++, &true_data)); file_id++, write_global_seqno, &true_data));
// File doesn't overwrite any keys, no seqno needed // File doesn't overwrite any keys, no seqno needed
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 2); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 2);
ASSERT_OK(GenerateAndAddExternalFile( ASSERT_OK(GenerateAndAddExternalFile(
options, {1, 130}, {ValueType::kTypeMerge, ValueType::kTypeDeletion}, options, {1, 130}, {ValueType::kTypeMerge, ValueType::kTypeDeletion},
file_id++, &true_data)); file_id++, write_global_seqno, &true_data));
// File overwrites some keys, a seqno will be assigned // File overwrites some keys, a seqno will be assigned
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 3); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 3);
@ -509,14 +537,14 @@ TEST_F(ExternalSSTFileBasicTest, IngestFileWithMixedValueType) {
options, {150, 151, 152}, options, {150, 151, 152},
{ValueType::kTypeValue, ValueType::kTypeMerge, {ValueType::kTypeValue, ValueType::kTypeMerge,
ValueType::kTypeDeletion}, ValueType::kTypeDeletion},
{{150, 160}, {180, 190}}, file_id++, &true_data)); {{150, 160}, {180, 190}}, file_id++, write_global_seqno, &true_data));
// File doesn't overwrite any keys, no seqno needed // File doesn't overwrite any keys, no seqno needed
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 3); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 3);
ASSERT_OK(GenerateAndAddExternalFile( ASSERT_OK(GenerateAndAddExternalFile(
options, {150, 151, 152}, options, {150, 151, 152},
{ValueType::kTypeValue, ValueType::kTypeMerge, ValueType::kTypeValue}, {ValueType::kTypeValue, ValueType::kTypeMerge, ValueType::kTypeValue},
{{200, 250}}, file_id++, &true_data)); {{200, 250}}, file_id++, write_global_seqno, &true_data));
// File overwrites some keys, a seqno will be assigned // File overwrites some keys, a seqno will be assigned
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 4); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 4);
@ -524,7 +552,7 @@ TEST_F(ExternalSSTFileBasicTest, IngestFileWithMixedValueType) {
options, {300, 301, 302}, options, {300, 301, 302},
{ValueType::kTypeValue, ValueType::kTypeMerge, {ValueType::kTypeValue, ValueType::kTypeMerge,
ValueType::kTypeDeletion}, ValueType::kTypeDeletion},
{{1, 2}, {152, 154}}, file_id++, &true_data)); {{1, 2}, {152, 154}}, file_id++, write_global_seqno, &true_data));
// File overwrites some keys, a seqno will be assigned // File overwrites some keys, a seqno will be assigned
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 5); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 5);
@ -538,7 +566,7 @@ TEST_F(ExternalSSTFileBasicTest, IngestFileWithMixedValueType) {
ASSERT_OK(GenerateAndAddExternalFile( ASSERT_OK(GenerateAndAddExternalFile(
options, {60, 61, 62}, options, {60, 61, 62},
{ValueType::kTypeValue, ValueType::kTypeMerge, ValueType::kTypeValue}, {ValueType::kTypeValue, ValueType::kTypeMerge, ValueType::kTypeValue},
file_id++, &true_data)); file_id++, write_global_seqno, &true_data));
// File doesn't overwrite any keys, no seqno needed // File doesn't overwrite any keys, no seqno needed
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno);
@ -546,7 +574,7 @@ TEST_F(ExternalSSTFileBasicTest, IngestFileWithMixedValueType) {
options, {40, 41, 42}, options, {40, 41, 42},
{ValueType::kTypeValue, ValueType::kTypeDeletion, {ValueType::kTypeValue, ValueType::kTypeDeletion,
ValueType::kTypeDeletion}, ValueType::kTypeDeletion},
file_id++, &true_data)); file_id++, write_global_seqno, &true_data));
// File overwrites some keys, a seqno will be assigned // File overwrites some keys, a seqno will be assigned
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 1); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 1);
@ -554,7 +582,7 @@ TEST_F(ExternalSSTFileBasicTest, IngestFileWithMixedValueType) {
options, {20, 30, 40}, options, {20, 30, 40},
{ValueType::kTypeDeletion, ValueType::kTypeDeletion, {ValueType::kTypeDeletion, ValueType::kTypeDeletion,
ValueType::kTypeDeletion}, ValueType::kTypeDeletion},
file_id++, &true_data)); file_id++, write_global_seqno, &true_data));
// File overwrites some keys, a seqno will be assigned // File overwrites some keys, a seqno will be assigned
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 2); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 2);
@ -564,13 +592,13 @@ TEST_F(ExternalSSTFileBasicTest, IngestFileWithMixedValueType) {
// keys in the DB or not because we have a snapshot // keys in the DB or not because we have a snapshot
ASSERT_OK(GenerateAndAddExternalFile( ASSERT_OK(GenerateAndAddExternalFile(
options, {1000, 1002}, {ValueType::kTypeValue, ValueType::kTypeMerge}, options, {1000, 1002}, {ValueType::kTypeValue, ValueType::kTypeMerge},
file_id++, &true_data)); file_id++, write_global_seqno, &true_data));
// A global seqno will be assigned anyway because of the snapshot // A global seqno will be assigned anyway because of the snapshot
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 3); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 3);
ASSERT_OK(GenerateAndAddExternalFile( ASSERT_OK(GenerateAndAddExternalFile(
options, {2000, 3002}, {ValueType::kTypeValue, ValueType::kTypeMerge}, options, {2000, 3002}, {ValueType::kTypeValue, ValueType::kTypeMerge},
file_id++, &true_data)); file_id++, write_global_seqno, &true_data));
// A global seqno will be assigned anyway because of the snapshot // A global seqno will be assigned anyway because of the snapshot
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 4); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 4);
@ -578,7 +606,7 @@ TEST_F(ExternalSSTFileBasicTest, IngestFileWithMixedValueType) {
options, {1, 20, 40, 100, 150}, options, {1, 20, 40, 100, 150},
{ValueType::kTypeDeletion, ValueType::kTypeDeletion, {ValueType::kTypeDeletion, ValueType::kTypeDeletion,
ValueType::kTypeValue, ValueType::kTypeMerge, ValueType::kTypeMerge}, ValueType::kTypeValue, ValueType::kTypeMerge, ValueType::kTypeMerge},
file_id++, &true_data)); file_id++, write_global_seqno, &true_data));
// A global seqno will be assigned anyway because of the snapshot // A global seqno will be assigned anyway because of the snapshot
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 5); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 5);
@ -586,13 +614,13 @@ TEST_F(ExternalSSTFileBasicTest, IngestFileWithMixedValueType) {
ASSERT_OK(GenerateAndAddExternalFile( ASSERT_OK(GenerateAndAddExternalFile(
options, {5000, 5001}, {ValueType::kTypeValue, ValueType::kTypeMerge}, options, {5000, 5001}, {ValueType::kTypeValue, ValueType::kTypeMerge},
file_id++, &true_data)); file_id++, write_global_seqno, &true_data));
// No snapshot anymore, no need to assign a seqno // No snapshot anymore, no need to assign a seqno
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 5); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 5);
size_t kcnt = 0; size_t kcnt = 0;
VerifyDBFromMap(true_data, &kcnt, false); VerifyDBFromMap(true_data, &kcnt, false);
} while (ChangeCompactOptions()); } while (ChangeOptionsForFileIngestionTest());
} }
TEST_F(ExternalSSTFileBasicTest, FadviseTrigger) { TEST_F(ExternalSSTFileBasicTest, FadviseTrigger) {
@ -635,7 +663,7 @@ TEST_F(ExternalSSTFileBasicTest, FadviseTrigger) {
rocksdb::SyncPoint::GetInstance()->DisableProcessing(); rocksdb::SyncPoint::GetInstance()->DisableProcessing();
} }
TEST_F(ExternalSSTFileBasicTest, IngestionWithRangeDeletions) { TEST_P(ExternalSSTFileBasicTest, IngestionWithRangeDeletions) {
int kNumLevels = 7; int kNumLevels = 7;
Options options = CurrentOptions(); Options options = CurrentOptions();
options.disable_auto_compactions = true; options.disable_auto_compactions = true;
@ -662,12 +690,13 @@ TEST_F(ExternalSSTFileBasicTest, IngestionWithRangeDeletions) {
ASSERT_EQ(0, NumTableFilesAtLevel(kNumLevels - 2)); ASSERT_EQ(0, NumTableFilesAtLevel(kNumLevels - 2));
ASSERT_EQ(1, NumTableFilesAtLevel(kNumLevels - 1)); ASSERT_EQ(1, NumTableFilesAtLevel(kNumLevels - 1));
bool write_global_seqno = GetParam();
// overlaps with L0 file but not memtable, so flush is skipped and file is // overlaps with L0 file but not memtable, so flush is skipped and file is
// ingested into L0 // ingested into L0
SequenceNumber last_seqno = dbfull()->GetLatestSequenceNumber(); SequenceNumber last_seqno = dbfull()->GetLatestSequenceNumber();
ASSERT_OK(GenerateAndAddExternalFile( ASSERT_OK(GenerateAndAddExternalFile(
options, {60, 90}, {ValueType::kTypeValue, ValueType::kTypeValue}, options, {60, 90}, {ValueType::kTypeValue, ValueType::kTypeValue},
{{65, 70}, {70, 85}}, file_id++, &true_data)); {{65, 70}, {70, 85}}, file_id++, write_global_seqno, &true_data));
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), ++last_seqno); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), ++last_seqno);
ASSERT_EQ(2, NumTableFilesAtLevel(0)); ASSERT_EQ(2, NumTableFilesAtLevel(0));
ASSERT_EQ(0, NumTableFilesAtLevel(kNumLevels - 2)); ASSERT_EQ(0, NumTableFilesAtLevel(kNumLevels - 2));
@ -677,7 +706,7 @@ TEST_F(ExternalSSTFileBasicTest, IngestionWithRangeDeletions) {
// file is ingested into L5 // file is ingested into L5
ASSERT_OK(GenerateAndAddExternalFile( ASSERT_OK(GenerateAndAddExternalFile(
options, {10, 40}, {ValueType::kTypeValue, ValueType::kTypeValue}, options, {10, 40}, {ValueType::kTypeValue, ValueType::kTypeValue},
file_id++, &true_data)); file_id++, write_global_seqno, &true_data));
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), ++last_seqno); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), ++last_seqno);
ASSERT_EQ(2, NumTableFilesAtLevel(0)); ASSERT_EQ(2, NumTableFilesAtLevel(0));
ASSERT_EQ(1, NumTableFilesAtLevel(kNumLevels - 2)); ASSERT_EQ(1, NumTableFilesAtLevel(kNumLevels - 2));
@ -686,7 +715,7 @@ TEST_F(ExternalSSTFileBasicTest, IngestionWithRangeDeletions) {
// overlaps with L5 file but not memtable or L0 file, so flush is skipped and // overlaps with L5 file but not memtable or L0 file, so flush is skipped and
// file is ingested into L4 // file is ingested into L4
ASSERT_OK(GenerateAndAddExternalFile(options, {}, {}, {{5, 15}}, file_id++, ASSERT_OK(GenerateAndAddExternalFile(options, {}, {}, {{5, 15}}, file_id++,
&true_data)); write_global_seqno, &true_data));
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), ++last_seqno); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), ++last_seqno);
ASSERT_EQ(2, NumTableFilesAtLevel(0)); ASSERT_EQ(2, NumTableFilesAtLevel(0));
ASSERT_EQ(1, NumTableFilesAtLevel(kNumLevels - 2)); ASSERT_EQ(1, NumTableFilesAtLevel(kNumLevels - 2));
@ -698,7 +727,7 @@ TEST_F(ExternalSSTFileBasicTest, IngestionWithRangeDeletions) {
// count increases by two. // count increases by two.
ASSERT_OK(GenerateAndAddExternalFile( ASSERT_OK(GenerateAndAddExternalFile(
options, {100, 140}, {ValueType::kTypeValue, ValueType::kTypeValue}, options, {100, 140}, {ValueType::kTypeValue, ValueType::kTypeValue},
file_id++, &true_data)); file_id++, write_global_seqno, &true_data));
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), ++last_seqno); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), ++last_seqno);
ASSERT_EQ(4, NumTableFilesAtLevel(0)); ASSERT_EQ(4, NumTableFilesAtLevel(0));
ASSERT_EQ(1, NumTableFilesAtLevel(kNumLevels - 2)); ASSERT_EQ(1, NumTableFilesAtLevel(kNumLevels - 2));
@ -711,13 +740,16 @@ TEST_F(ExternalSSTFileBasicTest, IngestionWithRangeDeletions) {
// seqnum. // seqnum.
ASSERT_OK(GenerateAndAddExternalFile( ASSERT_OK(GenerateAndAddExternalFile(
options, {151, 175}, {ValueType::kTypeValue, ValueType::kTypeValue}, options, {151, 175}, {ValueType::kTypeValue, ValueType::kTypeValue},
{{160, 200}}, file_id++, &true_data)); {{160, 200}}, file_id++, write_global_seqno, &true_data));
ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno); ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno);
ASSERT_EQ(4, NumTableFilesAtLevel(0)); ASSERT_EQ(4, NumTableFilesAtLevel(0));
ASSERT_EQ(1, NumTableFilesAtLevel(kNumLevels - 2)); ASSERT_EQ(1, NumTableFilesAtLevel(kNumLevels - 2));
ASSERT_EQ(2, NumTableFilesAtLevel(options.num_levels - 1)); ASSERT_EQ(2, NumTableFilesAtLevel(options.num_levels - 1));
} }
INSTANTIATE_TEST_CASE_P(ExternalSSTFileBasicTest, ExternalSSTFileBasicTest,
testing::Bool());
#endif // ROCKSDB_LITE #endif // ROCKSDB_LITE
} // namespace rocksdb } // namespace rocksdb

121
db/external_sst_file_test.cc
Unescape View File

@ -15,7 +15,8 @@
namespace rocksdb { namespace rocksdb {
class ExternalSSTFileTest : public DBTestBase { class ExternalSSTFileTest : public DBTestBase,
public ::testing::WithParamInterface<bool> {
public: public:
ExternalSSTFileTest() : DBTestBase("/external_sst_file_test") { ExternalSSTFileTest() : DBTestBase("/external_sst_file_test") {
sst_files_dir_ = dbname_ + "/sst_files/"; sst_files_dir_ = dbname_ + "/sst_files/";
@ -30,7 +31,8 @@ class ExternalSSTFileTest : public DBTestBase {
Status GenerateAndAddExternalFile( Status GenerateAndAddExternalFile(
const Options options, const Options options,
std::vector<std::pair<std::string, std::string>> data, int file_id = -1, std::vector<std::pair<std::string, std::string>> data, int file_id = -1,
bool allow_global_seqno = false, bool sort_data = false, bool allow_global_seqno = false, bool write_global_seqno = false,
bool sort_data = false,
std::map<std::string, std::string>* true_data = nullptr, std::map<std::string, std::string>* true_data = nullptr,
ColumnFamilyHandle* cfh = nullptr) { ColumnFamilyHandle* cfh = nullptr) {
// Generate a file id if not provided // Generate a file id if not provided
@ -73,6 +75,7 @@ class ExternalSSTFileTest : public DBTestBase {
if (s.ok()) { if (s.ok()) {
IngestExternalFileOptions ifo; IngestExternalFileOptions ifo;
ifo.allow_global_seqno = allow_global_seqno; ifo.allow_global_seqno = allow_global_seqno;
ifo.write_global_seqno = allow_global_seqno ? write_global_seqno : false;
if (cfh) { if (cfh) {
s = db_->IngestExternalFile(cfh, {file_path}, ifo); s = db_->IngestExternalFile(cfh, {file_path}, ifo);
} else { } else {
@ -149,11 +152,10 @@ class ExternalSSTFileTest : public DBTestBase {
return s; return s;
} }
Status GenerateAndAddExternalFile( Status GenerateAndAddExternalFile(
const Options options, std::vector<std::pair<int, std::string>> data, const Options options, std::vector<std::pair<int, std::string>> data,
int file_id = -1, bool allow_global_seqno = false, bool sort_data = false, int file_id = -1, bool allow_global_seqno = false,
bool write_global_seqno = false, bool sort_data = false,
std::map<std::string, std::string>* true_data = nullptr, std::map<std::string, std::string>* true_data = nullptr,
ColumnFamilyHandle* cfh = nullptr) { ColumnFamilyHandle* cfh = nullptr) {
std::vector<std::pair<std::string, std::string>> file_data; std::vector<std::pair<std::string, std::string>> file_data;
@ -161,13 +163,14 @@ class ExternalSSTFileTest : public DBTestBase {
file_data.emplace_back(Key(entry.first), entry.second); file_data.emplace_back(Key(entry.first), entry.second);
} }
return GenerateAndAddExternalFile(options, file_data, file_id, return GenerateAndAddExternalFile(options, file_data, file_id,
allow_global_seqno, sort_data, true_data, allow_global_seqno, write_global_seqno,
cfh); sort_data, true_data, cfh);
} }
Status GenerateAndAddExternalFile( Status GenerateAndAddExternalFile(
const Options options, std::vector<int> keys, int file_id = -1, const Options options, std::vector<int> keys, int file_id = -1,
bool allow_global_seqno = false, bool sort_data = false, bool allow_global_seqno = false, bool write_global_seqno = false,
bool sort_data = false,
std::map<std::string, std::string>* true_data = nullptr, std::map<std::string, std::string>* true_data = nullptr,
ColumnFamilyHandle* cfh = nullptr) { ColumnFamilyHandle* cfh = nullptr) {
std::vector<std::pair<std::string, std::string>> file_data; std::vector<std::pair<std::string, std::string>> file_data;
@ -175,18 +178,20 @@ class ExternalSSTFileTest : public DBTestBase {
file_data.emplace_back(Key(k), Key(k) + ToString(file_id)); file_data.emplace_back(Key(k), Key(k) + ToString(file_id));
} }
return GenerateAndAddExternalFile(options, file_data, file_id, return GenerateAndAddExternalFile(options, file_data, file_id,
allow_global_seqno, sort_data, true_data, allow_global_seqno, write_global_seqno,
cfh); sort_data, true_data, cfh);
} }
Status DeprecatedAddFile(const std::vector<std::string>& files, Status DeprecatedAddFile(const std::vector<std::string>& files,
bool move_files = false, bool move_files = false,
bool skip_snapshot_check = false) { bool skip_snapshot_check = false,
bool skip_write_global_seqno = false) {
IngestExternalFileOptions opts; IngestExternalFileOptions opts;
opts.move_files = move_files; opts.move_files = move_files;
opts.snapshot_consistency = !skip_snapshot_check; opts.snapshot_consistency = !skip_snapshot_check;
opts.allow_global_seqno = false; opts.allow_global_seqno = false;
opts.allow_blocking_flush = false; opts.allow_blocking_flush = false;
opts.write_global_seqno = !skip_write_global_seqno;
return db_->IngestExternalFile(files, opts); return db_->IngestExternalFile(files, opts);
} }
@ -453,6 +458,7 @@ TEST_F(ExternalSSTFileTest, Basic) {
} while (ChangeOptions(kSkipPlainTable | kSkipFIFOCompaction | } while (ChangeOptions(kSkipPlainTable | kSkipFIFOCompaction |
kRangeDelSkipConfigs)); kRangeDelSkipConfigs));
} }
class SstFileWriterCollector : public TablePropertiesCollector { class SstFileWriterCollector : public TablePropertiesCollector {
public: public:
explicit SstFileWriterCollector(const std::string prefix) : prefix_(prefix) { explicit SstFileWriterCollector(const std::string prefix) : prefix_(prefix) {
@ -1141,7 +1147,7 @@ TEST_F(ExternalSSTFileTest, OverlappingRanges) {
} while (ChangeOptions(kSkipPlainTable | kSkipFIFOCompaction)); } while (ChangeOptions(kSkipPlainTable | kSkipFIFOCompaction));
} }
TEST_F(ExternalSSTFileTest, PickedLevel) { TEST_P(ExternalSSTFileTest, PickedLevel) {
Options options = CurrentOptions(); Options options = CurrentOptions();
options.disable_auto_compactions = false; options.disable_auto_compactions = false;
options.level0_file_num_compaction_trigger = 4; options.level0_file_num_compaction_trigger = 4;
@ -1152,11 +1158,11 @@ TEST_F(ExternalSSTFileTest, PickedLevel) {
// File 0 will go to last level (L3) // File 0 will go to last level (L3)
ASSERT_OK(GenerateAndAddExternalFile(options, {1, 10}, -1, false, false, ASSERT_OK(GenerateAndAddExternalFile(options, {1, 10}, -1, false, false,
&true_data)); false, &true_data));
EXPECT_EQ(FilesPerLevel(), "0,0,0,1"); EXPECT_EQ(FilesPerLevel(), "0,0,0,1");
// File 1 will go to level L2 (since it overlap with file 0 in L3) // File 1 will go to level L2 (since it overlap with file 0 in L3)
ASSERT_OK(GenerateAndAddExternalFile(options, {2, 9}, -1, false, false, ASSERT_OK(GenerateAndAddExternalFile(options, {2, 9}, -1, false, false, false,
&true_data)); &true_data));
EXPECT_EQ(FilesPerLevel(), "0,0,1,1"); EXPECT_EQ(FilesPerLevel(), "0,0,1,1");
@ -1186,13 +1192,13 @@ TEST_F(ExternalSSTFileTest, PickedLevel) {
// This file overlaps with file 0 (L3), file 1 (L2) and the // This file overlaps with file 0 (L3), file 1 (L2) and the
// output of compaction going to L1 // output of compaction going to L1
ASSERT_OK(GenerateAndAddExternalFile(options, {4, 7}, -1, false, false, ASSERT_OK(GenerateAndAddExternalFile(options, {4, 7}, -1, false, false, false,
&true_data)); &true_data));
EXPECT_EQ(FilesPerLevel(), "5,0,1,1"); EXPECT_EQ(FilesPerLevel(), "5,0,1,1");
// This file does not overlap with any file or with the running compaction // This file does not overlap with any file or with the running compaction
ASSERT_OK(GenerateAndAddExternalFile(options, {9000, 9001}, -1, false, false, ASSERT_OK(GenerateAndAddExternalFile(options, {9000, 9001}, -1, false, false,
&true_data)); false, &true_data));
EXPECT_EQ(FilesPerLevel(), "5,0,1,2"); EXPECT_EQ(FilesPerLevel(), "5,0,1,2");
// Hold compaction from finishing // Hold compaction from finishing
@ -1422,12 +1428,12 @@ TEST_F(ExternalSSTFileTest, PickedLevelDynamic) {
// This file overlaps with the output of the compaction (going to L3) // This file overlaps with the output of the compaction (going to L3)
// so the file will be added to L0 since L3 is the base level // so the file will be added to L0 since L3 is the base level
ASSERT_OK(GenerateAndAddExternalFile(options, {31, 32, 33, 34}, -1, false, ASSERT_OK(GenerateAndAddExternalFile(options, {31, 32, 33, 34}, -1, false,
false, &true_data)); false, false, &true_data));
EXPECT_EQ(FilesPerLevel(), "5"); EXPECT_EQ(FilesPerLevel(), "5");
// This file does not overlap with the current running compactiong // This file does not overlap with the current running compactiong
ASSERT_OK(GenerateAndAddExternalFile(options, {9000, 9001}, -1, false, false, ASSERT_OK(GenerateAndAddExternalFile(options, {9000, 9001}, -1, false, false,
&true_data)); false, &true_data));
EXPECT_EQ(FilesPerLevel(), "5,0,0,1"); EXPECT_EQ(FilesPerLevel(), "5,0,0,1");
// Hold compaction from finishing // Hold compaction from finishing
@ -1442,24 +1448,24 @@ TEST_F(ExternalSSTFileTest, PickedLevelDynamic) {
Reopen(options); Reopen(options);
ASSERT_OK(GenerateAndAddExternalFile(options, {1, 15, 19}, -1, false, false, ASSERT_OK(GenerateAndAddExternalFile(options, {1, 15, 19}, -1, false, false,
&true_data)); false, &true_data));
ASSERT_EQ(FilesPerLevel(), "1,0,0,3"); ASSERT_EQ(FilesPerLevel(), "1,0,0,3");
ASSERT_OK(GenerateAndAddExternalFile(options, {1000, 1001, 1002}, -1, false, ASSERT_OK(GenerateAndAddExternalFile(options, {1000, 1001, 1002}, -1, false,
false, &true_data)); false, false, &true_data));
ASSERT_EQ(FilesPerLevel(), "1,0,0,4"); ASSERT_EQ(FilesPerLevel(), "1,0,0,4");
ASSERT_OK(GenerateAndAddExternalFile(options, {500, 600, 700}, -1, false, ASSERT_OK(GenerateAndAddExternalFile(options, {500, 600, 700}, -1, false,
false, &true_data)); false, false, &true_data));
ASSERT_EQ(FilesPerLevel(), "1,0,0,5"); ASSERT_EQ(FilesPerLevel(), "1,0,0,5");
// File 5 overlaps with file 2 (L3 / base level) // File 5 overlaps with file 2 (L3 / base level)
ASSERT_OK(GenerateAndAddExternalFile(options, {2, 10}, -1, false, false, ASSERT_OK(GenerateAndAddExternalFile(options, {2, 10}, -1, false, false,
&true_data)); false, &true_data));
ASSERT_EQ(FilesPerLevel(), "2,0,0,5"); ASSERT_EQ(FilesPerLevel(), "2,0,0,5");
// File 6 overlaps with file 2 (L3 / base level) and file 5 (L0) // File 6 overlaps with file 2 (L3 / base level) and file 5 (L0)
ASSERT_OK(GenerateAndAddExternalFile(options, {3, 9}, -1, false, false, ASSERT_OK(GenerateAndAddExternalFile(options, {3, 9}, -1, false, false, false,
&true_data)); &true_data));
ASSERT_EQ(FilesPerLevel(), "3,0,0,5"); ASSERT_EQ(FilesPerLevel(), "3,0,0,5");
@ -1479,7 +1485,7 @@ TEST_F(ExternalSSTFileTest, PickedLevelDynamic) {
// File 7 overlaps with file 4 (L3) // File 7 overlaps with file 4 (L3)
ASSERT_OK(GenerateAndAddExternalFile(options, {650, 651, 652}, -1, false, ASSERT_OK(GenerateAndAddExternalFile(options, {650, 651, 652}, -1, false,
false, &true_data)); false, false, &true_data));
ASSERT_EQ(FilesPerLevel(), "5,0,0,5"); ASSERT_EQ(FilesPerLevel(), "5,0,0,5");
VerifyDBFromMap(true_data, &kcnt, false); VerifyDBFromMap(true_data, &kcnt, false);
@ -1613,12 +1619,13 @@ TEST_F(ExternalSSTFileTest, SstFileWriterNonSharedKeys) {
ASSERT_OK(DeprecatedAddFile({file_path})); ASSERT_OK(DeprecatedAddFile({file_path}));
} }
TEST_F(ExternalSSTFileTest, IngestFileWithGlobalSeqnoRandomized) { TEST_P(ExternalSSTFileTest, IngestFileWithGlobalSeqnoRandomized) {
Options options = CurrentOptions(); Options options = CurrentOptions();
options.IncreaseParallelism(20); options.IncreaseParallelism(20);
options.level0_slowdown_writes_trigger = 256; options.level0_slowdown_writes_trigger = 256;
options.level0_stop_writes_trigger = 256; options.level0_stop_writes_trigger = 256;
bool write_global_seqno = GetParam();
for (int iter = 0; iter < 2; iter++) { for (int iter = 0; iter < 2; iter++) {
bool write_to_memtable = (iter == 0); bool write_to_memtable = (iter == 0);
DestroyAndReopen(options); DestroyAndReopen(options);
@ -1643,7 +1650,8 @@ TEST_F(ExternalSSTFileTest, IngestFileWithGlobalSeqnoRandomized) {
} }
} else { } else {
ASSERT_OK(GenerateAndAddExternalFile(options, random_data, -1, true, ASSERT_OK(GenerateAndAddExternalFile(options, random_data, -1, true,
true, &true_data)); write_global_seqno, true,
&true_data));
} }
} }
size_t kcnt = 0; size_t kcnt = 0;
@ -1653,7 +1661,7 @@ TEST_F(ExternalSSTFileTest, IngestFileWithGlobalSeqnoRandomized) {
} }
} }
TEST_F(ExternalSSTFileTest, IngestFileWithGlobalSeqnoAssignedLevel) { TEST_P(ExternalSSTFileTest, IngestFileWithGlobalSeqnoAssignedLevel) {
Options options = CurrentOptions(); Options options = CurrentOptions();
options.num_levels = 5; options.num_levels = 5;
options.disable_auto_compactions = true; options.disable_auto_compactions = true;
@ -1672,8 +1680,9 @@ TEST_F(ExternalSSTFileTest, IngestFileWithGlobalSeqnoAssignedLevel) {
for (int i = 0; i <= 20; i++) { for (int i = 0; i <= 20; i++) {
file_data.emplace_back(Key(i), "L4"); file_data.emplace_back(Key(i), "L4");
} }
ASSERT_OK(GenerateAndAddExternalFile(options, file_data, -1, true, false, bool write_global_seqno = GetParam();
&true_data)); ASSERT_OK(GenerateAndAddExternalFile(options, file_data, -1, true,
write_global_seqno, false, &true_data));
// This file dont overlap with anything in the DB, will go to L4 // This file dont overlap with anything in the DB, will go to L4
ASSERT_EQ("0,0,0,0,1", FilesPerLevel()); ASSERT_EQ("0,0,0,0,1", FilesPerLevel());
@ -1683,8 +1692,8 @@ TEST_F(ExternalSSTFileTest, IngestFileWithGlobalSeqnoAssignedLevel) {
for (int i = 80; i <= 130; i++) { for (int i = 80; i <= 130; i++) {
file_data.emplace_back(Key(i), "L0"); file_data.emplace_back(Key(i), "L0");
} }
ASSERT_OK(GenerateAndAddExternalFile(options, file_data, -1, true, false, ASSERT_OK(GenerateAndAddExternalFile(options, file_data, -1, true,
&true_data)); write_global_seqno, false, &true_data));
// This file overlap with the memtable, so it will flush it and add // This file overlap with the memtable, so it will flush it and add
// it self to L0 // it self to L0
@ -1695,8 +1704,8 @@ TEST_F(ExternalSSTFileTest, IngestFileWithGlobalSeqnoAssignedLevel) {
for (int i = 30; i <= 50; i++) { for (int i = 30; i <= 50; i++) {
file_data.emplace_back(Key(i), "L4"); file_data.emplace_back(Key(i), "L4");
} }
ASSERT_OK(GenerateAndAddExternalFile(options, file_data, -1, true, false, ASSERT_OK(GenerateAndAddExternalFile(options, file_data, -1, true,
&true_data)); write_global_seqno, false, &true_data));
// This file dont overlap with anything in the DB and fit in L4 as well // This file dont overlap with anything in the DB and fit in L4 as well
ASSERT_EQ("2,0,0,0,2", FilesPerLevel()); ASSERT_EQ("2,0,0,0,2", FilesPerLevel());
@ -1706,8 +1715,8 @@ TEST_F(ExternalSSTFileTest, IngestFileWithGlobalSeqnoAssignedLevel) {
for (int i = 10; i <= 40; i++) { for (int i = 10; i <= 40; i++) {
file_data.emplace_back(Key(i), "L3"); file_data.emplace_back(Key(i), "L3");
} }
ASSERT_OK(GenerateAndAddExternalFile(options, file_data, -1, true, false, ASSERT_OK(GenerateAndAddExternalFile(options, file_data, -1, true,
&true_data)); write_global_seqno, false, &true_data));
// This file overlap with files in L4, we will ingest it in L3 // This file overlap with files in L4, we will ingest it in L3
ASSERT_EQ("2,0,0,1,2", FilesPerLevel()); ASSERT_EQ("2,0,0,1,2", FilesPerLevel());
@ -1716,7 +1725,7 @@ TEST_F(ExternalSSTFileTest, IngestFileWithGlobalSeqnoAssignedLevel) {
VerifyDBFromMap(true_data, &kcnt, false); VerifyDBFromMap(true_data, &kcnt, false);
} }
TEST_F(ExternalSSTFileTest, IngestFileWithGlobalSeqnoMemtableFlush) { TEST_P(ExternalSSTFileTest, IngestFileWithGlobalSeqnoMemtableFlush) {
Options options = CurrentOptions(); Options options = CurrentOptions();
DestroyAndReopen(options); DestroyAndReopen(options);
uint64_t entries_in_memtable; uint64_t entries_in_memtable;
@ -1730,16 +1739,17 @@ TEST_F(ExternalSSTFileTest, IngestFileWithGlobalSeqnoMemtableFlush) {
&entries_in_memtable); &entries_in_memtable);
ASSERT_GE(entries_in_memtable, 1); ASSERT_GE(entries_in_memtable, 1);
bool write_global_seqno = GetParam();
// No need for flush // No need for flush
ASSERT_OK(GenerateAndAddExternalFile(options, {90, 100, 110}, -1, true, false, ASSERT_OK(GenerateAndAddExternalFile(options, {90, 100, 110}, -1, true,
&true_data)); write_global_seqno, false, &true_data));
db_->GetIntProperty(DB::Properties::kNumEntriesActiveMemTable, db_->GetIntProperty(DB::Properties::kNumEntriesActiveMemTable,
&entries_in_memtable); &entries_in_memtable);
ASSERT_GE(entries_in_memtable, 1); ASSERT_GE(entries_in_memtable, 1);
// This file will flush the memtable // This file will flush the memtable
ASSERT_OK(GenerateAndAddExternalFile(options, {19, 20, 21}, -1, true, false, ASSERT_OK(GenerateAndAddExternalFile(options, {19, 20, 21}, -1, true,
&true_data)); write_global_seqno, false, &true_data));
db_->GetIntProperty(DB::Properties::kNumEntriesActiveMemTable, db_->GetIntProperty(DB::Properties::kNumEntriesActiveMemTable,
&entries_in_memtable); &entries_in_memtable);
ASSERT_EQ(entries_in_memtable, 0); ASSERT_EQ(entries_in_memtable, 0);
@ -1754,14 +1764,14 @@ TEST_F(ExternalSSTFileTest, IngestFileWithGlobalSeqnoMemtableFlush) {
// No need for flush, this file keys fit between the memtable keys // No need for flush, this file keys fit between the memtable keys
ASSERT_OK(GenerateAndAddExternalFile(options, {202, 203, 204}, -1, true, ASSERT_OK(GenerateAndAddExternalFile(options, {202, 203, 204}, -1, true,
false, &true_data)); write_global_seqno, false, &true_data));
db_->GetIntProperty(DB::Properties::kNumEntriesActiveMemTable, db_->GetIntProperty(DB::Properties::kNumEntriesActiveMemTable,
&entries_in_memtable); &entries_in_memtable);
ASSERT_GE(entries_in_memtable, 1); ASSERT_GE(entries_in_memtable, 1);
// This file will flush the memtable // This file will flush the memtable
ASSERT_OK(GenerateAndAddExternalFile(options, {206, 207}, -1, true, false, ASSERT_OK(GenerateAndAddExternalFile(options, {206, 207}, -1, true, false,
&true_data)); write_global_seqno, &true_data));
db_->GetIntProperty(DB::Properties::kNumEntriesActiveMemTable, db_->GetIntProperty(DB::Properties::kNumEntriesActiveMemTable,
&entries_in_memtable); &entries_in_memtable);
ASSERT_EQ(entries_in_memtable, 0); ASSERT_EQ(entries_in_memtable, 0);
@ -1770,7 +1780,7 @@ TEST_F(ExternalSSTFileTest, IngestFileWithGlobalSeqnoMemtableFlush) {
VerifyDBFromMap(true_data, &kcnt, false); VerifyDBFromMap(true_data, &kcnt, false);
} }
TEST_F(ExternalSSTFileTest, L0SortingIssue) { TEST_P(ExternalSSTFileTest, L0SortingIssue) {
Options options = CurrentOptions(); Options options = CurrentOptions();
options.num_levels = 2; options.num_levels = 2;
DestroyAndReopen(options); DestroyAndReopen(options);
@ -1779,10 +1789,13 @@ TEST_F(ExternalSSTFileTest, L0SortingIssue) {
ASSERT_OK(Put(Key(1), "memtable")); ASSERT_OK(Put(Key(1), "memtable"));
ASSERT_OK(Put(Key(10), "memtable")); ASSERT_OK(Put(Key(10), "memtable"));
bool write_global_seqno = GetParam();
// No Flush needed, No global seqno needed, Ingest in L1 // No Flush needed, No global seqno needed, Ingest in L1
ASSERT_OK(GenerateAndAddExternalFile(options, {7, 8}, -1, true, false)); ASSERT_OK(GenerateAndAddExternalFile(options, {7, 8}, -1, true,
write_global_seqno, false));
// No Flush needed, but need a global seqno, Ingest in L0 // No Flush needed, but need a global seqno, Ingest in L0
ASSERT_OK(GenerateAndAddExternalFile(options, {7, 8}, -1, true, false)); ASSERT_OK(GenerateAndAddExternalFile(options, {7, 8}, -1, true,
write_global_seqno, false));
printf("%s\n", FilesPerLevel().c_str()); printf("%s\n", FilesPerLevel().c_str());
// Overwrite what we added using external files // Overwrite what we added using external files
@ -2011,15 +2024,17 @@ class TestIngestExternalFileListener : public EventListener {
std::vector<ExternalFileIngestionInfo> ingested_files; std::vector<ExternalFileIngestionInfo> ingested_files;
}; };
TEST_F(ExternalSSTFileTest, IngestionListener) { TEST_P(ExternalSSTFileTest, IngestionListener) {
Options options = CurrentOptions(); Options options = CurrentOptions();
TestIngestExternalFileListener* listener = TestIngestExternalFileListener* listener =
new TestIngestExternalFileListener(); new TestIngestExternalFileListener();
options.listeners.emplace_back(listener); options.listeners.emplace_back(listener);
CreateAndReopenWithCF({"koko", "toto"}, options); CreateAndReopenWithCF({"koko", "toto"}, options);
bool write_global_seqno = GetParam();
// Ingest into default cf // Ingest into default cf
ASSERT_OK(GenerateAndAddExternalFile(options, {1, 2}, -1, true, true, nullptr, ASSERT_OK(GenerateAndAddExternalFile(options, {1, 2}, -1, true,
write_global_seqno, true, nullptr,
handles_[0])); handles_[0]));
ASSERT_EQ(listener->ingested_files.size(), 1); ASSERT_EQ(listener->ingested_files.size(), 1);
ASSERT_EQ(listener->ingested_files.back().cf_name, "default"); ASSERT_EQ(listener->ingested_files.back().cf_name, "default");
@ -2030,7 +2045,8 @@ TEST_F(ExternalSSTFileTest, IngestionListener) {
"default"); "default");
// Ingest into cf1 // Ingest into cf1
ASSERT_OK(GenerateAndAddExternalFile(options, {1, 2}, -1, true, true, nullptr, ASSERT_OK(GenerateAndAddExternalFile(options, {1, 2}, -1, true,
write_global_seqno, true, nullptr,
handles_[1])); handles_[1]));
ASSERT_EQ(listener->ingested_files.size(), 2); ASSERT_EQ(listener->ingested_files.size(), 2);
ASSERT_EQ(listener->ingested_files.back().cf_name, "koko"); ASSERT_EQ(listener->ingested_files.back().cf_name, "koko");
@ -2041,7 +2057,8 @@ TEST_F(ExternalSSTFileTest, IngestionListener) {
"koko"); "koko");
// Ingest into cf2 // Ingest into cf2
ASSERT_OK(GenerateAndAddExternalFile(options, {1, 2}, -1, true, true, nullptr, ASSERT_OK(GenerateAndAddExternalFile(options, {1, 2}, -1, true,
write_global_seqno, true, nullptr,
handles_[2])); handles_[2]));
ASSERT_EQ(listener->ingested_files.size(), 3); ASSERT_EQ(listener->ingested_files.size(), 3);
ASSERT_EQ(listener->ingested_files.back().cf_name, "toto"); ASSERT_EQ(listener->ingested_files.back().cf_name, "toto");
@ -2084,7 +2101,7 @@ TEST_F(ExternalSSTFileTest, SnapshotInconsistencyBug) {
db_->ReleaseSnapshot(snap); db_->ReleaseSnapshot(snap);
} }
TEST_F(ExternalSSTFileTest, IngestBehind) { TEST_P(ExternalSSTFileTest, IngestBehind) {
Options options = CurrentOptions(); Options options = CurrentOptions();
options.compaction_style = kCompactionStyleUniversal; options.compaction_style = kCompactionStyleUniversal;
options.num_levels = 3; options.num_levels = 3;
@ -2108,6 +2125,7 @@ TEST_F(ExternalSSTFileTest, IngestBehind) {
IngestExternalFileOptions ifo; IngestExternalFileOptions ifo;
ifo.allow_global_seqno = true; ifo.allow_global_seqno = true;
ifo.ingest_behind = true; ifo.ingest_behind = true;
ifo.write_global_seqno = GetParam();
// Can't ingest behind since allow_ingest_behind isn't set to true // Can't ingest behind since allow_ingest_behind isn't set to true
ASSERT_NOK(GenerateAndAddExternalFileIngestBehind(options, ifo, ASSERT_NOK(GenerateAndAddExternalFileIngestBehind(options, ifo,
@ -2195,6 +2213,9 @@ TEST_F(ExternalSSTFileTest, SkipBloomFilter) {
} }
} }
INSTANTIATE_TEST_CASE_P(ExternalSSTFileTest, ExternalSSTFileTest,
testing::Bool());
} // namespace rocksdb } // namespace rocksdb
int main(int argc, char** argv) { int main(int argc, char** argv) {

Write Preview
Loading…
Cancel
Save