#ifndef ROCKSDB_LITE
#include <stdlib.h>
+
#include <map>
#include <string>
#include <vector>
-#include "db/db_impl.h"
+
+#include "db/db_impl/db_impl.h"
+#include "db/db_test_util.h"
#include "db/version_set.h"
#include "db/write_batch_internal.h"
+#include "file/filename.h"
+#include "port/stack_trace.h"
#include "rocksdb/db.h"
#include "rocksdb/env.h"
#include "rocksdb/transaction_log.h"
-#include "util/filename.h"
+#include "test_util/sync_point.h"
+#include "test_util/testharness.h"
+#include "test_util/testutil.h"
#include "util/string_util.h"
-#include "util/sync_point.h"
-#include "util/testharness.h"
-#include "util/testutil.h"
-namespace rocksdb {
+namespace ROCKSDB_NAMESPACE {
-class DeleteFileTest : public testing::Test {
+class DeleteFileTest : public DBTestBase {
public:
- std::string dbname_;
- Options options_;
- DB* db_;
- Env* env_;
- int numlevels_;
-
- DeleteFileTest() {
- db_ = nullptr;
- env_ = Env::Default();
- options_.delete_obsolete_files_period_micros = 0; // always do full purge
- options_.enable_thread_tracking = true;
- options_.write_buffer_size = 1024*1024*1000;
- options_.target_file_size_base = 1024*1024*1000;
- options_.max_bytes_for_level_base = 1024*1024*1000;
- options_.WAL_ttl_seconds = 300; // Used to test log files
- options_.WAL_size_limit_MB = 1024; // Used to test log files
- dbname_ = test::PerThreadDBPath("deletefile_test");
- options_.wal_dir = dbname_ + "/wal_files";
-
- // clean up all the files that might have been there before
- std::vector<std::string> old_files;
- env_->GetChildren(dbname_, &old_files);
- for (auto file : old_files) {
- env_->DeleteFile(dbname_ + "/" + file);
- }
- env_->GetChildren(options_.wal_dir, &old_files);
- for (auto file : old_files) {
- env_->DeleteFile(options_.wal_dir + "/" + file);
- }
-
- DestroyDB(dbname_, options_);
- numlevels_ = 7;
- EXPECT_OK(ReopenDB(true));
- }
-
- Status ReopenDB(bool create) {
- delete db_;
- if (create) {
- DestroyDB(dbname_, options_);
- }
- db_ = nullptr;
- options_.create_if_missing = create;
- Status s = DB::Open(options_, dbname_, &db_);
- assert(db_);
- return s;
- }
-
- void CloseDB() {
- delete db_;
- db_ = nullptr;
+ const int numlevels_;
+ const std::string wal_dir_;
+
+ DeleteFileTest()
+ : DBTestBase("deletefile_test", /*env_do_fsync=*/true),
+ numlevels_(7),
+ wal_dir_(dbname_ + "/wal_files") {}
+
+ void SetOptions(Options* options) {
+ ASSERT_NE(options, nullptr);
+ options->delete_obsolete_files_period_micros = 0; // always do full purge
+ options->enable_thread_tracking = true;
+ options->write_buffer_size = 1024 * 1024 * 1000;
+ options->target_file_size_base = 1024 * 1024 * 1000;
+ options->max_bytes_for_level_base = 1024 * 1024 * 1000;
+ options->WAL_ttl_seconds = 300; // Used to test log files
+ options->WAL_size_limit_MB = 1024; // Used to test log files
+ options->wal_dir = wal_dir_;
}
void AddKeys(int numkeys, int startkey = 0) {
WriteOptions options;
options.sync = false;
ReadOptions roptions;
- for (int i = startkey; i < (numkeys + startkey) ; i++) {
- std::string temp = ToString(i);
+ for (int i = startkey; i < (numkeys + startkey); i++) {
+ std::string temp = std::to_string(i);
Slice key(temp);
Slice value(temp);
ASSERT_OK(db_->Put(options, key, value));
}
}
- int numKeysInLevels(
- std::vector<LiveFileMetaData> &metadata,
- std::vector<int> *keysperlevel = nullptr) {
-
+ int numKeysInLevels(std::vector<LiveFileMetaData>& metadata,
+ std::vector<int>* keysperlevel = nullptr) {
if (keysperlevel != nullptr) {
keysperlevel->resize(numlevels_);
}
}
fprintf(stderr, "level %d name %s smallest %s largest %s\n",
metadata[i].level, metadata[i].name.c_str(),
- metadata[i].smallestkey.c_str(),
- metadata[i].largestkey.c_str());
+ metadata[i].smallestkey.c_str(), metadata[i].largestkey.c_str());
}
return numKeys;
}
void CreateTwoLevels() {
AddKeys(50000, 10000);
- DBImpl* dbi = reinterpret_cast<DBImpl*>(db_);
- ASSERT_OK(dbi->TEST_FlushMemTable());
- ASSERT_OK(dbi->TEST_WaitForFlushMemTable());
+ ASSERT_OK(dbfull()->TEST_FlushMemTable());
+ ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
for (int i = 0; i < 2; ++i) {
- ASSERT_OK(dbi->TEST_CompactRange(i, nullptr, nullptr));
+ ASSERT_OK(dbfull()->TEST_CompactRange(i, nullptr, nullptr));
}
AddKeys(50000, 10000);
- ASSERT_OK(dbi->TEST_FlushMemTable());
- ASSERT_OK(dbi->TEST_WaitForFlushMemTable());
- ASSERT_OK(dbi->TEST_CompactRange(0, nullptr, nullptr));
+ ASSERT_OK(dbfull()->TEST_FlushMemTable());
+ ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
+ ASSERT_OK(dbfull()->TEST_CompactRange(0, nullptr, nullptr));
}
- void CheckFileTypeCounts(std::string& dir,
- int required_log,
- int required_sst,
- int required_manifest) {
+ void CheckFileTypeCounts(const std::string& dir, int required_log,
+ int required_sst, int required_manifest) {
std::vector<std::string> filenames;
- env_->GetChildren(dir, &filenames);
+ ASSERT_OK(env_->GetChildren(dir, &filenames));
int log_cnt = 0, sst_cnt = 0, manifest_cnt = 0;
for (auto file : filenames) {
uint64_t number;
FileType type;
if (ParseFileName(file, &number, &type)) {
- log_cnt += (type == kLogFile);
+ log_cnt += (type == kWalFile);
sst_cnt += (type == kTableFile);
manifest_cnt += (type == kDescriptorFile);
}
}
- ASSERT_EQ(required_log, log_cnt);
- ASSERT_EQ(required_sst, sst_cnt);
- ASSERT_EQ(required_manifest, manifest_cnt);
+ if (required_log >= 0) {
+ ASSERT_EQ(required_log, log_cnt);
+ }
+ if (required_sst >= 0) {
+ ASSERT_EQ(required_sst, sst_cnt);
+ }
+ if (required_manifest >= 0) {
+ ASSERT_EQ(required_manifest, manifest_cnt);
+ }
}
static void DoSleep(void* arg) {
};
TEST_F(DeleteFileTest, AddKeysAndQueryLevels) {
+ Options options = CurrentOptions();
+ SetOptions(&options);
+ Destroy(options);
+ options.create_if_missing = true;
+ Reopen(options);
+
CreateTwoLevels();
std::vector<LiveFileMetaData> metadata;
db_->GetLiveFilesMetaData(&metadata);
ASSERT_TRUE(status.IsInvalidArgument());
// Lowest level file deletion should succeed.
- ASSERT_OK(db_->DeleteFile(level2file));
-
- CloseDB();
+ status = db_->DeleteFile(level2file);
+ ASSERT_OK(status);
}
TEST_F(DeleteFileTest, PurgeObsoleteFilesTest) {
+ Options options = CurrentOptions();
+ SetOptions(&options);
+ Destroy(options);
+ options.create_if_missing = true;
+ Reopen(options);
+
CreateTwoLevels();
// there should be only one (empty) log file because CreateTwoLevels()
// flushes the memtables to disk
- CheckFileTypeCounts(options_.wal_dir, 1, 0, 0);
+ CheckFileTypeCounts(wal_dir_, 1, 0, 0);
// 2 ssts, 1 manifest
CheckFileTypeCounts(dbname_, 0, 2, 1);
std::string first("0"), last("999999");
compact_options.change_level = true;
compact_options.target_level = 2;
Slice first_slice(first), last_slice(last);
- db_->CompactRange(compact_options, &first_slice, &last_slice);
+ ASSERT_OK(db_->CompactRange(compact_options, &first_slice, &last_slice));
// 1 sst after compaction
CheckFileTypeCounts(dbname_, 0, 1, 1);
// this time, we keep an iterator alive
- ReopenDB(true);
- Iterator *itr = nullptr;
+ Reopen(options);
+ Iterator* itr = nullptr;
CreateTwoLevels();
itr = db_->NewIterator(ReadOptions());
- db_->CompactRange(compact_options, &first_slice, &last_slice);
+ ASSERT_OK(itr->status());
+ ASSERT_OK(db_->CompactRange(compact_options, &first_slice, &last_slice));
+ ASSERT_OK(itr->status());
// 3 sst after compaction with live iterator
CheckFileTypeCounts(dbname_, 0, 3, 1);
delete itr;
// 1 sst after iterator deletion
CheckFileTypeCounts(dbname_, 0, 1, 1);
-
- CloseDB();
}
TEST_F(DeleteFileTest, BackgroundPurgeIteratorTest) {
+ Options options = CurrentOptions();
+ SetOptions(&options);
+ Destroy(options);
+ options.create_if_missing = true;
+ Reopen(options);
+
std::string first("0"), last("999999");
CompactRangeOptions compact_options;
compact_options.change_level = true;
// We keep an iterator alive
Iterator* itr = nullptr;
CreateTwoLevels();
- ReadOptions options;
- options.background_purge_on_iterator_cleanup = true;
- itr = db_->NewIterator(options);
- db_->CompactRange(compact_options, &first_slice, &last_slice);
+ ReadOptions read_options;
+ read_options.background_purge_on_iterator_cleanup = true;
+ itr = db_->NewIterator(read_options);
+ ASSERT_OK(itr->status());
+ ASSERT_OK(db_->CompactRange(compact_options, &first_slice, &last_slice));
// 3 sst after compaction with live iterator
CheckFileTypeCounts(dbname_, 0, 3, 1);
test::SleepingBackgroundTask sleeping_task_before;
sleeping_task_after.WaitUntilDone();
// 1 sst after iterator deletion
CheckFileTypeCounts(dbname_, 0, 1, 1);
+}
- CloseDB();
+TEST_F(DeleteFileTest, PurgeDuringOpen) {
+ Options options = CurrentOptions();
+ CheckFileTypeCounts(dbname_, -1, 0, -1);
+ Close();
+ std::unique_ptr<WritableFile> file;
+ ASSERT_OK(options.env->NewWritableFile(dbname_ + "/000002.sst", &file,
+ EnvOptions()));
+ ASSERT_OK(file->Close());
+ CheckFileTypeCounts(dbname_, -1, 1, -1);
+ options.avoid_unnecessary_blocking_io = false;
+ options.create_if_missing = false;
+ Reopen(options);
+ CheckFileTypeCounts(dbname_, -1, 0, -1);
+ Close();
+
+ // test background purge
+ options.avoid_unnecessary_blocking_io = true;
+ options.create_if_missing = false;
+ ASSERT_OK(options.env->NewWritableFile(dbname_ + "/000002.sst", &file,
+ EnvOptions()));
+ ASSERT_OK(file->Close());
+ CheckFileTypeCounts(dbname_, -1, 1, -1);
+ SyncPoint::GetInstance()->DisableProcessing();
+ SyncPoint::GetInstance()->ClearAllCallBacks();
+ SyncPoint::GetInstance()->LoadDependency(
+ {{"DeleteFileTest::PurgeDuringOpen:1", "DBImpl::BGWorkPurge:start"}});
+ SyncPoint::GetInstance()->EnableProcessing();
+ Reopen(options);
+ // the obsolete file is not deleted until the background purge job is ran
+ CheckFileTypeCounts(dbname_, -1, 1, -1);
+ TEST_SYNC_POINT("DeleteFileTest::PurgeDuringOpen:1");
+ ASSERT_OK(dbfull()->TEST_WaitForPurge());
+ CheckFileTypeCounts(dbname_, -1, 0, -1);
}
TEST_F(DeleteFileTest, BackgroundPurgeCFDropTest) {
+ Options options = CurrentOptions();
+ SetOptions(&options);
+ Destroy(options);
+ options.create_if_missing = true;
+ Reopen(options);
+
auto do_test = [&](bool bg_purge) {
ColumnFamilyOptions co;
+ co.max_write_buffer_size_to_maintain =
+ static_cast<int64_t>(co.write_buffer_size);
WriteOptions wo;
FlushOptions fo;
ColumnFamilyHandle* cfh = nullptr;
&sleeping_task_after, Env::Priority::HIGH);
// If background purge is enabled, the file should still be there.
CheckFileTypeCounts(dbname_, 0, bg_purge ? 1 : 0, 1);
+ TEST_SYNC_POINT("DeleteFileTest::BackgroundPurgeCFDropTest:1");
// Execute background purges.
sleeping_task_after.WakeUp();
do_test(false);
}
- options_.avoid_unnecessary_blocking_io = true;
- ASSERT_OK(ReopenDB(false));
+ options.avoid_unnecessary_blocking_io = true;
+ options.create_if_missing = false;
+ Reopen(options);
+ ASSERT_OK(dbfull()->TEST_WaitForPurge());
+
+ SyncPoint::GetInstance()->DisableProcessing();
+ SyncPoint::GetInstance()->ClearAllCallBacks();
+ SyncPoint::GetInstance()->LoadDependency(
+ {{"DeleteFileTest::BackgroundPurgeCFDropTest:1",
+ "DBImpl::BGWorkPurge:start"}});
+ SyncPoint::GetInstance()->EnableProcessing();
+
{
SCOPED_TRACE("avoid_unnecessary_blocking_io = true");
do_test(true);
}
-
- CloseDB();
}
// This test is to reproduce a bug that read invalid ReadOption in iterator
// cleanup function
TEST_F(DeleteFileTest, BackgroundPurgeCopyOptions) {
+ Options options = CurrentOptions();
+ SetOptions(&options);
+ Destroy(options);
+ options.create_if_missing = true;
+ Reopen(options);
+
std::string first("0"), last("999999");
CompactRangeOptions compact_options;
compact_options.change_level = true;
// We keep an iterator alive
Iterator* itr = nullptr;
CreateTwoLevels();
- ReadOptions* options = new ReadOptions();
- options->background_purge_on_iterator_cleanup = true;
- itr = db_->NewIterator(*options);
- // ReadOptions is deleted, but iterator cleanup function should not be
- // affected
- delete options;
-
- db_->CompactRange(compact_options, &first_slice, &last_slice);
+ {
+ ReadOptions read_options;
+ read_options.background_purge_on_iterator_cleanup = true;
+ itr = db_->NewIterator(read_options);
+ ASSERT_OK(itr->status());
+ // ReadOptions is deleted, but iterator cleanup function should not be
+ // affected
+ }
+
+ ASSERT_OK(db_->CompactRange(compact_options, &first_slice, &last_slice));
// 3 sst after compaction with live iterator
CheckFileTypeCounts(dbname_, 0, 3, 1);
delete itr;
sleeping_task_after.WaitUntilDone();
// 1 sst after iterator deletion
CheckFileTypeCounts(dbname_, 0, 1, 1);
-
- CloseDB();
}
TEST_F(DeleteFileTest, BackgroundPurgeTestMultipleJobs) {
+ Options options = CurrentOptions();
+ SetOptions(&options);
+ Destroy(options);
+ options.create_if_missing = true;
+ Reopen(options);
+
std::string first("0"), last("999999");
CompactRangeOptions compact_options;
compact_options.change_level = true;
// We keep an iterator alive
CreateTwoLevels();
- ReadOptions options;
- options.background_purge_on_iterator_cleanup = true;
- Iterator* itr1 = db_->NewIterator(options);
+ ReadOptions read_options;
+ read_options.background_purge_on_iterator_cleanup = true;
+ Iterator* itr1 = db_->NewIterator(read_options);
+ ASSERT_OK(itr1->status());
CreateTwoLevels();
- Iterator* itr2 = db_->NewIterator(options);
- db_->CompactRange(compact_options, &first_slice, &last_slice);
+ Iterator* itr2 = db_->NewIterator(read_options);
+ ASSERT_OK(itr2->status());
+ ASSERT_OK(db_->CompactRange(compact_options, &first_slice, &last_slice));
// 5 sst files after 2 compactions with 2 live iterators
CheckFileTypeCounts(dbname_, 0, 5, 1);
+ ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
// ~DBImpl should wait until all BGWorkPurge are finished
- rocksdb::SyncPoint::GetInstance()->LoadDependency(
+ ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->LoadDependency(
{{"DBImpl::~DBImpl:WaitJob", "DBImpl::BGWorkPurge"},
{"DeleteFileTest::GuardFinish",
"DeleteFileTest::BackgroundPurgeTestMultipleJobs:DBClose"}});
- rocksdb::SyncPoint::GetInstance()->EnableProcessing();
+ ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
delete itr1;
env_->Schedule(&DeleteFileTest::DoSleep, this, Env::Priority::HIGH);
delete itr2;
env_->Schedule(&DeleteFileTest::GuardFinish, nullptr, Env::Priority::HIGH);
- CloseDB();
+ Close();
TEST_SYNC_POINT("DeleteFileTest::BackgroundPurgeTestMultipleJobs:DBClose");
// 1 sst after iterator deletion
CheckFileTypeCounts(dbname_, 0, 1, 1);
- rocksdb::SyncPoint::GetInstance()->DisableProcessing();
}
TEST_F(DeleteFileTest, DeleteFileWithIterator) {
+ Options options = CurrentOptions();
+ SetOptions(&options);
+ Destroy(options);
+ options.create_if_missing = true;
+ Reopen(options);
+
CreateTwoLevels();
- ReadOptions options;
- Iterator* it = db_->NewIterator(options);
+ ReadOptions read_options;
+ Iterator* it = db_->NewIterator(read_options);
+ ASSERT_OK(it->status());
std::vector<LiveFileMetaData> metadata;
db_->GetLiveFilesMetaData(&metadata);
- std::string level2file = "";
+ std::string level2file;
- ASSERT_EQ((int)metadata.size(), 2);
+ ASSERT_EQ(metadata.size(), static_cast<size_t>(2));
if (metadata[0].level == 1) {
level2file = metadata[1].name;
} else {
}
Status status = db_->DeleteFile(level2file);
- fprintf(stdout, "Deletion status %s: %s\n",
- level2file.c_str(), status.ToString().c_str());
- ASSERT_TRUE(status.ok());
+ fprintf(stdout, "Deletion status %s: %s\n", level2file.c_str(),
+ status.ToString().c_str());
+ ASSERT_OK(status);
it->SeekToFirst();
int numKeysIterated = 0;
- while(it->Valid()) {
+ while (it->Valid()) {
numKeysIterated++;
it->Next();
}
ASSERT_EQ(numKeysIterated, 50000);
delete it;
- CloseDB();
}
TEST_F(DeleteFileTest, DeleteLogFiles) {
+ Options options = CurrentOptions();
+ SetOptions(&options);
+ Destroy(options);
+ options.create_if_missing = true;
+ Reopen(options);
+
AddKeys(10, 0);
VectorLogPtr logfiles;
- db_->GetSortedWalFiles(logfiles);
+ ASSERT_OK(db_->GetSortedWalFiles(logfiles));
ASSERT_GT(logfiles.size(), 0UL);
// Take the last log file which is expected to be alive and try to delete it
// Should not succeed because live logs are not allowed to be deleted
std::unique_ptr<LogFile> alive_log = std::move(logfiles.back());
ASSERT_EQ(alive_log->Type(), kAliveLogFile);
- ASSERT_OK(env_->FileExists(options_.wal_dir + "/" + alive_log->PathName()));
+ ASSERT_OK(env_->FileExists(wal_dir_ + "/" + alive_log->PathName()));
fprintf(stdout, "Deleting alive log file %s\n",
alive_log->PathName().c_str());
- ASSERT_TRUE(!db_->DeleteFile(alive_log->PathName()).ok());
- ASSERT_OK(env_->FileExists(options_.wal_dir + "/" + alive_log->PathName()));
+ ASSERT_NOK(db_->DeleteFile(alive_log->PathName()));
+ ASSERT_OK(env_->FileExists(wal_dir_ + "/" + alive_log->PathName()));
logfiles.clear();
// Call Flush to bring about a new working log file and add more keys
// Call Flush again to flush out memtable and move alive log to archived log
// and try to delete the archived log file
FlushOptions fopts;
- db_->Flush(fopts);
+ ASSERT_OK(db_->Flush(fopts));
AddKeys(10, 0);
- db_->Flush(fopts);
- db_->GetSortedWalFiles(logfiles);
+ ASSERT_OK(db_->Flush(fopts));
+ ASSERT_OK(db_->GetSortedWalFiles(logfiles));
ASSERT_GT(logfiles.size(), 0UL);
std::unique_ptr<LogFile> archived_log = std::move(logfiles.front());
ASSERT_EQ(archived_log->Type(), kArchivedLogFile);
- ASSERT_OK(
- env_->FileExists(options_.wal_dir + "/" + archived_log->PathName()));
+ ASSERT_OK(env_->FileExists(wal_dir_ + "/" + archived_log->PathName()));
fprintf(stdout, "Deleting archived log file %s\n",
archived_log->PathName().c_str());
ASSERT_OK(db_->DeleteFile(archived_log->PathName()));
- ASSERT_EQ(Status::NotFound(), env_->FileExists(options_.wal_dir + "/" +
- archived_log->PathName()));
- CloseDB();
+ ASSERT_TRUE(
+ env_->FileExists(wal_dir_ + "/" + archived_log->PathName()).IsNotFound());
}
TEST_F(DeleteFileTest, DeleteNonDefaultColumnFamily) {
- CloseDB();
- DBOptions db_options;
- db_options.create_if_missing = true;
- db_options.create_missing_column_families = true;
- std::vector<ColumnFamilyDescriptor> column_families;
- column_families.emplace_back();
- column_families.emplace_back("new_cf", ColumnFamilyOptions());
-
- std::vector<rocksdb::ColumnFamilyHandle*> handles;
- rocksdb::DB* db;
- ASSERT_OK(DB::Open(db_options, dbname_, column_families, &handles, &db));
+ Options options = CurrentOptions();
+ SetOptions(&options);
+ Destroy(options);
+ options.create_if_missing = true;
+ Reopen(options);
+ CreateAndReopenWithCF({"new_cf"}, options);
Random rnd(5);
for (int i = 0; i < 1000; ++i) {
- ASSERT_OK(db->Put(WriteOptions(), handles[1], test::RandomKey(&rnd, 10),
- test::RandomKey(&rnd, 10)));
+ ASSERT_OK(db_->Put(WriteOptions(), handles_[1], test::RandomKey(&rnd, 10),
+ test::RandomKey(&rnd, 10)));
}
- ASSERT_OK(db->Flush(FlushOptions(), handles[1]));
+ ASSERT_OK(db_->Flush(FlushOptions(), handles_[1]));
for (int i = 0; i < 1000; ++i) {
- ASSERT_OK(db->Put(WriteOptions(), handles[1], test::RandomKey(&rnd, 10),
- test::RandomKey(&rnd, 10)));
+ ASSERT_OK(db_->Put(WriteOptions(), handles_[1], test::RandomKey(&rnd, 10),
+ test::RandomKey(&rnd, 10)));
}
- ASSERT_OK(db->Flush(FlushOptions(), handles[1]));
+ ASSERT_OK(db_->Flush(FlushOptions(), handles_[1]));
std::vector<LiveFileMetaData> metadata;
- db->GetLiveFilesMetaData(&metadata);
+ db_->GetLiveFilesMetaData(&metadata);
ASSERT_EQ(2U, metadata.size());
ASSERT_EQ("new_cf", metadata[0].column_family_name);
ASSERT_EQ("new_cf", metadata[1].column_family_name);
auto new_file = metadata[0].smallest_seqno > metadata[1].smallest_seqno
? metadata[0].name
: metadata[1].name;
- ASSERT_TRUE(db->DeleteFile(new_file).IsInvalidArgument());
- ASSERT_OK(db->DeleteFile(old_file));
+ ASSERT_TRUE(db_->DeleteFile(new_file).IsInvalidArgument());
+ ASSERT_OK(db_->DeleteFile(old_file));
{
- std::unique_ptr<Iterator> itr(db->NewIterator(ReadOptions(), handles[1]));
+ std::unique_ptr<Iterator> itr(db_->NewIterator(ReadOptions(), handles_[1]));
+ ASSERT_OK(itr->status());
int count = 0;
for (itr->SeekToFirst(); itr->Valid(); itr->Next()) {
ASSERT_OK(itr->status());
ASSERT_EQ(count, 1000);
}
- delete handles[0];
- delete handles[1];
- delete db;
+ Close();
+ ReopenWithColumnFamilies({kDefaultColumnFamilyName, "new_cf"}, options);
- ASSERT_OK(DB::Open(db_options, dbname_, column_families, &handles, &db));
{
- std::unique_ptr<Iterator> itr(db->NewIterator(ReadOptions(), handles[1]));
+ std::unique_ptr<Iterator> itr(db_->NewIterator(ReadOptions(), handles_[1]));
int count = 0;
for (itr->SeekToFirst(); itr->Valid(); itr->Next()) {
ASSERT_OK(itr->status());
}
ASSERT_EQ(count, 1000);
}
-
- delete handles[0];
- delete handles[1];
- delete db;
}
-} //namespace rocksdb
+} // namespace ROCKSDB_NAMESPACE
int main(int argc, char** argv) {
+ ROCKSDB_NAMESPACE::port::InstallStackTraceHandler();
::testing::InitGoogleTest(&argc, argv);
+ RegisterCustomObjects(argc, argv);
return RUN_ALL_TESTS();
}
projects / ceph.git / blobdiff