db_test.cc 340.9 KB
Newer Older
1 2 3 4 5
//  Copyright (c) 2013, Facebook, Inc.  All rights reserved.
//  This source code is licensed under the BSD-style license found in the
//  LICENSE file in the root directory of this source tree. An additional grant
//  of patent rights can be found in the PATENTS file in the same directory.
//
J
jorlow@chromium.org 已提交
6 7 8 9
// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file. See the AUTHORS file for names of contributors.

S
sdong 已提交
10 11
// Introduction of SyncPoint effectively disabled building and running this test
// in Release build.
D
Dmitri Smirnov 已提交
12
// which is a pity, it is a good test
S
sdong 已提交
13
#if !(defined NDEBUG) || !defined(OS_WIN)
D
Dmitri Smirnov 已提交
14

15
#include <algorithm>
16
#include <iostream>
17
#include <set>
18
#include <thread>
19
#include <unordered_set>
S
Stanislau Hlebik 已提交
20
#include <utility>
K
krad 已提交
21
#include <fcntl.h>
S
sdong 已提交
22 23 24
#ifndef OS_WIN
#include <unistd.h>
#endif
25

26
#include "db/filename.h"
27
#include "db/dbformat.h"
J
jorlow@chromium.org 已提交
28 29
#include "db/db_impl.h"
#include "db/filename.h"
I
Igor Canadi 已提交
30
#include "db/job_context.h"
J
jorlow@chromium.org 已提交
31 32
#include "db/version_set.h"
#include "db/write_batch_internal.h"
I
Igor Canadi 已提交
33
#include "port/stack_trace.h"
34 35
#include "rocksdb/cache.h"
#include "rocksdb/compaction_filter.h"
K
Kai Liu 已提交
36
#include "rocksdb/db.h"
37
#include "rocksdb/env.h"
38
#include "rocksdb/experimental.h"
K
Kai Liu 已提交
39
#include "rocksdb/filter_policy.h"
40
#include "rocksdb/perf_context.h"
41 42
#include "rocksdb/slice.h"
#include "rocksdb/slice_transform.h"
S
Siying Dong 已提交
43
#include "rocksdb/table.h"
L
Lei Jin 已提交
44
#include "rocksdb/options.h"
45
#include "rocksdb/table_properties.h"
Y
Yueh-Hsuan Chiang 已提交
46
#include "rocksdb/thread_status.h"
47
#include "rocksdb/utilities/write_batch_with_index.h"
48
#include "rocksdb/utilities/checkpoint.h"
49
#include "rocksdb/utilities/convenience.h"
A
agiardullo 已提交
50
#include "rocksdb/utilities/optimistic_transaction_db.h"
K
kailiu 已提交
51
#include "table/block_based_table_factory.h"
52
#include "table/mock_table.h"
53
#include "table/plain_table_factory.h"
54
#include "util/db_test_util.h"
S
Sanjay Ghemawat 已提交
55
#include "util/hash.h"
K
Kai Liu 已提交
56
#include "util/hash_linklist_rep.h"
57
#include "utilities/merge_operators.h"
J
jorlow@chromium.org 已提交
58
#include "util/logging.h"
I
Igor Canadi 已提交
59
#include "util/compression.h"
60
#include "util/mutexlock.h"
L
Lei Jin 已提交
61
#include "util/rate_limiter.h"
K
Kai Liu 已提交
62
#include "util/statistics.h"
J
jorlow@chromium.org 已提交
63
#include "util/testharness.h"
64
#include "util/scoped_arena_iterator.h"
65
#include "util/sync_point.h"
J
jorlow@chromium.org 已提交
66
#include "util/testutil.h"
67
#include "util/mock_env.h"
68
#include "util/string_util.h"
69
#include "util/thread_status_util.h"
70
#include "util/xfunc.h"
J
jorlow@chromium.org 已提交
71

72
namespace rocksdb {
J
jorlow@chromium.org 已提交
73

I
Igor Canadi 已提交
74 75 76 77
static long TestGetTickerCount(const Options& options, Tickers ticker_type) {
  return options.statistics->getTickerCount(ticker_type);
}

78 79
// A helper function that ensures the table properties returned in
// `GetPropertiesOfAllTablesTest` is correct.
C
clark.kang 已提交
80
// This test assumes entries size is different for each of the tables.
I
Igor Canadi 已提交
81
namespace {
82 83 84 85
void VerifyTableProperties(DB* db, uint64_t expected_entries_size) {
  TablePropertiesCollection props;
  ASSERT_OK(db->GetPropertiesOfAllTables(&props));

I
Igor Canadi 已提交
86
  ASSERT_EQ(4U, props.size());
87 88 89 90 91 92 93 94 95 96 97 98
  std::unordered_set<uint64_t> unique_entries;

  // Indirect test
  uint64_t sum = 0;
  for (const auto& item : props) {
    unique_entries.insert(item.second->num_entries);
    sum += item.second->num_entries;
  }

  ASSERT_EQ(props.size(), unique_entries.size());
  ASSERT_EQ(expected_entries_size, sum);
}
I
Igor Canadi 已提交
99 100 101 102 103 104 105 106 107 108 109

uint64_t GetNumberOfSstFilesForColumnFamily(DB* db,
                                            std::string column_family_name) {
  std::vector<LiveFileMetaData> metadata;
  db->GetLiveFilesMetaData(&metadata);
  uint64_t result = 0;
  for (auto& fileMetadata : metadata) {
    result += (fileMetadata.column_family_name == column_family_name);
  }
  return result;
}
I
Igor Canadi 已提交
110
}  // namespace
111

112 113 114 115 116
class DBTest : public DBTestBase {
 public:
  DBTest() : DBTestBase("/db_test") {}
};

I
Igor Sugak 已提交
117
TEST_F(DBTest, Empty) {
S
Sanjay Ghemawat 已提交
118
  do {
119
    Options options;
K
kailiu 已提交
120 121
    options.env = env_;
    options.write_buffer_size = 100000;  // Small write buffer
122
    options = CurrentOptions(options);
L
Lei Jin 已提交
123
    CreateAndReopenWithCF({"pikachu"}, options);
J
jorlow@chromium.org 已提交
124

125 126 127 128 129
    std::string num;
    ASSERT_TRUE(dbfull()->GetProperty(
        handles_[1], "rocksdb.num-entries-active-mem-table", &num));
    ASSERT_EQ("0", num);

130 131
    ASSERT_OK(Put(1, "foo", "v1"));
    ASSERT_EQ("v1", Get(1, "foo"));
132 133 134
    ASSERT_TRUE(dbfull()->GetProperty(
        handles_[1], "rocksdb.num-entries-active-mem-table", &num));
    ASSERT_EQ("1", num);
K
kailiu 已提交
135

I
Igor Canadi 已提交
136 137
    // Block sync calls
    env_->delay_sstable_sync_.store(true, std::memory_order_release);
138
    Put(1, "k1", std::string(100000, 'x'));         // Fill memtable
139 140 141 142
    ASSERT_TRUE(dbfull()->GetProperty(
        handles_[1], "rocksdb.num-entries-active-mem-table", &num));
    ASSERT_EQ("2", num);

143
    Put(1, "k2", std::string(100000, 'y'));         // Trigger compaction
144 145 146 147
    ASSERT_TRUE(dbfull()->GetProperty(
        handles_[1], "rocksdb.num-entries-active-mem-table", &num));
    ASSERT_EQ("1", num);

148
    ASSERT_EQ("v1", Get(1, "foo"));
I
Igor Canadi 已提交
149 150
    // Release sync calls
    env_->delay_sstable_sync_.store(false, std::memory_order_release);
151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175

    ASSERT_OK(db_->DisableFileDeletions());
    ASSERT_TRUE(
        dbfull()->GetProperty("rocksdb.is-file-deletions-enabled", &num));
    ASSERT_EQ("1", num);

    ASSERT_OK(db_->DisableFileDeletions());
    ASSERT_TRUE(
        dbfull()->GetProperty("rocksdb.is-file-deletions-enabled", &num));
    ASSERT_EQ("2", num);

    ASSERT_OK(db_->DisableFileDeletions());
    ASSERT_TRUE(
        dbfull()->GetProperty("rocksdb.is-file-deletions-enabled", &num));
    ASSERT_EQ("3", num);

    ASSERT_OK(db_->EnableFileDeletions(false));
    ASSERT_TRUE(
        dbfull()->GetProperty("rocksdb.is-file-deletions-enabled", &num));
    ASSERT_EQ("2", num);

    ASSERT_OK(db_->EnableFileDeletions());
    ASSERT_TRUE(
        dbfull()->GetProperty("rocksdb.is-file-deletions-enabled", &num));
    ASSERT_EQ("0", num);
S
Sanjay Ghemawat 已提交
176
  } while (ChangeOptions());
J
jorlow@chromium.org 已提交
177 178
}

I
Igor Sugak 已提交
179
TEST_F(DBTest, WriteEmptyBatch) {
180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199
  Options options;
  options.env = env_;
  options.write_buffer_size = 100000;
  options = CurrentOptions(options);
  CreateAndReopenWithCF({"pikachu"}, options);

  ASSERT_OK(Put(1, "foo", "bar"));
  env_->sync_counter_.store(0);
  WriteOptions wo;
  wo.sync = true;
  wo.disableWAL = false;
  WriteBatch empty_batch;
  ASSERT_OK(dbfull()->Write(wo, &empty_batch));
  ASSERT_GE(env_->sync_counter_.load(), 1);

  // make sure we can re-open it.
  ASSERT_OK(TryReopenWithColumnFamilies({"default", "pikachu"}, options));
  ASSERT_EQ("bar", Get(1, "foo"));
}

I
Igor Sugak 已提交
200
TEST_F(DBTest, ReadOnlyDB) {
201 202 203 204 205
  ASSERT_OK(Put("foo", "v1"));
  ASSERT_OK(Put("bar", "v2"));
  ASSERT_OK(Put("foo", "v3"));
  Close();

206 207 208
  auto options = CurrentOptions();
  assert(options.env = env_);
  ASSERT_OK(ReadOnlyReopen(options));
209 210 211 212 213 214 215 216 217 218
  ASSERT_EQ("v3", Get("foo"));
  ASSERT_EQ("v2", Get("bar"));
  Iterator* iter = db_->NewIterator(ReadOptions());
  int count = 0;
  for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
    ASSERT_OK(iter->status());
    ++count;
  }
  ASSERT_EQ(count, 2);
  delete iter;
219 220 221
  Close();

  // Reopen and flush memtable.
L
Lei Jin 已提交
222
  Reopen(options);
223 224 225
  Flush();
  Close();
  // Now check keys in read only mode.
226
  ASSERT_OK(ReadOnlyReopen(options));
227 228
  ASSERT_EQ("v3", Get("foo"));
  ASSERT_EQ("v2", Get("bar"));
229 230
}

I
Igor Sugak 已提交
231
TEST_F(DBTest, CompactedDB) {
L
Lei Jin 已提交
232 233 234 235 236 237 238 239
  const uint64_t kFileSize = 1 << 20;
  Options options;
  options.disable_auto_compactions = true;
  options.max_mem_compaction_level = 0;
  options.write_buffer_size = kFileSize;
  options.target_file_size_base = kFileSize;
  options.max_bytes_for_level_base = 1 << 30;
  options.compression = kNoCompression;
240
  options = CurrentOptions(options);
L
Lei Jin 已提交
241
  Reopen(options);
L
Lei Jin 已提交
242 243 244 245
  // 1 L0 file, use CompactedDB if max_open_files = -1
  ASSERT_OK(Put("aaa", DummyString(kFileSize / 2, '1')));
  Flush();
  Close();
246
  ASSERT_OK(ReadOnlyReopen(options));
L
Lei Jin 已提交
247 248 249 250 251 252
  Status s = Put("new", "value");
  ASSERT_EQ(s.ToString(),
            "Not implemented: Not supported operation in read only mode.");
  ASSERT_EQ(DummyString(kFileSize / 2, '1'), Get("aaa"));
  Close();
  options.max_open_files = -1;
253
  ASSERT_OK(ReadOnlyReopen(options));
L
Lei Jin 已提交
254 255 256 257 258
  s = Put("new", "value");
  ASSERT_EQ(s.ToString(),
            "Not implemented: Not supported in compacted db mode.");
  ASSERT_EQ(DummyString(kFileSize / 2, '1'), Get("aaa"));
  Close();
L
Lei Jin 已提交
259
  Reopen(options);
L
Lei Jin 已提交
260 261 262 263 264 265
  // Add more L0 files
  ASSERT_OK(Put("bbb", DummyString(kFileSize / 2, '2')));
  Flush();
  ASSERT_OK(Put("aaa", DummyString(kFileSize / 2, 'a')));
  Flush();
  ASSERT_OK(Put("bbb", DummyString(kFileSize / 2, 'b')));
266
  ASSERT_OK(Put("eee", DummyString(kFileSize / 2, 'e')));
L
Lei Jin 已提交
267 268 269
  Flush();
  Close();

270
  ASSERT_OK(ReadOnlyReopen(options));
L
Lei Jin 已提交
271 272 273 274 275 276 277
  // Fallback to read-only DB
  s = Put("new", "value");
  ASSERT_EQ(s.ToString(),
            "Not implemented: Not supported operation in read only mode.");
  Close();

  // Full compaction
L
Lei Jin 已提交
278
  Reopen(options);
L
Lei Jin 已提交
279 280 281 282 283
  // Add more keys
  ASSERT_OK(Put("fff", DummyString(kFileSize / 2, 'f')));
  ASSERT_OK(Put("hhh", DummyString(kFileSize / 2, 'h')));
  ASSERT_OK(Put("iii", DummyString(kFileSize / 2, 'i')));
  ASSERT_OK(Put("jjj", DummyString(kFileSize / 2, 'j')));
284
  db_->CompactRange(CompactRangeOptions(), nullptr, nullptr);
L
Lei Jin 已提交
285 286 287 288
  ASSERT_EQ(3, NumTableFilesAtLevel(1));
  Close();

  // CompactedDB
289
  ASSERT_OK(ReadOnlyReopen(options));
L
Lei Jin 已提交
290 291 292 293 294 295 296 297 298 299 300 301 302 303
  s = Put("new", "value");
  ASSERT_EQ(s.ToString(),
            "Not implemented: Not supported in compacted db mode.");
  ASSERT_EQ("NOT_FOUND", Get("abc"));
  ASSERT_EQ(DummyString(kFileSize / 2, 'a'), Get("aaa"));
  ASSERT_EQ(DummyString(kFileSize / 2, 'b'), Get("bbb"));
  ASSERT_EQ("NOT_FOUND", Get("ccc"));
  ASSERT_EQ(DummyString(kFileSize / 2, 'e'), Get("eee"));
  ASSERT_EQ(DummyString(kFileSize / 2, 'f'), Get("fff"));
  ASSERT_EQ("NOT_FOUND", Get("ggg"));
  ASSERT_EQ(DummyString(kFileSize / 2, 'h'), Get("hhh"));
  ASSERT_EQ(DummyString(kFileSize / 2, 'i'), Get("iii"));
  ASSERT_EQ(DummyString(kFileSize / 2, 'j'), Get("jjj"));
  ASSERT_EQ("NOT_FOUND", Get("kkk"));
304 305 306 307 308 309 310

  // MultiGet
  std::vector<std::string> values;
  std::vector<Status> status_list = dbfull()->MultiGet(ReadOptions(),
      std::vector<Slice>({Slice("aaa"), Slice("ccc"), Slice("eee"),
                          Slice("ggg"), Slice("iii"), Slice("kkk")}),
      &values);
311 312
  ASSERT_EQ(status_list.size(), static_cast<uint64_t>(6));
  ASSERT_EQ(values.size(), static_cast<uint64_t>(6));
313 314 315 316 317 318 319 320 321
  ASSERT_OK(status_list[0]);
  ASSERT_EQ(DummyString(kFileSize / 2, 'a'), values[0]);
  ASSERT_TRUE(status_list[1].IsNotFound());
  ASSERT_OK(status_list[2]);
  ASSERT_EQ(DummyString(kFileSize / 2, 'e'), values[2]);
  ASSERT_TRUE(status_list[3].IsNotFound());
  ASSERT_OK(status_list[4]);
  ASSERT_EQ(DummyString(kFileSize / 2, 'i'), values[4]);
  ASSERT_TRUE(status_list[5].IsNotFound());
L
Lei Jin 已提交
322 323
}

K
Kai Liu 已提交
324 325
// Make sure that when options.block_cache is set, after a new table is
// created its index/filter blocks are added to block cache.
I
Igor Sugak 已提交
326
TEST_F(DBTest, IndexAndFilterBlocksOfNewTableAddedToCache) {
K
Kai Liu 已提交
327 328 329
  Options options = CurrentOptions();
  options.create_if_missing = true;
  options.statistics = rocksdb::CreateDBStatistics();
330 331
  BlockBasedTableOptions table_options;
  table_options.cache_index_and_filter_blocks = true;
332
  table_options.filter_policy.reset(NewBloomFilterPolicy(20));
333
  options.table_factory.reset(new BlockBasedTableFactory(table_options));
L
Lei Jin 已提交
334
  CreateAndReopenWithCF({"pikachu"}, options);
K
Kai Liu 已提交
335

336 337 338
  ASSERT_OK(Put(1, "key", "val"));
  // Create a new table.
  ASSERT_OK(Flush(1));
K
Kai Liu 已提交
339 340

  // index/filter blocks added to block cache right after table creation.
I
Igor Canadi 已提交
341 342
  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_INDEX_MISS));
  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_FILTER_MISS));
K
Kai Liu 已提交
343
  ASSERT_EQ(2, /* only index/filter were added */
I
Igor Canadi 已提交
344 345
            TestGetTickerCount(options, BLOCK_CACHE_ADD));
  ASSERT_EQ(0, TestGetTickerCount(options, BLOCK_CACHE_DATA_MISS));
346 347 348 349
  uint64_t int_num;
  ASSERT_TRUE(
      dbfull()->GetIntProperty("rocksdb.estimate-table-readers-mem", &int_num));
  ASSERT_EQ(int_num, 0U);
K
Kai Liu 已提交
350 351 352 353

  // Make sure filter block is in cache.
  std::string value;
  ReadOptions ropt;
354
  db_->KeyMayExist(ReadOptions(), handles_[1], "key", &value);
K
Kai Liu 已提交
355 356

  // Miss count should remain the same.
I
Igor Canadi 已提交
357 358
  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_FILTER_MISS));
  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_FILTER_HIT));
K
Kai Liu 已提交
359

360
  db_->KeyMayExist(ReadOptions(), handles_[1], "key", &value);
I
Igor Canadi 已提交
361 362
  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_FILTER_MISS));
  ASSERT_EQ(2, TestGetTickerCount(options, BLOCK_CACHE_FILTER_HIT));
K
Kai Liu 已提交
363 364

  // Make sure index block is in cache.
I
Igor Canadi 已提交
365
  auto index_block_hit = TestGetTickerCount(options, BLOCK_CACHE_FILTER_HIT);
366
  value = Get(1, "key");
I
Igor Canadi 已提交
367
  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_FILTER_MISS));
K
Kai Liu 已提交
368
  ASSERT_EQ(index_block_hit + 1,
I
Igor Canadi 已提交
369
            TestGetTickerCount(options, BLOCK_CACHE_FILTER_HIT));
K
Kai Liu 已提交
370

371
  value = Get(1, "key");
I
Igor Canadi 已提交
372
  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_FILTER_MISS));
K
Kai Liu 已提交
373
  ASSERT_EQ(index_block_hit + 2,
I
Igor Canadi 已提交
374
            TestGetTickerCount(options, BLOCK_CACHE_FILTER_HIT));
K
Kai Liu 已提交
375 376
}

377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420
TEST_F(DBTest, ParanoidFileChecks) {
  Options options = CurrentOptions();
  options.create_if_missing = true;
  options.statistics = rocksdb::CreateDBStatistics();
  options.level0_file_num_compaction_trigger = 2;
  options.paranoid_file_checks = true;
  BlockBasedTableOptions table_options;
  table_options.cache_index_and_filter_blocks = false;
  table_options.filter_policy.reset(NewBloomFilterPolicy(20));
  options.table_factory.reset(new BlockBasedTableFactory(table_options));
  CreateAndReopenWithCF({"pikachu"}, options);

  ASSERT_OK(Put(1, "1_key", "val"));
  ASSERT_OK(Put(1, "9_key", "val"));
  // Create a new table.
  ASSERT_OK(Flush(1));
  ASSERT_EQ(1, /* read and cache data block */
            TestGetTickerCount(options, BLOCK_CACHE_ADD));

  ASSERT_OK(Put(1, "1_key2", "val2"));
  ASSERT_OK(Put(1, "9_key2", "val2"));
  // Create a new SST file. This will further trigger a compaction
  // and generate another file.
  ASSERT_OK(Flush(1));
  dbfull()->TEST_WaitForCompact();
  ASSERT_EQ(3, /* Totally 3 files created up to now */
            TestGetTickerCount(options, BLOCK_CACHE_ADD));

  // After disabling options.paranoid_file_checks. NO further block
  // is added after generating a new file.
  ASSERT_OK(
      dbfull()->SetOptions(handles_[1], {{"paranoid_file_checks", "false"}}));

  ASSERT_OK(Put(1, "1_key3", "val3"));
  ASSERT_OK(Put(1, "9_key3", "val3"));
  ASSERT_OK(Flush(1));
  ASSERT_OK(Put(1, "1_key4", "val4"));
  ASSERT_OK(Put(1, "9_key4", "val4"));
  ASSERT_OK(Flush(1));
  dbfull()->TEST_WaitForCompact();
  ASSERT_EQ(3, /* Totally 3 files created up to now */
            TestGetTickerCount(options, BLOCK_CACHE_ADD));
}

I
Igor Sugak 已提交
421
TEST_F(DBTest, GetPropertiesOfAllTablesTest) {
422
  Options options = CurrentOptions();
I
Igor Canadi 已提交
423
  options.max_background_flushes = 0;
L
Lei Jin 已提交
424
  Reopen(options);
425 426 427
  // Create 4 tables
  for (int table = 0; table < 4; ++table) {
    for (int i = 0; i < 10 + table; ++i) {
428
      db_->Put(WriteOptions(), ToString(table * 100 + i), "val");
429 430 431 432 433
    }
    db_->Flush(FlushOptions());
  }

  // 1. Read table properties directly from file
L
Lei Jin 已提交
434
  Reopen(options);
435 436 437
  VerifyTableProperties(db_, 10 + 11 + 12 + 13);

  // 2. Put two tables to table cache and
L
Lei Jin 已提交
438
  Reopen(options);
439 440 441
  // fetch key from 1st and 2nd table, which will internally place that table to
  // the table cache.
  for (int i = 0; i < 2; ++i) {
442
    Get(ToString(i * 100 + 0));
443 444 445 446 447
  }

  VerifyTableProperties(db_, 10 + 11 + 12 + 13);

  // 3. Put all tables to table cache
L
Lei Jin 已提交
448
  Reopen(options);
449 450 451
  // fetch key from 1st and 2nd table, which will internally place that table to
  // the table cache.
  for (int i = 0; i < 4; ++i) {
452
    Get(ToString(i * 100 + 0));
453 454 455 456
  }
  VerifyTableProperties(db_, 10 + 11 + 12 + 13);
}

457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528
class CoutingUserTblPropCollector : public TablePropertiesCollector {
 public:
  const char* Name() const override { return "CoutingUserTblPropCollector"; }

  Status Finish(UserCollectedProperties* properties) override {
    std::string encoded;
    PutVarint32(&encoded, count_);
    *properties = UserCollectedProperties{
        {"CoutingUserTblPropCollector", message_}, {"Count", encoded},
    };
    return Status::OK();
  }

  Status AddUserKey(const Slice& user_key, const Slice& value, EntryType type,
                    SequenceNumber seq, uint64_t file_size) override {
    ++count_;
    return Status::OK();
  }

  virtual UserCollectedProperties GetReadableProperties() const override {
    return UserCollectedProperties{};
  }

 private:
  std::string message_ = "Rocksdb";
  uint32_t count_ = 0;
};

class CoutingUserTblPropCollectorFactory
    : public TablePropertiesCollectorFactory {
 public:
  virtual TablePropertiesCollector* CreateTablePropertiesCollector() override {
    return new CoutingUserTblPropCollector();
  }
  const char* Name() const override {
    return "CoutingUserTblPropCollectorFactory";
  }
};

TEST_F(DBTest, GetUserDefinedTablaProperties) {
  Options options = CurrentOptions();
  options.max_background_flushes = 0;
  options.table_properties_collector_factories.resize(1);
  options.table_properties_collector_factories[0] =
      std::make_shared<CoutingUserTblPropCollectorFactory>();
  Reopen(options);
  // Create 4 tables
  for (int table = 0; table < 4; ++table) {
    for (int i = 0; i < 10 + table; ++i) {
      db_->Put(WriteOptions(), ToString(table * 100 + i), "val");
    }
    db_->Flush(FlushOptions());
  }

  TablePropertiesCollection props;
  ASSERT_OK(db_->GetPropertiesOfAllTables(&props));
  ASSERT_EQ(4U, props.size());
  uint32_t sum = 0;
  for (const auto& item : props) {
    auto& user_collected = item.second->user_collected_properties;
    ASSERT_TRUE(user_collected.find("CoutingUserTblPropCollector") !=
                user_collected.end());
    ASSERT_EQ(user_collected.at("CoutingUserTblPropCollector"), "Rocksdb");
    ASSERT_TRUE(user_collected.find("Count") != user_collected.end());
    Slice key(user_collected.at("Count"));
    uint32_t count;
    ASSERT_TRUE(GetVarint32(&key, &count));
    sum += count;
  }
  ASSERT_EQ(10u + 11u + 12u + 13u, sum);
}

I
Igor Sugak 已提交
529
TEST_F(DBTest, LevelLimitReopen) {
530
  Options options = CurrentOptions();
L
Lei Jin 已提交
531
  CreateAndReopenWithCF({"pikachu"}, options);
532 533 534

  const std::string value(1024 * 1024, ' ');
  int i = 0;
535 536
  while (NumTableFilesAtLevel(2, 1) == 0) {
    ASSERT_OK(Put(1, Key(i++), value));
537 538 539
  }

  options.num_levels = 1;
540
  options.max_bytes_for_level_multiplier_additional.resize(1, 1);
L
Lei Jin 已提交
541
  Status s = TryReopenWithColumnFamilies({"default", "pikachu"}, options);
542
  ASSERT_EQ(s.IsInvalidArgument(), true);
543
  ASSERT_EQ(s.ToString(),
544
            "Invalid argument: db has more levels than options.num_levels");
545 546

  options.num_levels = 10;
547
  options.max_bytes_for_level_multiplier_additional.resize(10, 1);
L
Lei Jin 已提交
548
  ASSERT_OK(TryReopenWithColumnFamilies({"default", "pikachu"}, options));
549 550
}

I
Igor Sugak 已提交
551
TEST_F(DBTest, PutDeleteGet) {
S
Sanjay Ghemawat 已提交
552
  do {
L
Lei Jin 已提交
553
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
554 555 556 557 558 559
    ASSERT_OK(Put(1, "foo", "v1"));
    ASSERT_EQ("v1", Get(1, "foo"));
    ASSERT_OK(Put(1, "foo", "v2"));
    ASSERT_EQ("v2", Get(1, "foo"));
    ASSERT_OK(Delete(1, "foo"));
    ASSERT_EQ("NOT_FOUND", Get(1, "foo"));
S
Sanjay Ghemawat 已提交
560
  } while (ChangeOptions());
J
jorlow@chromium.org 已提交
561 562
}

I
Igor Sugak 已提交
563
TEST_F(DBTest, GetFromImmutableLayer) {
S
Sanjay Ghemawat 已提交
564
  do {
565
    Options options;
S
Sanjay Ghemawat 已提交
566 567
    options.env = env_;
    options.write_buffer_size = 100000;  // Small write buffer
568
    options = CurrentOptions(options);
L
Lei Jin 已提交
569
    CreateAndReopenWithCF({"pikachu"}, options);
570

571 572
    ASSERT_OK(Put(1, "foo", "v1"));
    ASSERT_EQ("v1", Get(1, "foo"));
573

I
Igor Canadi 已提交
574 575
    // Block sync calls
    env_->delay_sstable_sync_.store(true, std::memory_order_release);
576 577 578 579
    Put(1, "k1", std::string(100000, 'x'));          // Fill memtable
    Put(1, "k2", std::string(100000, 'y'));          // Trigger flush
    ASSERT_EQ("v1", Get(1, "foo"));
    ASSERT_EQ("NOT_FOUND", Get(0, "foo"));
I
Igor Canadi 已提交
580 581
    // Release sync calls
    env_->delay_sstable_sync_.store(false, std::memory_order_release);
S
Sanjay Ghemawat 已提交
582
  } while (ChangeOptions());
583 584
}

I
Igor Sugak 已提交
585
TEST_F(DBTest, GetFromVersions) {
S
Sanjay Ghemawat 已提交
586
  do {
L
Lei Jin 已提交
587
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
588 589 590 591
    ASSERT_OK(Put(1, "foo", "v1"));
    ASSERT_OK(Flush(1));
    ASSERT_EQ("v1", Get(1, "foo"));
    ASSERT_EQ("NOT_FOUND", Get(0, "foo"));
S
Sanjay Ghemawat 已提交
592
  } while (ChangeOptions());
593 594
}

I
Igor Sugak 已提交
595
TEST_F(DBTest, GetSnapshot) {
596 597
  anon::OptionsOverride options_override;
  options_override.skip_policy = kSkipNoSnapshot;
S
Sanjay Ghemawat 已提交
598
  do {
599
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions(options_override));
S
Sanjay Ghemawat 已提交
600 601 602
    // Try with both a short key and a long key
    for (int i = 0; i < 2; i++) {
      std::string key = (i == 0) ? std::string("foo") : std::string(200, 'x');
603
      ASSERT_OK(Put(1, key, "v1"));
S
Sanjay Ghemawat 已提交
604
      const Snapshot* s1 = db_->GetSnapshot();
S
sdong 已提交
605 606 607 608 609
      if (option_config_ == kHashCuckoo) {
        // NOt supported case.
        ASSERT_TRUE(s1 == nullptr);
        break;
      }
610 611 612 613 614 615
      ASSERT_OK(Put(1, key, "v2"));
      ASSERT_EQ("v2", Get(1, key));
      ASSERT_EQ("v1", Get(1, key, s1));
      ASSERT_OK(Flush(1));
      ASSERT_EQ("v2", Get(1, key));
      ASSERT_EQ("v1", Get(1, key, s1));
S
Sanjay Ghemawat 已提交
616 617
      db_->ReleaseSnapshot(s1);
    }
S
sdong 已提交
618
  } while (ChangeOptions());
619 620
}

I
Igor Sugak 已提交
621
TEST_F(DBTest, GetLevel0Ordering) {
S
Sanjay Ghemawat 已提交
622
  do {
L
Lei Jin 已提交
623
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
S
Sanjay Ghemawat 已提交
624 625 626 627
    // Check that we process level-0 files in correct order.  The code
    // below generates two level-0 files where the earlier one comes
    // before the later one in the level-0 file list since the earlier
    // one has a smaller "smallest" key.
628 629 630 631 632 633
    ASSERT_OK(Put(1, "bar", "b"));
    ASSERT_OK(Put(1, "foo", "v1"));
    ASSERT_OK(Flush(1));
    ASSERT_OK(Put(1, "foo", "v2"));
    ASSERT_OK(Flush(1));
    ASSERT_EQ("v2", Get(1, "foo"));
S
Sanjay Ghemawat 已提交
634
  } while (ChangeOptions());
635 636
}

I
Igor Sugak 已提交
637
TEST_F(DBTest, WrongLevel0Config) {
638 639 640 641 642 643 644 645 646
  Options options = CurrentOptions();
  Close();
  ASSERT_OK(DestroyDB(dbname_, options));
  options.level0_stop_writes_trigger = 1;
  options.level0_slowdown_writes_trigger = 2;
  options.level0_file_num_compaction_trigger = 3;
  ASSERT_OK(DB::Open(options, dbname_, &db_));
}

I
Igor Sugak 已提交
647
TEST_F(DBTest, GetOrderedByLevels) {
S
Sanjay Ghemawat 已提交
648
  do {
L
Lei Jin 已提交
649
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
650 651 652 653 654 655 656
    ASSERT_OK(Put(1, "foo", "v1"));
    Compact(1, "a", "z");
    ASSERT_EQ("v1", Get(1, "foo"));
    ASSERT_OK(Put(1, "foo", "v2"));
    ASSERT_EQ("v2", Get(1, "foo"));
    ASSERT_OK(Flush(1));
    ASSERT_EQ("v2", Get(1, "foo"));
S
Sanjay Ghemawat 已提交
657
  } while (ChangeOptions());
658 659
}

I
Igor Sugak 已提交
660
TEST_F(DBTest, GetPicksCorrectFile) {
S
Sanjay Ghemawat 已提交
661
  do {
L
Lei Jin 已提交
662
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
S
Sanjay Ghemawat 已提交
663
    // Arrange to have multiple files in a non-level-0 level.
664 665 666 667 668 669 670 671 672
    ASSERT_OK(Put(1, "a", "va"));
    Compact(1, "a", "b");
    ASSERT_OK(Put(1, "x", "vx"));
    Compact(1, "x", "y");
    ASSERT_OK(Put(1, "f", "vf"));
    Compact(1, "f", "g");
    ASSERT_EQ("va", Get(1, "a"));
    ASSERT_EQ("vf", Get(1, "f"));
    ASSERT_EQ("vx", Get(1, "x"));
S
Sanjay Ghemawat 已提交
673
  } while (ChangeOptions());
674 675
}

I
Igor Sugak 已提交
676
TEST_F(DBTest, GetEncountersEmptyLevel) {
S
Sanjay Ghemawat 已提交
677
  do {
I
Igor Canadi 已提交
678 679 680
    Options options = CurrentOptions();
    options.max_background_flushes = 0;
    options.disableDataSync = true;
L
Lei Jin 已提交
681
    CreateAndReopenWithCF({"pikachu"}, options);
S
Sanjay Ghemawat 已提交
682 683 684 685 686 687
    // Arrange for the following to happen:
    //   * sstable A in level 0
    //   * nothing in level 1
    //   * sstable B in level 2
    // Then do enough Get() calls to arrange for an automatic compaction
    // of sstable A.  A bug would cause the compaction to be marked as
C
clark.kang 已提交
688
    // occurring at level 1 (instead of the correct level 0).
S
Sanjay Ghemawat 已提交
689 690 691

    // Step 1: First place sstables in levels 0 and 2
    int compaction_count = 0;
692
    while (NumTableFilesAtLevel(0, 1) == 0 || NumTableFilesAtLevel(2, 1) == 0) {
S
Sanjay Ghemawat 已提交
693 694
      ASSERT_LE(compaction_count, 100) << "could not fill levels 0 and 2";
      compaction_count++;
695 696 697
      Put(1, "a", "begin");
      Put(1, "z", "end");
      ASSERT_OK(Flush(1));
S
Sanjay Ghemawat 已提交
698
    }
699

S
Sanjay Ghemawat 已提交
700
    // Step 2: clear level 1 if necessary.
701 702 703 704
    dbfull()->TEST_CompactRange(1, nullptr, nullptr, handles_[1]);
    ASSERT_EQ(NumTableFilesAtLevel(0, 1), 1);
    ASSERT_EQ(NumTableFilesAtLevel(1, 1), 0);
    ASSERT_EQ(NumTableFilesAtLevel(2, 1), 1);
S
Sanjay Ghemawat 已提交
705

H
heyongqiang 已提交
706 707
    // Step 3: read a bunch of times
    for (int i = 0; i < 1000; i++) {
708
      ASSERT_EQ("NOT_FOUND", Get(1, "missing"));
S
Sanjay Ghemawat 已提交
709
    }
H
heyongqiang 已提交
710 711 712 713

    // Step 4: Wait for compaction to finish
    env_->SleepForMicroseconds(1000000);

714
    ASSERT_EQ(NumTableFilesAtLevel(0, 1), 1);  // XXX
I
Igor Canadi 已提交
715
  } while (ChangeOptions(kSkipUniversalCompaction | kSkipFIFOCompaction));
716 717
}

718 719 720
// KeyMayExist can lead to a few false positives, but not false negatives.
// To make test deterministic, use a much larger number of bits per key-20 than
// bits in the key, so that false positives are eliminated
I
Igor Sugak 已提交
721
TEST_F(DBTest, KeyMayExist) {
722
  do {
723 724
    ReadOptions ropts;
    std::string value;
725 726 727
    anon::OptionsOverride options_override;
    options_override.filter_policy.reset(NewBloomFilterPolicy(20));
    Options options = CurrentOptions(options_override);
728
    options.statistics = rocksdb::CreateDBStatistics();
L
Lei Jin 已提交
729
    CreateAndReopenWithCF({"pikachu"}, options);
730

731
    ASSERT_TRUE(!db_->KeyMayExist(ropts, handles_[1], "a", &value));
732

733
    ASSERT_OK(Put(1, "a", "b"));
734
    bool value_found = false;
735 736
    ASSERT_TRUE(
        db_->KeyMayExist(ropts, handles_[1], "a", &value, &value_found));
737 738
    ASSERT_TRUE(value_found);
    ASSERT_EQ("b", value);
739

740
    ASSERT_OK(Flush(1));
741
    value.clear();
742

I
Igor Canadi 已提交
743 744
    long numopen = TestGetTickerCount(options, NO_FILE_OPENS);
    long cache_added = TestGetTickerCount(options, BLOCK_CACHE_ADD);
745 746
    ASSERT_TRUE(
        db_->KeyMayExist(ropts, handles_[1], "a", &value, &value_found));
M
Mayank Agarwal 已提交
747
    ASSERT_TRUE(!value_found);
748 749
    // assert that no new files were opened and no new blocks were
    // read into block cache.
I
Igor Canadi 已提交
750 751
    ASSERT_EQ(numopen, TestGetTickerCount(options, NO_FILE_OPENS));
    ASSERT_EQ(cache_added, TestGetTickerCount(options, BLOCK_CACHE_ADD));
752

753
    ASSERT_OK(Delete(1, "a"));
754

I
Igor Canadi 已提交
755 756
    numopen = TestGetTickerCount(options, NO_FILE_OPENS);
    cache_added = TestGetTickerCount(options, BLOCK_CACHE_ADD);
757
    ASSERT_TRUE(!db_->KeyMayExist(ropts, handles_[1], "a", &value));
I
Igor Canadi 已提交
758 759
    ASSERT_EQ(numopen, TestGetTickerCount(options, NO_FILE_OPENS));
    ASSERT_EQ(cache_added, TestGetTickerCount(options, BLOCK_CACHE_ADD));
760

761
    ASSERT_OK(Flush(1));
762 763
    dbfull()->TEST_CompactRange(0, nullptr, nullptr, handles_[1],
                                true /* disallow trivial move */);
764

I
Igor Canadi 已提交
765 766
    numopen = TestGetTickerCount(options, NO_FILE_OPENS);
    cache_added = TestGetTickerCount(options, BLOCK_CACHE_ADD);
767
    ASSERT_TRUE(!db_->KeyMayExist(ropts, handles_[1], "a", &value));
I
Igor Canadi 已提交
768 769
    ASSERT_EQ(numopen, TestGetTickerCount(options, NO_FILE_OPENS));
    ASSERT_EQ(cache_added, TestGetTickerCount(options, BLOCK_CACHE_ADD));
770

771
    ASSERT_OK(Delete(1, "c"));
772

I
Igor Canadi 已提交
773 774
    numopen = TestGetTickerCount(options, NO_FILE_OPENS);
    cache_added = TestGetTickerCount(options, BLOCK_CACHE_ADD);
775
    ASSERT_TRUE(!db_->KeyMayExist(ropts, handles_[1], "c", &value));
I
Igor Canadi 已提交
776 777
    ASSERT_EQ(numopen, TestGetTickerCount(options, NO_FILE_OPENS));
    ASSERT_EQ(cache_added, TestGetTickerCount(options, BLOCK_CACHE_ADD));
778

779 780
    // KeyMayExist function only checks data in block caches, which is not used
    // by plain table format.
I
Igor Canadi 已提交
781 782
  } while (
      ChangeOptions(kSkipPlainTable | kSkipHashIndex | kSkipFIFOCompaction));
783 784
}

I
Igor Sugak 已提交
785
TEST_F(DBTest, NonBlockingIteration) {
786 787 788
  do {
    ReadOptions non_blocking_opts, regular_opts;
    Options options = CurrentOptions();
789
    options.statistics = rocksdb::CreateDBStatistics();
790
    non_blocking_opts.read_tier = kBlockCacheTier;
L
Lei Jin 已提交
791
    CreateAndReopenWithCF({"pikachu"}, options);
792
    // write one kv to the database.
793
    ASSERT_OK(Put(1, "a", "b"));
794 795 796

    // scan using non-blocking iterator. We should find it because
    // it is in memtable.
797
    Iterator* iter = db_->NewIterator(non_blocking_opts, handles_[1]);
798 799
    int count = 0;
    for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
N
Naman Gupta 已提交
800
      ASSERT_OK(iter->status());
801 802 803 804 805 806 807
      count++;
    }
    ASSERT_EQ(count, 1);
    delete iter;

    // flush memtable to storage. Now, the key should not be in the
    // memtable neither in the block cache.
808
    ASSERT_OK(Flush(1));
809 810 811

    // verify that a non-blocking iterator does not find any
    // kvs. Neither does it do any IOs to storage.
I
Igor Canadi 已提交
812 813
    long numopen = TestGetTickerCount(options, NO_FILE_OPENS);
    long cache_added = TestGetTickerCount(options, BLOCK_CACHE_ADD);
814
    iter = db_->NewIterator(non_blocking_opts, handles_[1]);
815 816 817 818 819 820
    count = 0;
    for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
      count++;
    }
    ASSERT_EQ(count, 0);
    ASSERT_TRUE(iter->status().IsIncomplete());
I
Igor Canadi 已提交
821 822
    ASSERT_EQ(numopen, TestGetTickerCount(options, NO_FILE_OPENS));
    ASSERT_EQ(cache_added, TestGetTickerCount(options, BLOCK_CACHE_ADD));
823 824 825
    delete iter;

    // read in the specified block via a regular get
826
    ASSERT_EQ(Get(1, "a"), "b");
827 828

    // verify that we can find it via a non-blocking scan
I
Igor Canadi 已提交
829 830
    numopen = TestGetTickerCount(options, NO_FILE_OPENS);
    cache_added = TestGetTickerCount(options, BLOCK_CACHE_ADD);
831
    iter = db_->NewIterator(non_blocking_opts, handles_[1]);
832 833
    count = 0;
    for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
N
Naman Gupta 已提交
834
      ASSERT_OK(iter->status());
835 836 837
      count++;
    }
    ASSERT_EQ(count, 1);
I
Igor Canadi 已提交
838 839
    ASSERT_EQ(numopen, TestGetTickerCount(options, NO_FILE_OPENS));
    ASSERT_EQ(cache_added, TestGetTickerCount(options, BLOCK_CACHE_ADD));
840 841
    delete iter;

842 843
    // This test verifies block cache behaviors, which is not used by plain
    // table format.
844
    // Exclude kHashCuckoo as it does not support iteration currently
I
Igor Canadi 已提交
845 846
  } while (ChangeOptions(kSkipPlainTable | kSkipNoSeekToLast | kSkipHashCuckoo |
                         kSkipMmapReads));
847 848
}

I
Igor Sugak 已提交
849
TEST_F(DBTest, ManagedNonBlockingIteration) {
V
Venkatesh Radhakrishnan 已提交
850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913
  do {
    ReadOptions non_blocking_opts, regular_opts;
    Options options = CurrentOptions();
    options.statistics = rocksdb::CreateDBStatistics();
    non_blocking_opts.read_tier = kBlockCacheTier;
    non_blocking_opts.managed = true;
    CreateAndReopenWithCF({"pikachu"}, options);
    // write one kv to the database.
    ASSERT_OK(Put(1, "a", "b"));

    // scan using non-blocking iterator. We should find it because
    // it is in memtable.
    Iterator* iter = db_->NewIterator(non_blocking_opts, handles_[1]);
    int count = 0;
    for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
      ASSERT_OK(iter->status());
      count++;
    }
    ASSERT_EQ(count, 1);
    delete iter;

    // flush memtable to storage. Now, the key should not be in the
    // memtable neither in the block cache.
    ASSERT_OK(Flush(1));

    // verify that a non-blocking iterator does not find any
    // kvs. Neither does it do any IOs to storage.
    int64_t numopen = TestGetTickerCount(options, NO_FILE_OPENS);
    int64_t cache_added = TestGetTickerCount(options, BLOCK_CACHE_ADD);
    iter = db_->NewIterator(non_blocking_opts, handles_[1]);
    count = 0;
    for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
      count++;
    }
    ASSERT_EQ(count, 0);
    ASSERT_TRUE(iter->status().IsIncomplete());
    ASSERT_EQ(numopen, TestGetTickerCount(options, NO_FILE_OPENS));
    ASSERT_EQ(cache_added, TestGetTickerCount(options, BLOCK_CACHE_ADD));
    delete iter;

    // read in the specified block via a regular get
    ASSERT_EQ(Get(1, "a"), "b");

    // verify that we can find it via a non-blocking scan
    numopen = TestGetTickerCount(options, NO_FILE_OPENS);
    cache_added = TestGetTickerCount(options, BLOCK_CACHE_ADD);
    iter = db_->NewIterator(non_blocking_opts, handles_[1]);
    count = 0;
    for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
      ASSERT_OK(iter->status());
      count++;
    }
    ASSERT_EQ(count, 1);
    ASSERT_EQ(numopen, TestGetTickerCount(options, NO_FILE_OPENS));
    ASSERT_EQ(cache_added, TestGetTickerCount(options, BLOCK_CACHE_ADD));
    delete iter;

    // This test verifies block cache behaviors, which is not used by plain
    // table format.
    // Exclude kHashCuckoo as it does not support iteration currently
  } while (ChangeOptions(kSkipPlainTable | kSkipNoSeekToLast | kSkipHashCuckoo |
                         kSkipMmapReads));
}

914 915
// A delete is skipped for key if KeyMayExist(key) returns False
// Tests Writebatch consistency and proper delete behaviour
I
Igor Sugak 已提交
916
TEST_F(DBTest, FilterDeletes) {
917
  do {
918 919 920
    anon::OptionsOverride options_override;
    options_override.filter_policy.reset(NewBloomFilterPolicy(20));
    Options options = CurrentOptions(options_override);
921
    options.filter_deletes = true;
L
Lei Jin 已提交
922
    CreateAndReopenWithCF({"pikachu"}, options);
923 924
    WriteBatch batch;

I
Igor Canadi 已提交
925
    batch.Delete(handles_[1], "a");
926
    dbfull()->Write(WriteOptions(), &batch);
927
    ASSERT_EQ(AllEntriesFor("a", 1), "[ ]");  // Delete skipped
928 929
    batch.Clear();

I
Igor Canadi 已提交
930 931
    batch.Put(handles_[1], "a", "b");
    batch.Delete(handles_[1], "a");
932
    dbfull()->Write(WriteOptions(), &batch);
933 934
    ASSERT_EQ(Get(1, "a"), "NOT_FOUND");
    ASSERT_EQ(AllEntriesFor("a", 1), "[ DEL, b ]");  // Delete issued
935 936
    batch.Clear();

I
Igor Canadi 已提交
937 938
    batch.Delete(handles_[1], "c");
    batch.Put(handles_[1], "c", "d");
939
    dbfull()->Write(WriteOptions(), &batch);
940 941
    ASSERT_EQ(Get(1, "c"), "d");
    ASSERT_EQ(AllEntriesFor("c", 1), "[ d ]");  // Delete skipped
942 943
    batch.Clear();

944
    ASSERT_OK(Flush(1));  // A stray Flush
945

I
Igor Canadi 已提交
946
    batch.Delete(handles_[1], "c");
947
    dbfull()->Write(WriteOptions(), &batch);
948
    ASSERT_EQ(AllEntriesFor("c", 1), "[ DEL, d ]");  // Delete issued
949 950
    batch.Clear();
  } while (ChangeCompactOptions());
951 952
}

I
Igor Sugak 已提交
953
TEST_F(DBTest, GetFilterByPrefixBloom) {
954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987
  Options options = last_options_;
  options.prefix_extractor.reset(NewFixedPrefixTransform(8));
  options.statistics = rocksdb::CreateDBStatistics();
  BlockBasedTableOptions bbto;
  bbto.filter_policy.reset(NewBloomFilterPolicy(10, false));
  bbto.whole_key_filtering = false;
  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
  DestroyAndReopen(options);

  WriteOptions wo;
  ReadOptions ro;
  FlushOptions fo;
  fo.wait = true;
  std::string value;

  ASSERT_OK(dbfull()->Put(wo, "barbarbar", "foo"));
  ASSERT_OK(dbfull()->Put(wo, "barbarbar2", "foo2"));
  ASSERT_OK(dbfull()->Put(wo, "foofoofoo", "bar"));

  dbfull()->Flush(fo);

  ASSERT_EQ("foo", Get("barbarbar"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 0);
  ASSERT_EQ("foo2", Get("barbarbar2"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 0);
  ASSERT_EQ("NOT_FOUND", Get("barbarbar3"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 0);

  ASSERT_EQ("NOT_FOUND", Get("barfoofoo"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 1);

  ASSERT_EQ("NOT_FOUND", Get("foobarbar"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 2);
}
I
Igor Canadi 已提交
988

I
Igor Sugak 已提交
989
TEST_F(DBTest, WholeKeyFilterProp) {
990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041
  Options options = last_options_;
  options.prefix_extractor.reset(NewFixedPrefixTransform(3));
  options.statistics = rocksdb::CreateDBStatistics();

  BlockBasedTableOptions bbto;
  bbto.filter_policy.reset(NewBloomFilterPolicy(10, false));
  bbto.whole_key_filtering = false;
  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
  DestroyAndReopen(options);

  WriteOptions wo;
  ReadOptions ro;
  FlushOptions fo;
  fo.wait = true;
  std::string value;

  ASSERT_OK(dbfull()->Put(wo, "foobar", "foo"));
  // Needs insert some keys to make sure files are not filtered out by key
  // ranges.
  ASSERT_OK(dbfull()->Put(wo, "aaa", ""));
  ASSERT_OK(dbfull()->Put(wo, "zzz", ""));
  dbfull()->Flush(fo);

  Reopen(options);
  ASSERT_EQ("NOT_FOUND", Get("foo"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 0);
  ASSERT_EQ("NOT_FOUND", Get("bar"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 1);
  ASSERT_EQ("foo", Get("foobar"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 1);

  // Reopen with whole key filtering enabled and prefix extractor
  // NULL. Bloom filter should be off for both of whole key and
  // prefix bloom.
  bbto.whole_key_filtering = true;
  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
  options.prefix_extractor.reset();
  Reopen(options);

  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 1);
  ASSERT_EQ("NOT_FOUND", Get("foo"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 1);
  ASSERT_EQ("NOT_FOUND", Get("bar"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 1);
  ASSERT_EQ("foo", Get("foobar"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 1);
  // Write DB with only full key filtering.
  ASSERT_OK(dbfull()->Put(wo, "foobar", "foo"));
  // Needs insert some keys to make sure files are not filtered out by key
  // ranges.
  ASSERT_OK(dbfull()->Put(wo, "aaa", ""));
  ASSERT_OK(dbfull()->Put(wo, "zzz", ""));
1042
  db_->CompactRange(CompactRangeOptions(), nullptr, nullptr);
1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064

  // Reopen with both of whole key off and prefix extractor enabled.
  // Still no bloom filter should be used.
  options.prefix_extractor.reset(NewFixedPrefixTransform(3));
  bbto.whole_key_filtering = false;
  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
  Reopen(options);

  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 1);
  ASSERT_EQ("NOT_FOUND", Get("foo"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 1);
  ASSERT_EQ("NOT_FOUND", Get("bar"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 1);
  ASSERT_EQ("foo", Get("foobar"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 1);

  // Try to create a DB with mixed files:
  ASSERT_OK(dbfull()->Put(wo, "foobar", "foo"));
  // Needs insert some keys to make sure files are not filtered out by key
  // ranges.
  ASSERT_OK(dbfull()->Put(wo, "aaa", ""));
  ASSERT_OK(dbfull()->Put(wo, "zzz", ""));
1065
  db_->CompactRange(CompactRangeOptions(), nullptr, nullptr);
1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137

  options.prefix_extractor.reset();
  bbto.whole_key_filtering = true;
  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
  Reopen(options);

  // Try to create a DB with mixed files.
  ASSERT_OK(dbfull()->Put(wo, "barfoo", "bar"));
  // In this case needs insert some keys to make sure files are
  // not filtered out by key ranges.
  ASSERT_OK(dbfull()->Put(wo, "aaa", ""));
  ASSERT_OK(dbfull()->Put(wo, "zzz", ""));
  Flush();

  // Now we have two files:
  // File 1: An older file with prefix bloom.
  // File 2: A newer file with whole bloom filter.
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 1);
  ASSERT_EQ("NOT_FOUND", Get("foo"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 2);
  ASSERT_EQ("NOT_FOUND", Get("bar"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 3);
  ASSERT_EQ("foo", Get("foobar"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 4);
  ASSERT_EQ("bar", Get("barfoo"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 4);

  // Reopen with the same setting: only whole key is used
  Reopen(options);
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 4);
  ASSERT_EQ("NOT_FOUND", Get("foo"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 5);
  ASSERT_EQ("NOT_FOUND", Get("bar"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 6);
  ASSERT_EQ("foo", Get("foobar"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 7);
  ASSERT_EQ("bar", Get("barfoo"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 7);

  // Restart with both filters are allowed
  options.prefix_extractor.reset(NewFixedPrefixTransform(3));
  bbto.whole_key_filtering = true;
  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
  Reopen(options);
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 7);
  // File 1 will has it filtered out.
  // File 2 will not, as prefix `foo` exists in the file.
  ASSERT_EQ("NOT_FOUND", Get("foo"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 8);
  ASSERT_EQ("NOT_FOUND", Get("bar"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 10);
  ASSERT_EQ("foo", Get("foobar"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 11);
  ASSERT_EQ("bar", Get("barfoo"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 11);

  // Restart with only prefix bloom is allowed.
  options.prefix_extractor.reset(NewFixedPrefixTransform(3));
  bbto.whole_key_filtering = false;
  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
  Reopen(options);
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 11);
  ASSERT_EQ("NOT_FOUND", Get("foo"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 11);
  ASSERT_EQ("NOT_FOUND", Get("bar"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 12);
  ASSERT_EQ("foo", Get("foobar"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 12);
  ASSERT_EQ("bar", Get("barfoo"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 12);
}

I
Igor Sugak 已提交
1138
TEST_F(DBTest, IterSeekBeforePrev) {
I
Igor Canadi 已提交
1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153
  ASSERT_OK(Put("a", "b"));
  ASSERT_OK(Put("c", "d"));
  dbfull()->Flush(FlushOptions());
  ASSERT_OK(Put("0", "f"));
  ASSERT_OK(Put("1", "h"));
  dbfull()->Flush(FlushOptions());
  ASSERT_OK(Put("2", "j"));
  auto iter = db_->NewIterator(ReadOptions());
  iter->Seek(Slice("c"));
  iter->Prev();
  iter->Seek(Slice("a"));
  iter->Prev();
  delete iter;
}

I
Igor Canadi 已提交
1154
namespace {
1155 1156 1157
std::string MakeLongKey(size_t length, char c) {
  return std::string(length, c);
}
I
Igor Canadi 已提交
1158
}  // namespace
1159

I
Igor Sugak 已提交
1160
TEST_F(DBTest, IterLongKeys) {
1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192
  ASSERT_OK(Put(MakeLongKey(20, 0), "0"));
  ASSERT_OK(Put(MakeLongKey(32, 2), "2"));
  ASSERT_OK(Put("a", "b"));
  dbfull()->Flush(FlushOptions());
  ASSERT_OK(Put(MakeLongKey(50, 1), "1"));
  ASSERT_OK(Put(MakeLongKey(127, 3), "3"));
  ASSERT_OK(Put(MakeLongKey(64, 4), "4"));
  auto iter = db_->NewIterator(ReadOptions());

  // Create a key that needs to be skipped for Seq too new
  iter->Seek(MakeLongKey(20, 0));
  ASSERT_EQ(IterStatus(iter), MakeLongKey(20, 0) + "->0");
  iter->Next();
  ASSERT_EQ(IterStatus(iter), MakeLongKey(50, 1) + "->1");
  iter->Next();
  ASSERT_EQ(IterStatus(iter), MakeLongKey(32, 2) + "->2");
  iter->Next();
  ASSERT_EQ(IterStatus(iter), MakeLongKey(127, 3) + "->3");
  iter->Next();
  ASSERT_EQ(IterStatus(iter), MakeLongKey(64, 4) + "->4");
  delete iter;

  iter = db_->NewIterator(ReadOptions());
  iter->Seek(MakeLongKey(50, 1));
  ASSERT_EQ(IterStatus(iter), MakeLongKey(50, 1) + "->1");
  iter->Next();
  ASSERT_EQ(IterStatus(iter), MakeLongKey(32, 2) + "->2");
  iter->Next();
  ASSERT_EQ(IterStatus(iter), MakeLongKey(127, 3) + "->3");
  delete iter;
}

I
Igor Sugak 已提交
1193
TEST_F(DBTest, IterNextWithNewerSeq) {
S
sdong 已提交
1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213
  ASSERT_OK(Put("0", "0"));
  dbfull()->Flush(FlushOptions());
  ASSERT_OK(Put("a", "b"));
  ASSERT_OK(Put("c", "d"));
  ASSERT_OK(Put("d", "e"));
  auto iter = db_->NewIterator(ReadOptions());

  // Create a key that needs to be skipped for Seq too new
  for (uint64_t i = 0; i < last_options_.max_sequential_skip_in_iterations + 1;
       i++) {
    ASSERT_OK(Put("b", "f"));
  }

  iter->Seek(Slice("a"));
  ASSERT_EQ(IterStatus(iter), "a->b");
  iter->Next();
  ASSERT_EQ(IterStatus(iter), "c->d");
  delete iter;
}

I
Igor Sugak 已提交
1214
TEST_F(DBTest, IterPrevWithNewerSeq) {
S
sdong 已提交
1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238
  ASSERT_OK(Put("0", "0"));
  dbfull()->Flush(FlushOptions());
  ASSERT_OK(Put("a", "b"));
  ASSERT_OK(Put("c", "d"));
  ASSERT_OK(Put("d", "e"));
  auto iter = db_->NewIterator(ReadOptions());

  // Create a key that needs to be skipped for Seq too new
  for (uint64_t i = 0; i < last_options_.max_sequential_skip_in_iterations + 1;
       i++) {
    ASSERT_OK(Put("b", "f"));
  }

  iter->Seek(Slice("d"));
  ASSERT_EQ(IterStatus(iter), "d->e");
  iter->Prev();
  ASSERT_EQ(IterStatus(iter), "c->d");
  iter->Prev();
  ASSERT_EQ(IterStatus(iter), "a->b");

  iter->Prev();
  delete iter;
}

I
Igor Sugak 已提交
1239
TEST_F(DBTest, IterPrevWithNewerSeq2) {
S
sdong 已提交
1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261
  ASSERT_OK(Put("0", "0"));
  dbfull()->Flush(FlushOptions());
  ASSERT_OK(Put("a", "b"));
  ASSERT_OK(Put("c", "d"));
  ASSERT_OK(Put("d", "e"));
  auto iter = db_->NewIterator(ReadOptions());
  iter->Seek(Slice("c"));
  ASSERT_EQ(IterStatus(iter), "c->d");

  // Create a key that needs to be skipped for Seq too new
  for (uint64_t i = 0; i < last_options_.max_sequential_skip_in_iterations + 1;
      i++) {
    ASSERT_OK(Put("b", "f"));
  }

  iter->Prev();
  ASSERT_EQ(IterStatus(iter), "a->b");

  iter->Prev();
  delete iter;
}

I
Igor Sugak 已提交
1262
TEST_F(DBTest, IterEmpty) {
1263
  do {
L
Lei Jin 已提交
1264
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
1265
    Iterator* iter = db_->NewIterator(ReadOptions(), handles_[1]);
J
jorlow@chromium.org 已提交
1266

1267 1268
    iter->SeekToFirst();
    ASSERT_EQ(IterStatus(iter), "(invalid)");
J
jorlow@chromium.org 已提交
1269

1270 1271
    iter->SeekToLast();
    ASSERT_EQ(IterStatus(iter), "(invalid)");
J
jorlow@chromium.org 已提交
1272

1273 1274
    iter->Seek("foo");
    ASSERT_EQ(IterStatus(iter), "(invalid)");
J
jorlow@chromium.org 已提交
1275

1276 1277
    delete iter;
  } while (ChangeCompactOptions());
J
jorlow@chromium.org 已提交
1278 1279
}

I
Igor Sugak 已提交
1280
TEST_F(DBTest, IterSingle) {
1281
  do {
L
Lei Jin 已提交
1282
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
1283 1284
    ASSERT_OK(Put(1, "a", "va"));
    Iterator* iter = db_->NewIterator(ReadOptions(), handles_[1]);
J
jorlow@chromium.org 已提交
1285

1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307
    iter->SeekToFirst();
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "(invalid)");
    iter->SeekToFirst();
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "(invalid)");

    iter->SeekToLast();
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "(invalid)");
    iter->SeekToLast();
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "(invalid)");

    iter->Seek("");
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "(invalid)");
J
jorlow@chromium.org 已提交
1308

1309 1310 1311 1312 1313 1314 1315 1316 1317 1318
    iter->Seek("a");
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "(invalid)");

    iter->Seek("b");
    ASSERT_EQ(IterStatus(iter), "(invalid)");

    delete iter;
  } while (ChangeCompactOptions());
J
jorlow@chromium.org 已提交
1319 1320
}

I
Igor Sugak 已提交
1321
TEST_F(DBTest, IterMulti) {
1322
  do {
L
Lei Jin 已提交
1323
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
1324 1325 1326 1327
    ASSERT_OK(Put(1, "a", "va"));
    ASSERT_OK(Put(1, "b", "vb"));
    ASSERT_OK(Put(1, "c", "vc"));
    Iterator* iter = db_->NewIterator(ReadOptions(), handles_[1]);
J
jorlow@chromium.org 已提交
1328

1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340
    iter->SeekToFirst();
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "b->vb");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "c->vc");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "(invalid)");
    iter->SeekToFirst();
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "(invalid)");
J
jorlow@chromium.org 已提交
1341

1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360
    iter->SeekToLast();
    ASSERT_EQ(IterStatus(iter), "c->vc");
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "b->vb");
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "(invalid)");
    iter->SeekToLast();
    ASSERT_EQ(IterStatus(iter), "c->vc");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "(invalid)");

    iter->Seek("");
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Seek("a");
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Seek("ax");
    ASSERT_EQ(IterStatus(iter), "b->vb");
1361

1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381
    iter->Seek("b");
    ASSERT_EQ(IterStatus(iter), "b->vb");
    iter->Seek("z");
    ASSERT_EQ(IterStatus(iter), "(invalid)");

    // Switch from reverse to forward
    iter->SeekToLast();
    iter->Prev();
    iter->Prev();
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "b->vb");

    // Switch from forward to reverse
    iter->SeekToFirst();
    iter->Next();
    iter->Next();
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "b->vb");

    // Make sure iter stays at snapshot
1382 1383 1384 1385 1386
    ASSERT_OK(Put(1, "a", "va2"));
    ASSERT_OK(Put(1, "a2", "va3"));
    ASSERT_OK(Put(1, "b", "vb2"));
    ASSERT_OK(Put(1, "c", "vc2"));
    ASSERT_OK(Delete(1, "b"));
1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405
    iter->SeekToFirst();
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "b->vb");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "c->vc");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "(invalid)");
    iter->SeekToLast();
    ASSERT_EQ(IterStatus(iter), "c->vc");
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "b->vb");
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "(invalid)");

    delete iter;
  } while (ChangeCompactOptions());
J
jorlow@chromium.org 已提交
1406 1407
}

1408 1409
// Check that we can skip over a run of user keys
// by using reseek rather than sequential scan
I
Igor Sugak 已提交
1410
TEST_F(DBTest, IterReseek) {
1411 1412 1413
  anon::OptionsOverride options_override;
  options_override.skip_policy = kSkipNoSnapshot;
  Options options = CurrentOptions(options_override);
1414 1415
  options.max_sequential_skip_in_iterations = 3;
  options.create_if_missing = true;
1416
  options.statistics = rocksdb::CreateDBStatistics();
L
Lei Jin 已提交
1417
  DestroyAndReopen(options);
L
Lei Jin 已提交
1418
  CreateAndReopenWithCF({"pikachu"}, options);
1419 1420 1421 1422

  // insert two keys with same userkey and verify that
  // reseek is not invoked. For each of these test cases,
  // verify that we can find the next key "b".
1423 1424 1425 1426
  ASSERT_OK(Put(1, "a", "one"));
  ASSERT_OK(Put(1, "a", "two"));
  ASSERT_OK(Put(1, "b", "bone"));
  Iterator* iter = db_->NewIterator(ReadOptions(), handles_[1]);
1427
  iter->SeekToFirst();
I
Igor Canadi 已提交
1428
  ASSERT_EQ(TestGetTickerCount(options, NUMBER_OF_RESEEKS_IN_ITERATION), 0);
1429 1430
  ASSERT_EQ(IterStatus(iter), "a->two");
  iter->Next();
I
Igor Canadi 已提交
1431
  ASSERT_EQ(TestGetTickerCount(options, NUMBER_OF_RESEEKS_IN_ITERATION), 0);
1432 1433 1434 1435 1436
  ASSERT_EQ(IterStatus(iter), "b->bone");
  delete iter;

  // insert a total of three keys with same userkey and verify
  // that reseek is still not invoked.
1437 1438
  ASSERT_OK(Put(1, "a", "three"));
  iter = db_->NewIterator(ReadOptions(), handles_[1]);
1439 1440 1441
  iter->SeekToFirst();
  ASSERT_EQ(IterStatus(iter), "a->three");
  iter->Next();
I
Igor Canadi 已提交
1442
  ASSERT_EQ(TestGetTickerCount(options, NUMBER_OF_RESEEKS_IN_ITERATION), 0);
1443 1444 1445 1446 1447
  ASSERT_EQ(IterStatus(iter), "b->bone");
  delete iter;

  // insert a total of four keys with same userkey and verify
  // that reseek is invoked.
1448 1449
  ASSERT_OK(Put(1, "a", "four"));
  iter = db_->NewIterator(ReadOptions(), handles_[1]);
1450 1451
  iter->SeekToFirst();
  ASSERT_EQ(IterStatus(iter), "a->four");
I
Igor Canadi 已提交
1452
  ASSERT_EQ(TestGetTickerCount(options, NUMBER_OF_RESEEKS_IN_ITERATION), 0);
1453
  iter->Next();
I
Igor Canadi 已提交
1454
  ASSERT_EQ(TestGetTickerCount(options, NUMBER_OF_RESEEKS_IN_ITERATION), 1);
1455 1456 1457 1458 1459 1460
  ASSERT_EQ(IterStatus(iter), "b->bone");
  delete iter;

  // Testing reverse iterator
  // At this point, we have three versions of "a" and one version of "b".
  // The reseek statistics is already at 1.
I
Igor Canadi 已提交
1461 1462
  int num_reseeks =
      (int)TestGetTickerCount(options, NUMBER_OF_RESEEKS_IN_ITERATION);
1463 1464

  // Insert another version of b and assert that reseek is not invoked
1465 1466
  ASSERT_OK(Put(1, "b", "btwo"));
  iter = db_->NewIterator(ReadOptions(), handles_[1]);
1467 1468
  iter->SeekToLast();
  ASSERT_EQ(IterStatus(iter), "b->btwo");
I
Igor Canadi 已提交
1469 1470
  ASSERT_EQ(TestGetTickerCount(options, NUMBER_OF_RESEEKS_IN_ITERATION),
            num_reseeks);
1471
  iter->Prev();
I
Igor Canadi 已提交
1472 1473
  ASSERT_EQ(TestGetTickerCount(options, NUMBER_OF_RESEEKS_IN_ITERATION),
            num_reseeks + 1);
1474 1475 1476 1477 1478
  ASSERT_EQ(IterStatus(iter), "a->four");
  delete iter;

  // insert two more versions of b. This makes a total of 4 versions
  // of b and 4 versions of a.
1479 1480 1481
  ASSERT_OK(Put(1, "b", "bthree"));
  ASSERT_OK(Put(1, "b", "bfour"));
  iter = db_->NewIterator(ReadOptions(), handles_[1]);
1482 1483
  iter->SeekToLast();
  ASSERT_EQ(IterStatus(iter), "b->bfour");
I
Igor Canadi 已提交
1484 1485
  ASSERT_EQ(TestGetTickerCount(options, NUMBER_OF_RESEEKS_IN_ITERATION),
            num_reseeks + 2);
1486 1487 1488
  iter->Prev();

  // the previous Prev call should have invoked reseek
I
Igor Canadi 已提交
1489 1490
  ASSERT_EQ(TestGetTickerCount(options, NUMBER_OF_RESEEKS_IN_ITERATION),
            num_reseeks + 3);
1491 1492 1493 1494
  ASSERT_EQ(IterStatus(iter), "a->four");
  delete iter;
}

I
Igor Sugak 已提交
1495
TEST_F(DBTest, IterSmallAndLargeMix) {
1496
  do {
L
Lei Jin 已提交
1497
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
1498 1499 1500 1501 1502
    ASSERT_OK(Put(1, "a", "va"));
    ASSERT_OK(Put(1, "b", std::string(100000, 'b')));
    ASSERT_OK(Put(1, "c", "vc"));
    ASSERT_OK(Put(1, "d", std::string(100000, 'd')));
    ASSERT_OK(Put(1, "e", std::string(100000, 'e')));
J
jorlow@chromium.org 已提交
1503

1504
    Iterator* iter = db_->NewIterator(ReadOptions(), handles_[1]);
J
jorlow@chromium.org 已提交
1505

1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517
    iter->SeekToFirst();
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "b->" + std::string(100000, 'b'));
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "c->vc");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "d->" + std::string(100000, 'd'));
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "e->" + std::string(100000, 'e'));
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "(invalid)");
J
jorlow@chromium.org 已提交
1518

1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533
    iter->SeekToLast();
    ASSERT_EQ(IterStatus(iter), "e->" + std::string(100000, 'e'));
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "d->" + std::string(100000, 'd'));
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "c->vc");
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "b->" + std::string(100000, 'b'));
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "(invalid)");

    delete iter;
  } while (ChangeCompactOptions());
J
jorlow@chromium.org 已提交
1534 1535
}

I
Igor Sugak 已提交
1536
TEST_F(DBTest, IterMultiWithDelete) {
S
Sanjay Ghemawat 已提交
1537
  do {
L
Lei Jin 已提交
1538
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
1539 1540 1541 1542 1543
    ASSERT_OK(Put(1, "ka", "va"));
    ASSERT_OK(Put(1, "kb", "vb"));
    ASSERT_OK(Put(1, "kc", "vc"));
    ASSERT_OK(Delete(1, "kb"));
    ASSERT_EQ("NOT_FOUND", Get(1, "kb"));
1544 1545

    Iterator* iter = db_->NewIterator(ReadOptions(), handles_[1]);
1546 1547
    iter->Seek("kc");
    ASSERT_EQ(IterStatus(iter), "kc->vc");
1548 1549
    if (!CurrentOptions().merge_operator) {
      // TODO: merge operator does not support backward iteration yet
1550 1551 1552 1553 1554 1555
      if (kPlainTableAllBytesPrefix != option_config_&&
          kBlockBasedTableWithWholeKeyHashIndex != option_config_ &&
          kHashLinkList != option_config_) {
        iter->Prev();
        ASSERT_EQ(IterStatus(iter), "ka->va");
      }
1556
    }
S
Sanjay Ghemawat 已提交
1557 1558
    delete iter;
  } while (ChangeOptions());
1559 1560
}

I
Igor Sugak 已提交
1561
TEST_F(DBTest, IterPrevMaxSkip) {
1562
  do {
L
Lei Jin 已提交
1563
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
1564
    for (int i = 0; i < 2; i++) {
1565 1566 1567 1568 1569
      ASSERT_OK(Put(1, "key1", "v1"));
      ASSERT_OK(Put(1, "key2", "v2"));
      ASSERT_OK(Put(1, "key3", "v3"));
      ASSERT_OK(Put(1, "key4", "v4"));
      ASSERT_OK(Put(1, "key5", "v5"));
1570 1571
    }

1572
    VerifyIterLast("key5->v5", 1);
1573

1574 1575
    ASSERT_OK(Delete(1, "key5"));
    VerifyIterLast("key4->v4", 1);
1576

1577 1578
    ASSERT_OK(Delete(1, "key4"));
    VerifyIterLast("key3->v3", 1);
1579

1580 1581
    ASSERT_OK(Delete(1, "key3"));
    VerifyIterLast("key2->v2", 1);
1582

1583 1584
    ASSERT_OK(Delete(1, "key2"));
    VerifyIterLast("key1->v1", 1);
1585

1586 1587
    ASSERT_OK(Delete(1, "key1"));
    VerifyIterLast("(invalid)", 1);
1588
  } while (ChangeOptions(kSkipMergePut | kSkipNoSeekToLast));
1589 1590
}

I
Igor Sugak 已提交
1591
TEST_F(DBTest, IterWithSnapshot) {
1592 1593
  anon::OptionsOverride options_override;
  options_override.skip_policy = kSkipNoSnapshot;
1594
  do {
1595
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions(options_override));
1596 1597 1598 1599 1600
    ASSERT_OK(Put(1, "key1", "val1"));
    ASSERT_OK(Put(1, "key2", "val2"));
    ASSERT_OK(Put(1, "key3", "val3"));
    ASSERT_OK(Put(1, "key4", "val4"));
    ASSERT_OK(Put(1, "key5", "val5"));
1601 1602 1603 1604

    const Snapshot *snapshot = db_->GetSnapshot();
    ReadOptions options;
    options.snapshot = snapshot;
1605
    Iterator* iter = db_->NewIterator(options, handles_[1]);
1606 1607

    // Put more values after the snapshot
1608 1609
    ASSERT_OK(Put(1, "key100", "val100"));
    ASSERT_OK(Put(1, "key101", "val101"));
1610 1611 1612 1613 1614

    iter->Seek("key5");
    ASSERT_EQ(IterStatus(iter), "key5->val5");
    if (!CurrentOptions().merge_operator) {
      // TODO: merge operator does not support backward iteration yet
1615 1616 1617 1618 1619 1620 1621
      if (kPlainTableAllBytesPrefix != option_config_&&
        kBlockBasedTableWithWholeKeyHashIndex != option_config_ &&
        kHashLinkList != option_config_) {
        iter->Prev();
        ASSERT_EQ(IterStatus(iter), "key4->val4");
        iter->Prev();
        ASSERT_EQ(IterStatus(iter), "key3->val3");
1622

1623 1624 1625 1626 1627
        iter->Next();
        ASSERT_EQ(IterStatus(iter), "key4->val4");
        iter->Next();
        ASSERT_EQ(IterStatus(iter), "key5->val5");
      }
1628 1629 1630 1631 1632
      iter->Next();
      ASSERT_TRUE(!iter->Valid());
    }
    db_->ReleaseSnapshot(snapshot);
    delete iter;
1633 1634
    // skip as HashCuckooRep does not support snapshot
  } while (ChangeOptions(kSkipHashCuckoo));
1635 1636
}

I
Igor Sugak 已提交
1637
TEST_F(DBTest, Recover) {
S
Sanjay Ghemawat 已提交
1638
  do {
L
Lei Jin 已提交
1639
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
1640 1641 1642
    ASSERT_OK(Put(1, "foo", "v1"));
    ASSERT_OK(Put(1, "baz", "v5"));

L
Lei Jin 已提交
1643
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
1644 1645 1646 1647 1648 1649 1650
    ASSERT_EQ("v1", Get(1, "foo"));

    ASSERT_EQ("v1", Get(1, "foo"));
    ASSERT_EQ("v5", Get(1, "baz"));
    ASSERT_OK(Put(1, "bar", "v2"));
    ASSERT_OK(Put(1, "foo", "v3"));

L
Lei Jin 已提交
1651
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
1652 1653 1654 1655 1656
    ASSERT_EQ("v3", Get(1, "foo"));
    ASSERT_OK(Put(1, "foo", "v4"));
    ASSERT_EQ("v4", Get(1, "foo"));
    ASSERT_EQ("v2", Get(1, "bar"));
    ASSERT_EQ("v5", Get(1, "baz"));
S
Sanjay Ghemawat 已提交
1657
  } while (ChangeOptions());
J
jorlow@chromium.org 已提交
1658 1659
}

I
Igor Sugak 已提交
1660
TEST_F(DBTest, RecoverWithTableHandle) {
1661
  do {
1662
    Options options;
1663 1664 1665
    options.create_if_missing = true;
    options.write_buffer_size = 100;
    options.disable_auto_compactions = true;
1666
    options = CurrentOptions(options);
L
Lei Jin 已提交
1667
    DestroyAndReopen(options);
L
Lei Jin 已提交
1668
    CreateAndReopenWithCF({"pikachu"}, options);
1669

1670 1671 1672 1673 1674 1675 1676
    ASSERT_OK(Put(1, "foo", "v1"));
    ASSERT_OK(Put(1, "bar", "v2"));
    ASSERT_OK(Flush(1));
    ASSERT_OK(Put(1, "foo", "v3"));
    ASSERT_OK(Put(1, "bar", "v4"));
    ASSERT_OK(Flush(1));
    ASSERT_OK(Put(1, "big", std::string(100, 'a')));
L
Lei Jin 已提交
1677
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
1678 1679

    std::vector<std::vector<FileMetaData>> files;
1680
    dbfull()->TEST_GetFilesMetaData(handles_[1], &files);
1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697
    int total_files = 0;
    for (const auto& level : files) {
      total_files += level.size();
    }
    ASSERT_EQ(total_files, 3);
    for (const auto& level : files) {
      for (const auto& file : level) {
        if (kInfiniteMaxOpenFiles == option_config_) {
          ASSERT_TRUE(file.table_reader_handle != nullptr);
        } else {
          ASSERT_TRUE(file.table_reader_handle == nullptr);
        }
      }
    }
  } while (ChangeOptions());
}

I
Igor Sugak 已提交
1698
TEST_F(DBTest, IgnoreRecoveredLog) {
I
Igor Canadi 已提交
1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714
  std::string backup_logs = dbname_ + "/backup_logs";

  // delete old files in backup_logs directory
  env_->CreateDirIfMissing(backup_logs);
  std::vector<std::string> old_files;
  env_->GetChildren(backup_logs, &old_files);
  for (auto& file : old_files) {
    if (file != "." && file != "..") {
      env_->DeleteFile(backup_logs + "/" + file);
    }
  }

  do {
    Options options = CurrentOptions();
    options.create_if_missing = true;
    options.merge_operator = MergeOperators::CreateUInt64AddOperator();
1715 1716
    options.wal_dir = dbname_ + "/logs";
    DestroyAndReopen(options);
I
Igor Canadi 已提交
1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735

    // fill up the DB
    std::string one, two;
    PutFixed64(&one, 1);
    PutFixed64(&two, 2);
    ASSERT_OK(db_->Merge(WriteOptions(), Slice("foo"), Slice(one)));
    ASSERT_OK(db_->Merge(WriteOptions(), Slice("foo"), Slice(one)));
    ASSERT_OK(db_->Merge(WriteOptions(), Slice("bar"), Slice(one)));

    // copy the logs to backup
    std::vector<std::string> logs;
    env_->GetChildren(options.wal_dir, &logs);
    for (auto& log : logs) {
      if (log != ".." && log != ".") {
        CopyFile(options.wal_dir + "/" + log, backup_logs + "/" + log);
      }
    }

    // recover the DB
L
Lei Jin 已提交
1736
    Reopen(options);
I
Igor Canadi 已提交
1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749
    ASSERT_EQ(two, Get("foo"));
    ASSERT_EQ(one, Get("bar"));
    Close();

    // copy the logs from backup back to wal dir
    for (auto& log : logs) {
      if (log != ".." && log != ".") {
        CopyFile(backup_logs + "/" + log, options.wal_dir + "/" + log);
      }
    }
    // this should ignore the log files, recovery should not happen again
    // if the recovery happens, the same merge operator would be called twice,
    // leading to incorrect results
L
Lei Jin 已提交
1750
    Reopen(options);
I
Igor Canadi 已提交
1751 1752 1753
    ASSERT_EQ(two, Get("foo"));
    ASSERT_EQ(one, Get("bar"));
    Close();
L
Lei Jin 已提交
1754
    Destroy(options);
L
Lei Jin 已提交
1755
    Reopen(options);
1756
    Close();
I
Igor Canadi 已提交
1757 1758 1759 1760 1761 1762 1763 1764 1765 1766

    // copy the logs from backup back to wal dir
    env_->CreateDirIfMissing(options.wal_dir);
    for (auto& log : logs) {
      if (log != ".." && log != ".") {
        CopyFile(backup_logs + "/" + log, options.wal_dir + "/" + log);
      }
    }
    // assert that we successfully recovered only from logs, even though we
    // destroyed the DB
L
Lei Jin 已提交
1767
    Reopen(options);
I
Igor Canadi 已提交
1768 1769
    ASSERT_EQ(two, Get("foo"));
    ASSERT_EQ(one, Get("bar"));
1770 1771

    // Recovery will fail if DB directory doesn't exist.
L
Lei Jin 已提交
1772
    Destroy(options);
1773 1774 1775 1776 1777 1778 1779 1780 1781
    // copy the logs from backup back to wal dir
    env_->CreateDirIfMissing(options.wal_dir);
    for (auto& log : logs) {
      if (log != ".." && log != ".") {
        CopyFile(backup_logs + "/" + log, options.wal_dir + "/" + log);
        // we won't be needing this file no more
        env_->DeleteFile(backup_logs + "/" + log);
      }
    }
L
Lei Jin 已提交
1782
    Status s = TryReopen(options);
1783
    ASSERT_TRUE(!s.ok());
1784
  } while (ChangeOptions(kSkipHashCuckoo));
I
Igor Canadi 已提交
1785 1786
}

I
Igor Sugak 已提交
1787
TEST_F(DBTest, RollLog) {
H
heyongqiang 已提交
1788
  do {
L
Lei Jin 已提交
1789
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
1790 1791
    ASSERT_OK(Put(1, "foo", "v1"));
    ASSERT_OK(Put(1, "baz", "v5"));
H
heyongqiang 已提交
1792

L
Lei Jin 已提交
1793
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
H
heyongqiang 已提交
1794
    for (int i = 0; i < 10; i++) {
L
Lei Jin 已提交
1795
      ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
H
heyongqiang 已提交
1796
    }
1797
    ASSERT_OK(Put(1, "foo", "v4"));
H
heyongqiang 已提交
1798
    for (int i = 0; i < 10; i++) {
L
Lei Jin 已提交
1799
      ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
H
heyongqiang 已提交
1800 1801 1802 1803
    }
  } while (ChangeOptions());
}

I
Igor Sugak 已提交
1804
TEST_F(DBTest, WAL) {
1805
  do {
L
Lei Jin 已提交
1806
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
1807 1808
    WriteOptions writeOpt = WriteOptions();
    writeOpt.disableWAL = true;
1809 1810
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "foo", "v1"));
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "bar", "v1"));
H
heyongqiang 已提交
1811

L
Lei Jin 已提交
1812
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
1813 1814
    ASSERT_EQ("v1", Get(1, "foo"));
    ASSERT_EQ("v1", Get(1, "bar"));
H
heyongqiang 已提交
1815

1816
    writeOpt.disableWAL = false;
1817
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "bar", "v2"));
1818
    writeOpt.disableWAL = true;
1819
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "foo", "v2"));
H
heyongqiang 已提交
1820

L
Lei Jin 已提交
1821
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
1822
    // Both value's should be present.
1823 1824
    ASSERT_EQ("v2", Get(1, "bar"));
    ASSERT_EQ("v2", Get(1, "foo"));
H
heyongqiang 已提交
1825

1826
    writeOpt.disableWAL = true;
1827
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "bar", "v3"));
1828
    writeOpt.disableWAL = false;
1829
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "foo", "v3"));
H
heyongqiang 已提交
1830

L
Lei Jin 已提交
1831
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
1832
    // again both values should be present.
1833 1834
    ASSERT_EQ("v3", Get(1, "foo"));
    ASSERT_EQ("v3", Get(1, "bar"));
1835
  } while (ChangeCompactOptions());
H
heyongqiang 已提交
1836 1837
}

I
Igor Sugak 已提交
1838
TEST_F(DBTest, CheckLock) {
1839 1840 1841
  do {
    DB* localdb;
    Options options = CurrentOptions();
L
Lei Jin 已提交
1842
    ASSERT_OK(TryReopen(options));
1843 1844

    // second open should fail
1845
    ASSERT_TRUE(!(DB::Open(options, dbname_, &localdb)).ok());
1846
  } while (ChangeCompactOptions());
1847 1848
}

I
Igor Sugak 已提交
1849
TEST_F(DBTest, FlushMultipleMemtable) {
1850 1851 1852 1853 1854 1855
  do {
    Options options = CurrentOptions();
    WriteOptions writeOpt = WriteOptions();
    writeOpt.disableWAL = true;
    options.max_write_buffer_number = 4;
    options.min_write_buffer_number_to_merge = 3;
1856
    options.max_write_buffer_number_to_maintain = -1;
L
Lei Jin 已提交
1857
    CreateAndReopenWithCF({"pikachu"}, options);
1858 1859 1860 1861 1862 1863 1864
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "foo", "v1"));
    ASSERT_OK(Flush(1));
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "bar", "v1"));

    ASSERT_EQ("v1", Get(1, "foo"));
    ASSERT_EQ("v1", Get(1, "bar"));
    ASSERT_OK(Flush(1));
1865 1866 1867
  } while (ChangeCompactOptions());
}

I
Igor Sugak 已提交
1868
TEST_F(DBTest, NumImmutableMemTable) {
1869 1870 1871 1872 1873 1874
  do {
    Options options = CurrentOptions();
    WriteOptions writeOpt = WriteOptions();
    writeOpt.disableWAL = true;
    options.max_write_buffer_number = 4;
    options.min_write_buffer_number_to_merge = 3;
1875
    options.max_write_buffer_number_to_maintain = 0;
1876
    options.write_buffer_size = 1000000;
L
Lei Jin 已提交
1877
    CreateAndReopenWithCF({"pikachu"}, options);
1878

1879
    std::string big_value(1000000 * 2, 'x');
1880
    std::string num;
1881
    SetPerfLevel(kEnableTime);;
1882
    ASSERT_TRUE(GetPerfLevel() == kEnableTime);
1883

1884 1885 1886
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "k1", big_value));
    ASSERT_TRUE(dbfull()->GetProperty(handles_[1],
                                      "rocksdb.num-immutable-mem-table", &num));
1887
    ASSERT_EQ(num, "0");
1888 1889 1890
    ASSERT_TRUE(dbfull()->GetProperty(
        handles_[1], "rocksdb.num-entries-active-mem-table", &num));
    ASSERT_EQ(num, "1");
1891
    perf_context.Reset();
1892
    Get(1, "k1");
1893
    ASSERT_EQ(1, (int) perf_context.get_from_memtable_count);
1894

1895 1896 1897
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "k2", big_value));
    ASSERT_TRUE(dbfull()->GetProperty(handles_[1],
                                      "rocksdb.num-immutable-mem-table", &num));
1898
    ASSERT_EQ(num, "1");
1899 1900 1901 1902 1903 1904 1905
    ASSERT_TRUE(dbfull()->GetProperty(
        handles_[1], "rocksdb.num-entries-active-mem-table", &num));
    ASSERT_EQ(num, "1");
    ASSERT_TRUE(dbfull()->GetProperty(
        handles_[1], "rocksdb.num-entries-imm-mem-tables", &num));
    ASSERT_EQ(num, "1");

1906
    perf_context.Reset();
1907
    Get(1, "k1");
1908 1909
    ASSERT_EQ(2, (int) perf_context.get_from_memtable_count);
    perf_context.Reset();
1910
    Get(1, "k2");
1911
    ASSERT_EQ(1, (int) perf_context.get_from_memtable_count);
1912

1913
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "k3", big_value));
1914 1915
    ASSERT_TRUE(dbfull()->GetProperty(
        handles_[1], "rocksdb.cur-size-active-mem-table", &num));
1916 1917
    ASSERT_TRUE(dbfull()->GetProperty(handles_[1],
                                      "rocksdb.num-immutable-mem-table", &num));
1918
    ASSERT_EQ(num, "2");
1919 1920 1921 1922 1923 1924
    ASSERT_TRUE(dbfull()->GetProperty(
        handles_[1], "rocksdb.num-entries-active-mem-table", &num));
    ASSERT_EQ(num, "1");
    ASSERT_TRUE(dbfull()->GetProperty(
        handles_[1], "rocksdb.num-entries-imm-mem-tables", &num));
    ASSERT_EQ(num, "2");
1925
    perf_context.Reset();
1926
    Get(1, "k2");
1927 1928
    ASSERT_EQ(2, (int) perf_context.get_from_memtable_count);
    perf_context.Reset();
1929
    Get(1, "k3");
1930 1931
    ASSERT_EQ(1, (int) perf_context.get_from_memtable_count);
    perf_context.Reset();
1932
    Get(1, "k1");
1933
    ASSERT_EQ(3, (int) perf_context.get_from_memtable_count);
1934

1935 1936 1937
    ASSERT_OK(Flush(1));
    ASSERT_TRUE(dbfull()->GetProperty(handles_[1],
                                      "rocksdb.num-immutable-mem-table", &num));
1938
    ASSERT_EQ(num, "0");
1939 1940
    ASSERT_TRUE(dbfull()->GetProperty(
        handles_[1], "rocksdb.cur-size-active-mem-table", &num));
S
sdong 已提交
1941
    // "200" is the size of the metadata of an empty skiplist, this would
1942
    // break if we change the default skiplist implementation
S
sdong 已提交
1943
    ASSERT_EQ(num, "200");
1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972

    uint64_t int_num;
    uint64_t base_total_size;
    ASSERT_TRUE(dbfull()->GetIntProperty(
        handles_[1], "rocksdb.estimate-num-keys", &base_total_size));

    ASSERT_OK(dbfull()->Delete(writeOpt, handles_[1], "k2"));
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "k3", ""));
    ASSERT_OK(dbfull()->Delete(writeOpt, handles_[1], "k3"));
    ASSERT_TRUE(dbfull()->GetIntProperty(
        handles_[1], "rocksdb.num-deletes-active-mem-table", &int_num));
    ASSERT_EQ(int_num, 2U);
    ASSERT_TRUE(dbfull()->GetIntProperty(
        handles_[1], "rocksdb.num-entries-active-mem-table", &int_num));
    ASSERT_EQ(int_num, 3U);

    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "k2", big_value));
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "k2", big_value));
    ASSERT_TRUE(dbfull()->GetIntProperty(
        handles_[1], "rocksdb.num-entries-imm-mem-tables", &int_num));
    ASSERT_EQ(int_num, 4U);
    ASSERT_TRUE(dbfull()->GetIntProperty(
        handles_[1], "rocksdb.num-deletes-imm-mem-tables", &int_num));
    ASSERT_EQ(int_num, 2U);

    ASSERT_TRUE(dbfull()->GetIntProperty(
        handles_[1], "rocksdb.estimate-num-keys", &int_num));
    ASSERT_EQ(int_num, base_total_size + 1);

1973
    SetPerfLevel(kDisable);
1974
    ASSERT_TRUE(GetPerfLevel() == kDisable);
1975 1976 1977
  } while (ChangeCompactOptions());
}

1978 1979
class SleepingBackgroundTask {
 public:
I
Igor Canadi 已提交
1980 1981
  SleepingBackgroundTask()
      : bg_cv_(&mutex_), should_sleep_(true), done_with_sleep_(false) {}
1982 1983 1984 1985 1986
  void DoSleep() {
    MutexLock l(&mutex_);
    while (should_sleep_) {
      bg_cv_.Wait();
    }
I
Igor Canadi 已提交
1987 1988
    done_with_sleep_ = true;
    bg_cv_.SignalAll();
1989 1990 1991 1992 1993 1994
  }
  void WakeUp() {
    MutexLock l(&mutex_);
    should_sleep_ = false;
    bg_cv_.SignalAll();
  }
I
Igor Canadi 已提交
1995 1996 1997 1998 1999 2000
  void WaitUntilDone() {
    MutexLock l(&mutex_);
    while (!done_with_sleep_) {
      bg_cv_.Wait();
    }
  }
2001 2002 2003 2004 2005 2006 2007 2008 2009 2010
  bool WokenUp() {
    MutexLock l(&mutex_);
    return should_sleep_ == false;
  }

  void Reset() {
    MutexLock l(&mutex_);
    should_sleep_ = true;
    done_with_sleep_ = false;
  }
2011 2012 2013 2014 2015 2016 2017 2018 2019

  static void DoSleepTask(void* arg) {
    reinterpret_cast<SleepingBackgroundTask*>(arg)->DoSleep();
  }

 private:
  port::Mutex mutex_;
  port::CondVar bg_cv_;  // Signalled when background work finishes
  bool should_sleep_;
I
Igor Canadi 已提交
2020
  bool done_with_sleep_;
2021 2022
};

I
Igor Sugak 已提交
2023
TEST_F(DBTest, FlushEmptyColumnFamily) {
2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040
  // Block flush thread and disable compaction thread
  env_->SetBackgroundThreads(1, Env::HIGH);
  env_->SetBackgroundThreads(1, Env::LOW);
  SleepingBackgroundTask sleeping_task_low;
  env_->Schedule(&SleepingBackgroundTask::DoSleepTask, &sleeping_task_low,
                 Env::Priority::LOW);
  SleepingBackgroundTask sleeping_task_high;
  env_->Schedule(&SleepingBackgroundTask::DoSleepTask, &sleeping_task_high,
                 Env::Priority::HIGH);

  Options options = CurrentOptions();
  // disable compaction
  options.disable_auto_compactions = true;
  WriteOptions writeOpt = WriteOptions();
  writeOpt.disableWAL = true;
  options.max_write_buffer_number = 2;
  options.min_write_buffer_number_to_merge = 1;
2041
  options.max_write_buffer_number_to_maintain = 1;
L
Lei Jin 已提交
2042
  CreateAndReopenWithCF({"pikachu"}, options);
2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066

  // Compaction can still go through even if no thread can flush the
  // mem table.
  ASSERT_OK(Flush(0));
  ASSERT_OK(Flush(1));

  // Insert can go through
  ASSERT_OK(dbfull()->Put(writeOpt, handles_[0], "foo", "v1"));
  ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "bar", "v1"));

  ASSERT_EQ("v1", Get(0, "foo"));
  ASSERT_EQ("v1", Get(1, "bar"));

  sleeping_task_high.WakeUp();
  sleeping_task_high.WaitUntilDone();

  // Flush can still go through.
  ASSERT_OK(Flush(0));
  ASSERT_OK(Flush(1));

  sleeping_task_low.WakeUp();
  sleeping_task_low.WaitUntilDone();
}

I
Igor Sugak 已提交
2067
TEST_F(DBTest, GetProperty) {
2068 2069 2070
  // Set sizes to both background thread pool to be 1 and block them.
  env_->SetBackgroundThreads(1, Env::HIGH);
  env_->SetBackgroundThreads(1, Env::LOW);
I
Igor Canadi 已提交
2071
  SleepingBackgroundTask sleeping_task_low;
2072 2073
  env_->Schedule(&SleepingBackgroundTask::DoSleepTask, &sleeping_task_low,
                 Env::Priority::LOW);
I
Igor Canadi 已提交
2074
  SleepingBackgroundTask sleeping_task_high;
2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087
  env_->Schedule(&SleepingBackgroundTask::DoSleepTask, &sleeping_task_high,
                 Env::Priority::HIGH);

  Options options = CurrentOptions();
  WriteOptions writeOpt = WriteOptions();
  writeOpt.disableWAL = true;
  options.compaction_style = kCompactionStyleUniversal;
  options.level0_file_num_compaction_trigger = 1;
  options.compaction_options_universal.size_ratio = 50;
  options.max_background_compactions = 1;
  options.max_background_flushes = 1;
  options.max_write_buffer_number = 10;
  options.min_write_buffer_number_to_merge = 1;
2088
  options.max_write_buffer_number_to_maintain = 0;
2089
  options.write_buffer_size = 1000000;
L
Lei Jin 已提交
2090
  Reopen(options);
2091 2092 2093

  std::string big_value(1000000 * 2, 'x');
  std::string num;
2094
  uint64_t int_num;
2095 2096
  SetPerfLevel(kEnableTime);

2097 2098 2099 2100
  ASSERT_TRUE(
      dbfull()->GetIntProperty("rocksdb.estimate-table-readers-mem", &int_num));
  ASSERT_EQ(int_num, 0U);

2101 2102 2103 2104 2105 2106 2107
  ASSERT_OK(dbfull()->Put(writeOpt, "k1", big_value));
  ASSERT_TRUE(dbfull()->GetProperty("rocksdb.num-immutable-mem-table", &num));
  ASSERT_EQ(num, "0");
  ASSERT_TRUE(dbfull()->GetProperty("rocksdb.mem-table-flush-pending", &num));
  ASSERT_EQ(num, "0");
  ASSERT_TRUE(dbfull()->GetProperty("rocksdb.compaction-pending", &num));
  ASSERT_EQ(num, "0");
S
sdong 已提交
2108 2109
  ASSERT_TRUE(dbfull()->GetProperty("rocksdb.estimate-num-keys", &num));
  ASSERT_EQ(num, "1");
2110 2111 2112 2113 2114
  perf_context.Reset();

  ASSERT_OK(dbfull()->Put(writeOpt, "k2", big_value));
  ASSERT_TRUE(dbfull()->GetProperty("rocksdb.num-immutable-mem-table", &num));
  ASSERT_EQ(num, "1");
S
sdong 已提交
2115
  ASSERT_OK(dbfull()->Delete(writeOpt, "k-non-existing"));
2116 2117 2118 2119 2120 2121 2122
  ASSERT_OK(dbfull()->Put(writeOpt, "k3", big_value));
  ASSERT_TRUE(dbfull()->GetProperty("rocksdb.num-immutable-mem-table", &num));
  ASSERT_EQ(num, "2");
  ASSERT_TRUE(dbfull()->GetProperty("rocksdb.mem-table-flush-pending", &num));
  ASSERT_EQ(num, "1");
  ASSERT_TRUE(dbfull()->GetProperty("rocksdb.compaction-pending", &num));
  ASSERT_EQ(num, "0");
S
sdong 已提交
2123
  ASSERT_TRUE(dbfull()->GetProperty("rocksdb.estimate-num-keys", &num));
2124
  ASSERT_EQ(num, "2");
2125 2126 2127 2128 2129 2130 2131 2132
  // Verify the same set of properties through GetIntProperty
  ASSERT_TRUE(
      dbfull()->GetIntProperty("rocksdb.num-immutable-mem-table", &int_num));
  ASSERT_EQ(int_num, 2U);
  ASSERT_TRUE(
      dbfull()->GetIntProperty("rocksdb.mem-table-flush-pending", &int_num));
  ASSERT_EQ(int_num, 1U);
  ASSERT_TRUE(dbfull()->GetIntProperty("rocksdb.compaction-pending", &int_num));
2133
  ASSERT_EQ(int_num, 0U);
2134
  ASSERT_TRUE(dbfull()->GetIntProperty("rocksdb.estimate-num-keys", &int_num));
2135
  ASSERT_EQ(int_num, 2U);
2136

2137 2138 2139 2140
  ASSERT_TRUE(
      dbfull()->GetIntProperty("rocksdb.estimate-table-readers-mem", &int_num));
  ASSERT_EQ(int_num, 0U);

2141
  sleeping_task_high.WakeUp();
I
Igor Canadi 已提交
2142
  sleeping_task_high.WaitUntilDone();
2143 2144 2145 2146 2147 2148 2149 2150 2151
  dbfull()->TEST_WaitForFlushMemTable();

  ASSERT_OK(dbfull()->Put(writeOpt, "k4", big_value));
  ASSERT_OK(dbfull()->Put(writeOpt, "k5", big_value));
  dbfull()->TEST_WaitForFlushMemTable();
  ASSERT_TRUE(dbfull()->GetProperty("rocksdb.mem-table-flush-pending", &num));
  ASSERT_EQ(num, "0");
  ASSERT_TRUE(dbfull()->GetProperty("rocksdb.compaction-pending", &num));
  ASSERT_EQ(num, "1");
S
sdong 已提交
2152 2153
  ASSERT_TRUE(dbfull()->GetProperty("rocksdb.estimate-num-keys", &num));
  ASSERT_EQ(num, "4");
2154 2155 2156 2157 2158

  ASSERT_TRUE(
      dbfull()->GetIntProperty("rocksdb.estimate-table-readers-mem", &int_num));
  ASSERT_GT(int_num, 0U);

2159
  sleeping_task_low.WakeUp();
I
Igor Canadi 已提交
2160
  sleeping_task_low.WaitUntilDone();
2161 2162 2163

  dbfull()->TEST_WaitForFlushMemTable();
  options.max_open_files = 10;
L
Lei Jin 已提交
2164
  Reopen(options);
2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176
  // After reopening, no table reader is loaded, so no memory for table readers
  ASSERT_TRUE(
      dbfull()->GetIntProperty("rocksdb.estimate-table-readers-mem", &int_num));
  ASSERT_EQ(int_num, 0U);
  ASSERT_TRUE(dbfull()->GetIntProperty("rocksdb.estimate-num-keys", &int_num));
  ASSERT_GT(int_num, 0U);

  // After reading a key, at least one table reader is loaded.
  Get("k5");
  ASSERT_TRUE(
      dbfull()->GetIntProperty("rocksdb.estimate-table-readers-mem", &int_num));
  ASSERT_GT(int_num, 0U);
2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213

  // Test rocksdb.num-live-versions
  {
    options.level0_file_num_compaction_trigger = 20;
    Reopen(options);
    ASSERT_TRUE(
        dbfull()->GetIntProperty("rocksdb.num-live-versions", &int_num));
    ASSERT_EQ(int_num, 1U);

    // Use an iterator to hold current version
    std::unique_ptr<Iterator> iter1(dbfull()->NewIterator(ReadOptions()));

    ASSERT_OK(dbfull()->Put(writeOpt, "k6", big_value));
    Flush();
    ASSERT_TRUE(
        dbfull()->GetIntProperty("rocksdb.num-live-versions", &int_num));
    ASSERT_EQ(int_num, 2U);

    // Use an iterator to hold current version
    std::unique_ptr<Iterator> iter2(dbfull()->NewIterator(ReadOptions()));

    ASSERT_OK(dbfull()->Put(writeOpt, "k7", big_value));
    Flush();
    ASSERT_TRUE(
        dbfull()->GetIntProperty("rocksdb.num-live-versions", &int_num));
    ASSERT_EQ(int_num, 3U);

    iter2.reset();
    ASSERT_TRUE(
        dbfull()->GetIntProperty("rocksdb.num-live-versions", &int_num));
    ASSERT_EQ(int_num, 2U);

    iter1.reset();
    ASSERT_TRUE(
        dbfull()->GetIntProperty("rocksdb.num-live-versions", &int_num));
    ASSERT_EQ(int_num, 1U);
  }
2214 2215
}

I
Igor Sugak 已提交
2216
TEST_F(DBTest, FLUSH) {
2217
  do {
L
Lei Jin 已提交
2218
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
2219 2220
    WriteOptions writeOpt = WriteOptions();
    writeOpt.disableWAL = true;
2221
    SetPerfLevel(kEnableTime);;
2222
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "foo", "v1"));
2223
    // this will now also flush the last 2 writes
2224 2225
    ASSERT_OK(Flush(1));
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "bar", "v1"));
H
heyongqiang 已提交
2226

2227
    perf_context.Reset();
2228
    Get(1, "foo");
2229 2230
    ASSERT_TRUE((int) perf_context.get_from_output_files_time > 0);

L
Lei Jin 已提交
2231
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
2232
    ASSERT_EQ("v1", Get(1, "foo"));
2233
    ASSERT_EQ("v1", Get(1, "bar"));
H
heyongqiang 已提交
2234

2235
    writeOpt.disableWAL = true;
2236 2237 2238
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "bar", "v2"));
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "foo", "v2"));
    ASSERT_OK(Flush(1));
H
heyongqiang 已提交
2239

L
Lei Jin 已提交
2240
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
2241
    ASSERT_EQ("v2", Get(1, "bar"));
2242
    perf_context.Reset();
2243
    ASSERT_EQ("v2", Get(1, "foo"));
2244
    ASSERT_TRUE((int) perf_context.get_from_output_files_time > 0);
H
heyongqiang 已提交
2245

2246
    writeOpt.disableWAL = false;
2247 2248 2249
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "bar", "v3"));
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "foo", "v3"));
    ASSERT_OK(Flush(1));
H
heyongqiang 已提交
2250

L
Lei Jin 已提交
2251
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
2252 2253
    // 'foo' should be there because its put
    // has WAL enabled.
2254 2255
    ASSERT_EQ("v3", Get(1, "foo"));
    ASSERT_EQ("v3", Get(1, "bar"));
2256 2257

    SetPerfLevel(kDisable);
2258
  } while (ChangeCompactOptions());
H
heyongqiang 已提交
2259 2260
}

I
Igor Sugak 已提交
2261
TEST_F(DBTest, RecoveryWithEmptyLog) {
S
Sanjay Ghemawat 已提交
2262
  do {
L
Lei Jin 已提交
2263
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
2264 2265
    ASSERT_OK(Put(1, "foo", "v1"));
    ASSERT_OK(Put(1, "foo", "v2"));
L
Lei Jin 已提交
2266 2267
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
2268
    ASSERT_OK(Put(1, "foo", "v3"));
L
Lei Jin 已提交
2269
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
2270
    ASSERT_EQ("v3", Get(1, "foo"));
S
Sanjay Ghemawat 已提交
2271
  } while (ChangeOptions());
J
jorlow@chromium.org 已提交
2272 2273
}

2274 2275
// Check that writes done during a memtable compaction are recovered
// if the database is shutdown during the memtable compaction.
I
Igor Sugak 已提交
2276
TEST_F(DBTest, RecoverDuringMemtableCompaction) {
S
Sanjay Ghemawat 已提交
2277
  do {
2278
    Options options;
S
Sanjay Ghemawat 已提交
2279 2280
    options.env = env_;
    options.write_buffer_size = 1000000;
2281
    options = CurrentOptions(options);
L
Lei Jin 已提交
2282
    CreateAndReopenWithCF({"pikachu"}, options);
2283

S
Sanjay Ghemawat 已提交
2284
    // Trigger a long memtable compaction and reopen the database during it
2285 2286 2287 2288 2289
    ASSERT_OK(Put(1, "foo", "v1"));  // Goes to 1st log file
    ASSERT_OK(Put(1, "big1", std::string(10000000, 'x')));  // Fills memtable
    ASSERT_OK(Put(1, "big2", std::string(1000, 'y')));  // Triggers compaction
    ASSERT_OK(Put(1, "bar", "v2"));                     // Goes to new log file

L
Lei Jin 已提交
2290
    ReopenWithColumnFamilies({"default", "pikachu"}, options);
2291 2292 2293 2294
    ASSERT_EQ("v1", Get(1, "foo"));
    ASSERT_EQ("v2", Get(1, "bar"));
    ASSERT_EQ(std::string(10000000, 'x'), Get(1, "big1"));
    ASSERT_EQ(std::string(1000, 'y'), Get(1, "big2"));
S
Sanjay Ghemawat 已提交
2295
  } while (ChangeOptions());
2296 2297
}

2298 2299 2300
// false positive TSAN report on shared_ptr --
// https://groups.google.com/forum/#!topic/thread-sanitizer/vz_s-t226Vg
#ifndef ROCKSDB_TSAN_RUN
I
Igor Sugak 已提交
2301
TEST_F(DBTest, FlushSchedule) {
I
Igor Canadi 已提交
2302 2303 2304 2305 2306
  Options options = CurrentOptions();
  options.disable_auto_compactions = true;
  options.level0_stop_writes_trigger = 1 << 10;
  options.level0_slowdown_writes_trigger = 1 << 10;
  options.min_write_buffer_number_to_merge = 1;
2307
  options.max_write_buffer_number_to_maintain = 1;
I
Igor Canadi 已提交
2308 2309
  options.max_write_buffer_number = 2;
  options.write_buffer_size = 100 * 1000;
L
Lei Jin 已提交
2310
  CreateAndReopenWithCF({"pikachu"}, options);
I
Igor Canadi 已提交
2311 2312
  std::vector<std::thread> threads;

I
Igor Canadi 已提交
2313
  std::atomic<int> thread_num(0);
I
Igor Canadi 已提交
2314 2315 2316 2317 2318 2319
  // each column family will have 5 thread, each thread generating 2 memtables.
  // each column family should end up with 10 table files
  for (int i = 0; i < 10; ++i) {
    threads.emplace_back([&]() {
      int a = thread_num.fetch_add(1);
      Random rnd(a);
I
Igor Canadi 已提交
2320
      WriteOptions wo;
I
Igor Canadi 已提交
2321 2322
      // this should fill up 2 memtables
      for (int k = 0; k < 5000; ++k) {
I
Igor Canadi 已提交
2323
        ASSERT_OK(db_->Put(wo, handles_[a & 1], RandomString(&rnd, 13), ""));
I
Igor Canadi 已提交
2324 2325 2326 2327 2328 2329 2330 2331
      }
    });
  }

  for (auto& t : threads) {
    t.join();
  }

I
Igor Canadi 已提交
2332 2333 2334 2335 2336 2337
  auto default_tables = GetNumberOfSstFilesForColumnFamily(db_, "default");
  auto pikachu_tables = GetNumberOfSstFilesForColumnFamily(db_, "pikachu");
  ASSERT_LE(default_tables, static_cast<uint64_t>(10));
  ASSERT_GT(default_tables, static_cast<uint64_t>(0));
  ASSERT_LE(pikachu_tables, static_cast<uint64_t>(10));
  ASSERT_GT(pikachu_tables, static_cast<uint64_t>(0));
I
Igor Canadi 已提交
2338
}
2339
#endif  // enabled only if not TSAN run
I
Igor Canadi 已提交
2340

I
Igor Sugak 已提交
2341
TEST_F(DBTest, MinorCompactionsHappen) {
2342
  do {
2343
    Options options;
2344
    options.write_buffer_size = 10000;
2345
    options = CurrentOptions(options);
L
Lei Jin 已提交
2346
    CreateAndReopenWithCF({"pikachu"}, options);
J
jorlow@chromium.org 已提交
2347

2348
    const int N = 500;
J
jorlow@chromium.org 已提交
2349

2350
    int starting_num_tables = TotalTableFiles(1);
2351
    for (int i = 0; i < N; i++) {
2352
      ASSERT_OK(Put(1, Key(i), Key(i) + std::string(1000, 'v')));
2353
    }
2354
    int ending_num_tables = TotalTableFiles(1);
2355
    ASSERT_GT(ending_num_tables, starting_num_tables);
J
jorlow@chromium.org 已提交
2356

2357
    for (int i = 0; i < N; i++) {
2358
      ASSERT_EQ(Key(i) + std::string(1000, 'v'), Get(1, Key(i)));
2359
    }
J
jorlow@chromium.org 已提交
2360

L
Lei Jin 已提交
2361
    ReopenWithColumnFamilies({"default", "pikachu"}, options);
J
jorlow@chromium.org 已提交
2362

2363
    for (int i = 0; i < N; i++) {
2364
      ASSERT_EQ(Key(i) + std::string(1000, 'v'), Get(1, Key(i)));
2365 2366
    }
  } while (ChangeCompactOptions());
J
jorlow@chromium.org 已提交
2367 2368
}

I
Igor Sugak 已提交
2369
TEST_F(DBTest, ManifestRollOver) {
2370
  do {
2371
    Options options;
2372
    options.max_manifest_file_size = 10 ;  // 10 bytes
2373
    options = CurrentOptions(options);
L
Lei Jin 已提交
2374
    CreateAndReopenWithCF({"pikachu"}, options);
2375
    {
2376 2377 2378 2379 2380 2381
      ASSERT_OK(Put(1, "manifest_key1", std::string(1000, '1')));
      ASSERT_OK(Put(1, "manifest_key2", std::string(1000, '2')));
      ASSERT_OK(Put(1, "manifest_key3", std::string(1000, '3')));
      uint64_t manifest_before_flush = dbfull()->TEST_Current_Manifest_FileNo();
      ASSERT_OK(Flush(1));  // This should trigger LogAndApply.
      uint64_t manifest_after_flush = dbfull()->TEST_Current_Manifest_FileNo();
M
Mayank Agarwal 已提交
2382
      ASSERT_GT(manifest_after_flush, manifest_before_flush);
L
Lei Jin 已提交
2383
      ReopenWithColumnFamilies({"default", "pikachu"}, options);
2384
      ASSERT_GT(dbfull()->TEST_Current_Manifest_FileNo(), manifest_after_flush);
2385
      // check if a new manifest file got inserted or not.
2386 2387 2388
      ASSERT_EQ(std::string(1000, '1'), Get(1, "manifest_key1"));
      ASSERT_EQ(std::string(1000, '2'), Get(1, "manifest_key2"));
      ASSERT_EQ(std::string(1000, '3'), Get(1, "manifest_key3"));
2389 2390
    }
  } while (ChangeCompactOptions());
A
Abhishek Kona 已提交
2391 2392
}

I
Igor Sugak 已提交
2393
TEST_F(DBTest, IdentityAcrossRestarts) {
M
Mayank Agarwal 已提交
2394
  do {
2395 2396
    std::string id1;
    ASSERT_OK(db_->GetDbIdentity(id1));
M
Mayank Agarwal 已提交
2397 2398

    Options options = CurrentOptions();
L
Lei Jin 已提交
2399
    Reopen(options);
2400 2401
    std::string id2;
    ASSERT_OK(db_->GetDbIdentity(id2));
M
Mayank Agarwal 已提交
2402
    // id1 should match id2 because identity was not regenerated
2403
    ASSERT_EQ(id1.compare(id2), 0);
M
Mayank Agarwal 已提交
2404

2405
    std::string idfilename = IdentityFileName(dbname_);
M
Mayank Agarwal 已提交
2406
    ASSERT_OK(env_->DeleteFile(idfilename));
L
Lei Jin 已提交
2407
    Reopen(options);
2408 2409 2410 2411
    std::string id3;
    ASSERT_OK(db_->GetDbIdentity(id3));
    // id1 should NOT match id3 because identity was regenerated
    ASSERT_NE(id1.compare(id3), 0);
M
Mayank Agarwal 已提交
2412 2413 2414
  } while (ChangeCompactOptions());
}

I
Igor Sugak 已提交
2415
TEST_F(DBTest, RecoverWithLargeLog) {
2416 2417 2418
  do {
    {
      Options options = CurrentOptions();
L
Lei Jin 已提交
2419
      CreateAndReopenWithCF({"pikachu"}, options);
2420 2421 2422 2423 2424
      ASSERT_OK(Put(1, "big1", std::string(200000, '1')));
      ASSERT_OK(Put(1, "big2", std::string(200000, '2')));
      ASSERT_OK(Put(1, "small3", std::string(10, '3')));
      ASSERT_OK(Put(1, "small4", std::string(10, '4')));
      ASSERT_EQ(NumTableFilesAtLevel(0, 1), 0);
2425 2426 2427 2428
    }

    // Make sure that if we re-open with a small write buffer size that
    // we flush table files in the middle of a large log file.
2429
    Options options;
2430
    options.write_buffer_size = 100000;
2431
    options = CurrentOptions(options);
L
Lei Jin 已提交
2432
    ReopenWithColumnFamilies({"default", "pikachu"}, options);
2433 2434 2435 2436 2437 2438
    ASSERT_EQ(NumTableFilesAtLevel(0, 1), 3);
    ASSERT_EQ(std::string(200000, '1'), Get(1, "big1"));
    ASSERT_EQ(std::string(200000, '2'), Get(1, "big2"));
    ASSERT_EQ(std::string(10, '3'), Get(1, "small3"));
    ASSERT_EQ(std::string(10, '4'), Get(1, "small4"));
    ASSERT_GT(NumTableFilesAtLevel(0, 1), 1);
2439
  } while (ChangeCompactOptions());
J
jorlow@chromium.org 已提交
2440 2441
}

I
Igor Sugak 已提交
2442
TEST_F(DBTest, CompactionsGenerateMultipleFiles) {
2443
  Options options;
J
jorlow@chromium.org 已提交
2444
  options.write_buffer_size = 100000000;        // Large write buffer
2445
  options = CurrentOptions(options);
L
Lei Jin 已提交
2446
  CreateAndReopenWithCF({"pikachu"}, options);
J
jorlow@chromium.org 已提交
2447 2448 2449 2450

  Random rnd(301);

  // Write 8MB (80 values, each 100K)
2451
  ASSERT_EQ(NumTableFilesAtLevel(0, 1), 0);
J
jorlow@chromium.org 已提交
2452 2453 2454
  std::vector<std::string> values;
  for (int i = 0; i < 80; i++) {
    values.push_back(RandomString(&rnd, 100000));
2455
    ASSERT_OK(Put(1, Key(i), values[i]));
J
jorlow@chromium.org 已提交
2456 2457 2458
  }

  // Reopening moves updates to level-0
L
Lei Jin 已提交
2459
  ReopenWithColumnFamilies({"default", "pikachu"}, options);
2460 2461
  dbfull()->TEST_CompactRange(0, nullptr, nullptr, handles_[1],
                              true /* disallow trivial move */);
J
jorlow@chromium.org 已提交
2462

2463 2464
  ASSERT_EQ(NumTableFilesAtLevel(0, 1), 0);
  ASSERT_GT(NumTableFilesAtLevel(1, 1), 1);
J
jorlow@chromium.org 已提交
2465
  for (int i = 0; i < 80; i++) {
2466
    ASSERT_EQ(Get(1, Key(i)), values[i]);
J
jorlow@chromium.org 已提交
2467 2468 2469
  }
}

2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502
TEST_F(DBTest, TrivialMoveOneFile) {
  int32_t trivial_move = 0;
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:TrivialMove",
      [&](void* arg) { trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  Options options;
  options.write_buffer_size = 100000000;
  options = CurrentOptions(options);
  DestroyAndReopen(options);

  int32_t num_keys = 80;
  int32_t value_size = 100 * 1024;  // 100 KB

  Random rnd(301);
  std::vector<std::string> values;
  for (int i = 0; i < num_keys; i++) {
    values.push_back(RandomString(&rnd, value_size));
    ASSERT_OK(Put(Key(i), values[i]));
  }

  // Reopening moves updates to L0
  Reopen(options);
  ASSERT_EQ(NumTableFilesAtLevel(0, 0), 1);  // 1 file in L0
  ASSERT_EQ(NumTableFilesAtLevel(1, 0), 0);  // 0 files in L1

  std::vector<LiveFileMetaData> metadata;
  db_->GetLiveFilesMetaData(&metadata);
  ASSERT_EQ(metadata.size(), 1U);
  LiveFileMetaData level0_file = metadata[0];  // L0 file meta

  // Compaction will initiate a trivial move from L0 to L1
2503
  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567

  // File moved From L0 to L1
  ASSERT_EQ(NumTableFilesAtLevel(0, 0), 0);  // 0 files in L0
  ASSERT_EQ(NumTableFilesAtLevel(1, 0), 1);  // 1 file in L1

  metadata.clear();
  db_->GetLiveFilesMetaData(&metadata);
  ASSERT_EQ(metadata.size(), 1U);
  ASSERT_EQ(metadata[0].name /* level1_file.name */, level0_file.name);
  ASSERT_EQ(metadata[0].size /* level1_file.size */, level0_file.size);

  for (int i = 0; i < num_keys; i++) {
    ASSERT_EQ(Get(Key(i)), values[i]);
  }

  ASSERT_EQ(trivial_move, 1);
  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
}

TEST_F(DBTest, TrivialMoveNonOverlappingFiles) {
  int32_t trivial_move = 0;
  int32_t non_trivial_move = 0;
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:TrivialMove",
      [&](void* arg) { trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:NonTrivial",
      [&](void* arg) { non_trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  Options options = CurrentOptions();
  options.disable_auto_compactions = true;
  options.write_buffer_size = 10 * 1024 * 1024;

  DestroyAndReopen(options);
  // non overlapping ranges
  std::vector<std::pair<int32_t, int32_t>> ranges = {
    {100, 199},
    {300, 399},
    {0, 99},
    {200, 299},
    {600, 699},
    {400, 499},
    {500, 550},
    {551, 599},
  };
  int32_t value_size = 10 * 1024;  // 10 KB

  Random rnd(301);
  std::map<int32_t, std::string> values;
  for (uint32_t i = 0; i < ranges.size(); i++) {
    for (int32_t j = ranges[i].first; j <= ranges[i].second; j++) {
      values[j] = RandomString(&rnd, value_size);
      ASSERT_OK(Put(Key(j), values[j]));
    }
    ASSERT_OK(Flush());
  }

  int32_t level0_files = NumTableFilesAtLevel(0, 0);
  ASSERT_EQ(level0_files, ranges.size());    // Multiple files in L0
  ASSERT_EQ(NumTableFilesAtLevel(1, 0), 0);  // No files in L1

  // Since data is non-overlapping we expect compaction to initiate
  // a trivial move
2568
  db_->CompactRange(CompactRangeOptions(), nullptr, nullptr);
2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604
  // We expect that all the files were trivially moved from L0 to L1
  ASSERT_EQ(NumTableFilesAtLevel(0, 0), 0);
  ASSERT_EQ(NumTableFilesAtLevel(1, 0) /* level1_files */, level0_files);

  for (uint32_t i = 0; i < ranges.size(); i++) {
    for (int32_t j = ranges[i].first; j <= ranges[i].second; j++) {
      ASSERT_EQ(Get(Key(j)), values[j]);
    }
  }

  ASSERT_EQ(trivial_move, 1);
  ASSERT_EQ(non_trivial_move, 0);

  trivial_move = 0;
  non_trivial_move = 0;
  values.clear();
  DestroyAndReopen(options);
  // Same ranges as above but overlapping
  ranges = {
    {100, 199},
    {300, 399},
    {0, 99},
    {200, 299},
    {600, 699},
    {400, 499},
    {500, 560},  // this range overlap with the next one
    {551, 599},
  };
  for (uint32_t i = 0; i < ranges.size(); i++) {
    for (int32_t j = ranges[i].first; j <= ranges[i].second; j++) {
      values[j] = RandomString(&rnd, value_size);
      ASSERT_OK(Put(Key(j), values[j]));
    }
    ASSERT_OK(Flush());
  }

2605
  db_->CompactRange(CompactRangeOptions(), nullptr, nullptr);
2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617

  for (uint32_t i = 0; i < ranges.size(); i++) {
    for (int32_t j = ranges[i].first; j <= ranges[i].second; j++) {
      ASSERT_EQ(Get(Key(j)), values[j]);
    }
  }
  ASSERT_EQ(trivial_move, 0);
  ASSERT_EQ(non_trivial_move, 1);

  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
}

2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656
TEST_F(DBTest, TrivialMoveTargetLevel) {
  int32_t trivial_move = 0;
  int32_t non_trivial_move = 0;
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:TrivialMove",
      [&](void* arg) { trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:NonTrivial",
      [&](void* arg) { non_trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  Options options = CurrentOptions();
  options.disable_auto_compactions = true;
  options.write_buffer_size = 10 * 1024 * 1024;
  options.num_levels = 7;

  DestroyAndReopen(options);
  int32_t value_size = 10 * 1024;  // 10 KB

  // Add 2 non-overlapping files
  Random rnd(301);
  std::map<int32_t, std::string> values;

  // file 1 [0 => 300]
  for (int32_t i = 0; i <= 300; i++) {
    values[i] = RandomString(&rnd, value_size);
    ASSERT_OK(Put(Key(i), values[i]));
  }
  ASSERT_OK(Flush());

  // file 2 [600 => 700]
  for (int32_t i = 600; i <= 700; i++) {
    values[i] = RandomString(&rnd, value_size);
    ASSERT_OK(Put(Key(i), values[i]));
  }
  ASSERT_OK(Flush());

  // 2 files in L0
  ASSERT_EQ("2", FilesPerLevel(0));
2657 2658 2659 2660
  CompactRangeOptions compact_options;
  compact_options.change_level = true;
  compact_options.target_level = 6;
  ASSERT_OK(db_->CompactRange(compact_options, nullptr, nullptr));
2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674
  // 2 files in L6
  ASSERT_EQ("0,0,0,0,0,0,2", FilesPerLevel(0));

  ASSERT_EQ(trivial_move, 1);
  ASSERT_EQ(non_trivial_move, 0);

  for (int32_t i = 0; i <= 300; i++) {
    ASSERT_EQ(Get(Key(i)), values[i]);
  }
  for (int32_t i = 600; i <= 700; i++) {
    ASSERT_EQ(Get(Key(i)), values[i]);
  }
}

2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732
TEST_F(DBTest, TrivialMoveToLastLevelWithFiles) {
  int32_t trivial_move = 0;
  int32_t non_trivial_move = 0;
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:TrivialMove",
      [&](void* arg) { trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:NonTrivial",
      [&](void* arg) { non_trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  Options options;
  options.write_buffer_size = 100000000;
  options = CurrentOptions(options);
  DestroyAndReopen(options);

  int32_t value_size = 10 * 1024;  // 10 KB

  Random rnd(301);
  std::vector<std::string> values;
  // File with keys [ 0 => 99 ]
  for (int i = 0; i < 100; i++) {
    values.push_back(RandomString(&rnd, value_size));
    ASSERT_OK(Put(Key(i), values[i]));
  }
  ASSERT_OK(Flush());

  ASSERT_EQ("1", FilesPerLevel(0));
  // Compaction will do L0=>L1 (trivial move) then move L1 files to L3
  CompactRangeOptions compact_options;
  compact_options.change_level = true;
  compact_options.target_level = 3;
  ASSERT_OK(db_->CompactRange(compact_options, nullptr, nullptr));
  ASSERT_EQ("0,0,0,1", FilesPerLevel(0));
  ASSERT_EQ(trivial_move, 1);
  ASSERT_EQ(non_trivial_move, 0);

  // File with keys [ 100 => 199 ]
  for (int i = 100; i < 200; i++) {
    values.push_back(RandomString(&rnd, value_size));
    ASSERT_OK(Put(Key(i), values[i]));
  }
  ASSERT_OK(Flush());

  ASSERT_EQ("1,0,0,1", FilesPerLevel(0));
  // Compaction will do L0=>L1 L1=>L2 L2=>L3 (3 trivial moves)
  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
  ASSERT_EQ("0,0,0,2", FilesPerLevel(0));
  ASSERT_EQ(trivial_move, 4);
  ASSERT_EQ(non_trivial_move, 0);

  for (int i = 0; i < 200; i++) {
    ASSERT_EQ(Get(Key(i)), values[i]);
  }

  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
}

I
Igor Sugak 已提交
2733
TEST_F(DBTest, CompactionTrigger) {
2734
  Options options;
2735 2736 2737 2738
  options.write_buffer_size = 100<<10; //100KB
  options.num_levels = 3;
  options.max_mem_compaction_level = 0;
  options.level0_file_num_compaction_trigger = 3;
2739
  options = CurrentOptions(options);
L
Lei Jin 已提交
2740
  CreateAndReopenWithCF({"pikachu"}, options);
2741 2742 2743

  Random rnd(301);

2744
  for (int num = 0; num < options.level0_file_num_compaction_trigger - 1;
2745
       num++) {
2746 2747 2748 2749
    std::vector<std::string> values;
    // Write 120KB (12 values, each 10K)
    for (int i = 0; i < 12; i++) {
      values.push_back(RandomString(&rnd, 10000));
2750
      ASSERT_OK(Put(1, Key(i), values[i]));
2751
    }
2752 2753
    dbfull()->TEST_WaitForFlushMemTable(handles_[1]);
    ASSERT_EQ(NumTableFilesAtLevel(0, 1), num + 1);
2754 2755 2756 2757 2758 2759
  }

  //generate one more file in level-0, and should trigger level-0 compaction
  std::vector<std::string> values;
  for (int i = 0; i < 12; i++) {
    values.push_back(RandomString(&rnd, 10000));
2760
    ASSERT_OK(Put(1, Key(i), values[i]));
2761 2762 2763
  }
  dbfull()->TEST_WaitForCompact();

2764 2765
  ASSERT_EQ(NumTableFilesAtLevel(0, 1), 0);
  ASSERT_EQ(NumTableFilesAtLevel(1, 1), 1);
2766 2767
}

2768 2769 2770 2771 2772 2773 2774 2775 2776
namespace {
static const int kCDTValueSize = 1000;
static const int kCDTKeysPerBuffer = 4;
static const int kCDTNumLevels = 8;
Options DeletionTriggerOptions() {
  Options options;
  options.compression = kNoCompression;
  options.write_buffer_size = kCDTKeysPerBuffer * (kCDTValueSize + 24);
  options.min_write_buffer_number_to_merge = 1;
2777
  options.max_write_buffer_number_to_maintain = 0;
2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790
  options.num_levels = kCDTNumLevels;
  options.max_mem_compaction_level = 0;
  options.level0_file_num_compaction_trigger = 1;
  options.target_file_size_base = options.write_buffer_size * 2;
  options.target_file_size_multiplier = 2;
  options.max_bytes_for_level_base =
      options.target_file_size_base * options.target_file_size_multiplier;
  options.max_bytes_for_level_multiplier = 2;
  options.disable_auto_compactions = false;
  return options;
}
}  // anonymous namespace

I
Igor Sugak 已提交
2791
TEST_F(DBTest, CompactionDeletionTrigger) {
2792 2793
  for (int tid = 0; tid < 2; ++tid) {
    uint64_t db_size[2];
2794 2795 2796 2797 2798 2799 2800
    Options options = CurrentOptions(DeletionTriggerOptions());

    if (tid == 1) {
      // second pass with universal compaction
      options.compaction_style = kCompactionStyleUniversal;
      options.num_levels = 1;
    }
2801

L
Lei Jin 已提交
2802
    DestroyAndReopen(options);
2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826
    Random rnd(301);

    const int kTestSize = kCDTKeysPerBuffer * 512;
    std::vector<std::string> values;
    for (int k = 0; k < kTestSize; ++k) {
      values.push_back(RandomString(&rnd, kCDTValueSize));
      ASSERT_OK(Put(Key(k), values[k]));
    }
    dbfull()->TEST_WaitForFlushMemTable();
    dbfull()->TEST_WaitForCompact();
    db_size[0] = Size(Key(0), Key(kTestSize - 1));

    for (int k = 0; k < kTestSize; ++k) {
      ASSERT_OK(Delete(Key(k)));
    }
    dbfull()->TEST_WaitForFlushMemTable();
    dbfull()->TEST_WaitForCompact();
    db_size[1] = Size(Key(0), Key(kTestSize - 1));

    // must have much smaller db size.
    ASSERT_GT(db_size[0] / 3, db_size[1]);
  }
}

I
Igor Sugak 已提交
2827
TEST_F(DBTest, CompactionDeletionTriggerReopen) {
2828 2829
  for (int tid = 0; tid < 2; ++tid) {
    uint64_t db_size[3];
2830
    Options options = CurrentOptions(DeletionTriggerOptions());
2831

2832 2833 2834 2835 2836 2837
    if (tid == 1) {
      // second pass with universal compaction
      options.compaction_style = kCompactionStyleUniversal;
      options.num_levels = 1;
    }

L
Lei Jin 已提交
2838
    DestroyAndReopen(options);
2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855
    Random rnd(301);

    // round 1 --- insert key/value pairs.
    const int kTestSize = kCDTKeysPerBuffer * 512;
    std::vector<std::string> values;
    for (int k = 0; k < kTestSize; ++k) {
      values.push_back(RandomString(&rnd, kCDTValueSize));
      ASSERT_OK(Put(Key(k), values[k]));
    }
    dbfull()->TEST_WaitForFlushMemTable();
    dbfull()->TEST_WaitForCompact();
    db_size[0] = Size(Key(0), Key(kTestSize - 1));
    Close();

    // round 2 --- disable auto-compactions and issue deletions.
    options.create_if_missing = false;
    options.disable_auto_compactions = true;
L
Lei Jin 已提交
2856
    Reopen(options);
2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869

    for (int k = 0; k < kTestSize; ++k) {
      ASSERT_OK(Delete(Key(k)));
    }
    db_size[1] = Size(Key(0), Key(kTestSize - 1));
    Close();
    // as auto_compaction is off, we shouldn't see too much reduce
    // in db size.
    ASSERT_LT(db_size[0] / 3, db_size[1]);

    // round 3 --- reopen db with auto_compaction on and see if
    // deletion compensation still work.
    options.disable_auto_compactions = false;
L
Lei Jin 已提交
2870
    Reopen(options);
2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882
    // insert relatively small amount of data to trigger auto compaction.
    for (int k = 0; k < kTestSize / 10; ++k) {
      ASSERT_OK(Put(Key(k), values[k]));
    }
    dbfull()->TEST_WaitForFlushMemTable();
    dbfull()->TEST_WaitForCompact();
    db_size[2] = Size(Key(0), Key(kTestSize - 1));
    // this time we're expecting significant drop in size.
    ASSERT_GT(db_size[0] / 3, db_size[2]);
  }
}

2883 2884
namespace {
class KeepFilter : public CompactionFilter {
2885 2886 2887 2888 2889 2890 2891
 public:
  virtual bool Filter(int level, const Slice& key, const Slice& value,
                      std::string* new_value, bool* value_changed) const
      override {
    return false;
  }

2892
  virtual const char* Name() const override { return "KeepFilter"; }
2893 2894 2895 2896 2897 2898 2899 2900
};

class KeepFilterFactory : public CompactionFilterFactory {
 public:
  explicit KeepFilterFactory(bool check_context = false)
      : check_context_(check_context) {}

  virtual std::unique_ptr<CompactionFilter> CreateCompactionFilter(
2901
      const CompactionFilter::Context& context) override {
2902
    if (check_context_) {
2903 2904
      EXPECT_EQ(expect_full_compaction_.load(), context.is_full_compaction);
      EXPECT_EQ(expect_manual_compaction_.load(), context.is_manual_compaction);
2905 2906 2907 2908 2909 2910 2911 2912 2913 2914
    }
    return std::unique_ptr<CompactionFilter>(new KeepFilter());
  }

  virtual const char* Name() const override { return "KeepFilterFactory"; }
  bool check_context_;
  std::atomic_bool expect_full_compaction_;
  std::atomic_bool expect_manual_compaction_;
};

2915
class DelayFilter : public CompactionFilter {
2916
 public:
2917
  explicit DelayFilter(DBTestBase* d) : db_test(d) {}
2918 2919 2920 2921 2922
  virtual bool Filter(int level, const Slice& key, const Slice& value,
                      std::string* new_value,
                      bool* value_changed) const override {
    db_test->env_->addon_time_.fetch_add(1000);
    return true;
2923 2924
  }

2925 2926 2927
  virtual const char* Name() const override { return "DelayFilter"; }

 private:
2928
  DBTestBase* db_test;
2929 2930
};

2931 2932
class DelayFilterFactory : public CompactionFilterFactory {
 public:
2933
  explicit DelayFilterFactory(DBTestBase* d) : db_test(d) {}
2934 2935 2936 2937 2938 2939 2940 2941
  virtual std::unique_ptr<CompactionFilter> CreateCompactionFilter(
      const CompactionFilter::Context& context) override {
    return std::unique_ptr<CompactionFilter>(new DelayFilter(db_test));
  }

  virtual const char* Name() const override { return "DelayFilterFactory"; }

 private:
2942
  DBTestBase* db_test;
2943
};
2944
}  // namespace
S
sdong 已提交
2945

I
Igor Sugak 已提交
2946
TEST_F(DBTest, CompressedCache) {
I
Igor Canadi 已提交
2947
  if (!Snappy_Supported()) {
2948 2949
    return;
  }
2950 2951 2952 2953 2954 2955
  int num_iter = 80;

  // Run this test three iterations.
  // Iteration 1: only a uncompressed block cache
  // Iteration 2: only a compressed block cache
  // Iteration 3: both block cache and compressed cache
I
Igor Canadi 已提交
2956 2957 2958
  // Iteration 4: both block cache and compressed cache, but DB is not
  // compressed
  for (int iter = 0; iter < 4; iter++) {
2959
    Options options;
2960 2961
    options.write_buffer_size = 64*1024;        // small write buffer
    options.statistics = rocksdb::CreateDBStatistics();
2962
    options = CurrentOptions(options);
2963

2964
    BlockBasedTableOptions table_options;
2965 2966 2967
    switch (iter) {
      case 0:
        // only uncompressed block cache
2968 2969 2970
        table_options.block_cache = NewLRUCache(8*1024);
        table_options.block_cache_compressed = nullptr;
        options.table_factory.reset(NewBlockBasedTableFactory(table_options));
2971 2972 2973
        break;
      case 1:
        // no block cache, only compressed cache
2974 2975 2976 2977
        table_options.no_block_cache = true;
        table_options.block_cache = nullptr;
        table_options.block_cache_compressed = NewLRUCache(8*1024);
        options.table_factory.reset(NewBlockBasedTableFactory(table_options));
2978 2979 2980
        break;
      case 2:
        // both compressed and uncompressed block cache
2981 2982 2983
        table_options.block_cache = NewLRUCache(1024);
        table_options.block_cache_compressed = NewLRUCache(8*1024);
        options.table_factory.reset(NewBlockBasedTableFactory(table_options));
2984
        break;
I
Igor Canadi 已提交
2985 2986 2987
      case 3:
        // both block cache and compressed cache, but DB is not compressed
        // also, make block cache sizes bigger, to trigger block cache hits
2988 2989 2990
        table_options.block_cache = NewLRUCache(1024 * 1024);
        table_options.block_cache_compressed = NewLRUCache(8 * 1024 * 1024);
        options.table_factory.reset(NewBlockBasedTableFactory(table_options));
I
Igor Canadi 已提交
2991 2992
        options.compression = kNoCompression;
        break;
2993 2994 2995
      default:
        ASSERT_TRUE(false);
    }
L
Lei Jin 已提交
2996
    CreateAndReopenWithCF({"pikachu"}, options);
2997 2998 2999
    // default column family doesn't have block cache
    Options no_block_cache_opts;
    no_block_cache_opts.statistics = options.statistics;
3000
    no_block_cache_opts = CurrentOptions(no_block_cache_opts);
3001 3002 3003 3004
    BlockBasedTableOptions table_options_no_bc;
    table_options_no_bc.no_block_cache = true;
    no_block_cache_opts.table_factory.reset(
        NewBlockBasedTableFactory(table_options_no_bc));
3005
    ReopenWithColumnFamilies({"default", "pikachu"},
L
Lei Jin 已提交
3006
        std::vector<Options>({no_block_cache_opts, options}));
3007 3008 3009 3010

    Random rnd(301);

    // Write 8MB (80 values, each 100K)
3011
    ASSERT_EQ(NumTableFilesAtLevel(0, 1), 0);
3012 3013 3014 3015 3016 3017 3018
    std::vector<std::string> values;
    std::string str;
    for (int i = 0; i < num_iter; i++) {
      if (i % 4 == 0) {        // high compression ratio
        str = RandomString(&rnd, 1000);
      }
      values.push_back(str);
3019
      ASSERT_OK(Put(1, Key(i), values[i]));
3020 3021 3022
    }

    // flush all data from memtable so that reads are from block cache
3023
    ASSERT_OK(Flush(1));
3024 3025

    for (int i = 0; i < num_iter; i++) {
3026
      ASSERT_EQ(Get(1, Key(i)), values[i]);
3027 3028 3029 3030 3031 3032
    }

    // check that we triggered the appropriate code paths in the cache
    switch (iter) {
      case 0:
        // only uncompressed block cache
I
Igor Canadi 已提交
3033 3034
        ASSERT_GT(TestGetTickerCount(options, BLOCK_CACHE_MISS), 0);
        ASSERT_EQ(TestGetTickerCount(options, BLOCK_CACHE_COMPRESSED_MISS), 0);
3035 3036 3037
        break;
      case 1:
        // no block cache, only compressed cache
I
Igor Canadi 已提交
3038 3039
        ASSERT_EQ(TestGetTickerCount(options, BLOCK_CACHE_MISS), 0);
        ASSERT_GT(TestGetTickerCount(options, BLOCK_CACHE_COMPRESSED_MISS), 0);
3040 3041 3042
        break;
      case 2:
        // both compressed and uncompressed block cache
I
Igor Canadi 已提交
3043 3044
        ASSERT_GT(TestGetTickerCount(options, BLOCK_CACHE_MISS), 0);
        ASSERT_GT(TestGetTickerCount(options, BLOCK_CACHE_COMPRESSED_MISS), 0);
3045
        break;
I
Igor Canadi 已提交
3046 3047 3048 3049 3050 3051 3052 3053 3054
      case 3:
        // both compressed and uncompressed block cache
        ASSERT_GT(TestGetTickerCount(options, BLOCK_CACHE_MISS), 0);
        ASSERT_GT(TestGetTickerCount(options, BLOCK_CACHE_HIT), 0);
        ASSERT_GT(TestGetTickerCount(options, BLOCK_CACHE_COMPRESSED_MISS), 0);
        // compressed doesn't have any hits since blocks are not compressed on
        // storage
        ASSERT_EQ(TestGetTickerCount(options, BLOCK_CACHE_COMPRESSED_HIT), 0);
        break;
3055 3056 3057
      default:
        ASSERT_TRUE(false);
    }
3058 3059

    options.create_if_missing = true;
L
Lei Jin 已提交
3060
    DestroyAndReopen(options);
3061 3062 3063
  }
}

K
kailiu 已提交
3064 3065 3066 3067 3068 3069
static std::string CompressibleString(Random* rnd, int len) {
  std::string r;
  test::CompressibleString(rnd, 0.8, len, &r);
  return r;
}

I
Igor Sugak 已提交
3070
TEST_F(DBTest, FailMoreDbPaths) {
3071
  Options options = CurrentOptions();
3072 3073 3074 3075 3076
  options.db_paths.emplace_back(dbname_, 10000000);
  options.db_paths.emplace_back(dbname_ + "_2", 1000000);
  options.db_paths.emplace_back(dbname_ + "_3", 1000000);
  options.db_paths.emplace_back(dbname_ + "_4", 1000000);
  options.db_paths.emplace_back(dbname_ + "_5", 1000000);
L
Lei Jin 已提交
3077
  ASSERT_TRUE(TryReopen(options).IsNotSupported());
3078
}
3079

I
Igor Sugak 已提交
3080
TEST_F(DBTest, UniversalCompactionSecondPathRatio) {
I
Igor Canadi 已提交
3081
  if (!Snappy_Supported()) {
3082 3083
    return;
  }
3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099
  Options options;
  options.db_paths.emplace_back(dbname_, 500 * 1024);
  options.db_paths.emplace_back(dbname_ + "_2", 1024 * 1024 * 1024);
  options.compaction_style = kCompactionStyleUniversal;
  options.write_buffer_size = 100 << 10;  // 100KB
  options.level0_file_num_compaction_trigger = 2;
  options.num_levels = 1;
  options = CurrentOptions(options);

  std::vector<std::string> filenames;
  env_->GetChildren(options.db_paths[1].path, &filenames);
  // Delete archival files.
  for (size_t i = 0; i < filenames.size(); ++i) {
    env_->DeleteFile(options.db_paths[1].path + "/" + filenames[i]);
  }
  env_->DeleteDir(options.db_paths[1].path);
L
Lei Jin 已提交
3100
  Reopen(options);
3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165

  Random rnd(301);
  int key_idx = 0;

  // First three 110KB files are not going to second path.
  // After that, (100K, 200K)
  for (int num = 0; num < 3; num++) {
    GenerateNewFile(&rnd, &key_idx);
  }

  // Another 110KB triggers a compaction to 400K file to second path
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));

  // (1, 4)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  // (1,1,4) -> (2, 4)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  // (1, 2, 4)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(2, GetSstFileCount(dbname_));

  // (1, 1, 2, 4) -> (8)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(0, GetSstFileCount(dbname_));

  // (1, 8)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  // (1, 1, 8) -> (2, 8)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  // (1, 2, 8)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(2, GetSstFileCount(dbname_));

  // (1, 1, 2, 8) -> (4, 8)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(2, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(0, GetSstFileCount(dbname_));

  // (1, 4, 8)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(2, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  for (int i = 0; i < key_idx; i++) {
    auto v = Get(Key(i));
    ASSERT_NE(v, "NOT_FOUND");
    ASSERT_TRUE(v.size() == 1 || v.size() == 10000);
  }

L
Lei Jin 已提交
3166
  Reopen(options);
3167 3168 3169 3170 3171 3172 3173

  for (int i = 0; i < key_idx; i++) {
    auto v = Get(Key(i));
    ASSERT_NE(v, "NOT_FOUND");
    ASSERT_TRUE(v.size() == 1 || v.size() == 10000);
  }

L
Lei Jin 已提交
3174
  Destroy(options);
3175 3176
}

I
Igor Sugak 已提交
3177
TEST_F(DBTest, LevelCompactionThirdPath) {
3178
  Options options = CurrentOptions();
3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289
  options.db_paths.emplace_back(dbname_, 500 * 1024);
  options.db_paths.emplace_back(dbname_ + "_2", 4 * 1024 * 1024);
  options.db_paths.emplace_back(dbname_ + "_3", 1024 * 1024 * 1024);
  options.compaction_style = kCompactionStyleLevel;
  options.write_buffer_size = 100 << 10;  // 100KB
  options.level0_file_num_compaction_trigger = 2;
  options.num_levels = 4;
  options.max_bytes_for_level_base = 400 * 1024;
  //  options = CurrentOptions(options);

  std::vector<std::string> filenames;
  env_->GetChildren(options.db_paths[1].path, &filenames);
  // Delete archival files.
  for (size_t i = 0; i < filenames.size(); ++i) {
    env_->DeleteFile(options.db_paths[1].path + "/" + filenames[i]);
  }
  env_->DeleteDir(options.db_paths[1].path);
  Reopen(options);

  Random rnd(301);
  int key_idx = 0;

  // First three 110KB files are not going to second path.
  // After that, (100K, 200K)
  for (int num = 0; num < 3; num++) {
    GenerateNewFile(&rnd, &key_idx);
  }

  // Another 110KB triggers a compaction to 400K file to fill up first path
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(3, GetSstFileCount(options.db_paths[1].path));

  // (1, 4)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4", FilesPerLevel(0));
  ASSERT_EQ(4, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  // (1, 4, 1)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4,1", FilesPerLevel(0));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(4, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  // (1, 4, 2)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4,2", FilesPerLevel(0));
  ASSERT_EQ(2, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(4, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  // (1, 4, 3)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4,3", FilesPerLevel(0));
  ASSERT_EQ(3, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(4, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  // (1, 4, 4)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4,4", FilesPerLevel(0));
  ASSERT_EQ(4, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(4, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  // (1, 4, 5)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4,5", FilesPerLevel(0));
  ASSERT_EQ(5, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(4, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  // (1, 4, 6)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4,6", FilesPerLevel(0));
  ASSERT_EQ(6, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(4, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  // (1, 4, 7)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4,7", FilesPerLevel(0));
  ASSERT_EQ(7, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(4, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  // (1, 4, 8)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4,8", FilesPerLevel(0));
  ASSERT_EQ(8, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(4, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  for (int i = 0; i < key_idx; i++) {
    auto v = Get(Key(i));
    ASSERT_NE(v, "NOT_FOUND");
    ASSERT_TRUE(v.size() == 1 || v.size() == 10000);
  }

  Reopen(options);

  for (int i = 0; i < key_idx; i++) {
    auto v = Get(Key(i));
    ASSERT_NE(v, "NOT_FOUND");
    ASSERT_TRUE(v.size() == 1 || v.size() == 10000);
  }

  Destroy(options);
}

I
Igor Sugak 已提交
3290
TEST_F(DBTest, LevelCompactionPathUse) {
3291
  Options options = CurrentOptions();
3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403
  options.db_paths.emplace_back(dbname_, 500 * 1024);
  options.db_paths.emplace_back(dbname_ + "_2", 4 * 1024 * 1024);
  options.db_paths.emplace_back(dbname_ + "_3", 1024 * 1024 * 1024);
  options.compaction_style = kCompactionStyleLevel;
  options.write_buffer_size = 100 << 10;  // 100KB
  options.level0_file_num_compaction_trigger = 2;
  options.num_levels = 4;
  options.max_bytes_for_level_base = 400 * 1024;
  //  options = CurrentOptions(options);

  std::vector<std::string> filenames;
  env_->GetChildren(options.db_paths[1].path, &filenames);
  // Delete archival files.
  for (size_t i = 0; i < filenames.size(); ++i) {
    env_->DeleteFile(options.db_paths[1].path + "/" + filenames[i]);
  }
  env_->DeleteDir(options.db_paths[1].path);
  Reopen(options);

  Random rnd(301);
  int key_idx = 0;

  // Always gets compacted into 1 Level1 file,
  // 0/1 Level 0 file
  for (int num = 0; num < 3; num++) {
    key_idx = 0;
    GenerateNewFile(&rnd, &key_idx);
  }

  key_idx = 0;
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));

  key_idx = 0;
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,1", FilesPerLevel(0));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  key_idx = 0;
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("0,1", FilesPerLevel(0));
  ASSERT_EQ(0, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(0, GetSstFileCount(dbname_));

  key_idx = 0;
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,1", FilesPerLevel(0));
  ASSERT_EQ(0, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  key_idx = 0;
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("0,1", FilesPerLevel(0));
  ASSERT_EQ(0, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(0, GetSstFileCount(dbname_));

  key_idx = 0;
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,1", FilesPerLevel(0));
  ASSERT_EQ(0, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  key_idx = 0;
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("0,1", FilesPerLevel(0));
  ASSERT_EQ(0, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(0, GetSstFileCount(dbname_));

  key_idx = 0;
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,1", FilesPerLevel(0));
  ASSERT_EQ(0, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  key_idx = 0;
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("0,1", FilesPerLevel(0));
  ASSERT_EQ(0, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(0, GetSstFileCount(dbname_));

  key_idx = 0;
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,1", FilesPerLevel(0));
  ASSERT_EQ(0, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  for (int i = 0; i < key_idx; i++) {
    auto v = Get(Key(i));
    ASSERT_NE(v, "NOT_FOUND");
    ASSERT_TRUE(v.size() == 1 || v.size() == 10000);
  }

  Reopen(options);

  for (int i = 0; i < key_idx; i++) {
    auto v = Get(Key(i));
    ASSERT_NE(v, "NOT_FOUND");
    ASSERT_TRUE(v.size() == 1 || v.size() == 10000);
  }

  Destroy(options);
}

I
Igor Sugak 已提交
3404
TEST_F(DBTest, UniversalCompactionFourPaths) {
3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422
  Options options;
  options.db_paths.emplace_back(dbname_, 300 * 1024);
  options.db_paths.emplace_back(dbname_ + "_2", 300 * 1024);
  options.db_paths.emplace_back(dbname_ + "_3", 500 * 1024);
  options.db_paths.emplace_back(dbname_ + "_4", 1024 * 1024 * 1024);
  options.compaction_style = kCompactionStyleUniversal;
  options.write_buffer_size = 100 << 10;  // 100KB
  options.level0_file_num_compaction_trigger = 2;
  options.num_levels = 1;
  options = CurrentOptions(options);

  std::vector<std::string> filenames;
  env_->GetChildren(options.db_paths[1].path, &filenames);
  // Delete archival files.
  for (size_t i = 0; i < filenames.size(); ++i) {
    env_->DeleteFile(options.db_paths[1].path + "/" + filenames[i]);
  }
  env_->DeleteDir(options.db_paths[1].path);
L
Lei Jin 已提交
3423
  Reopen(options);
3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491

  Random rnd(301);
  int key_idx = 0;

  // First three 110KB files are not going to second path.
  // After that, (100K, 200K)
  for (int num = 0; num < 3; num++) {
    GenerateNewFile(&rnd, &key_idx);
  }

  // Another 110KB triggers a compaction to 400K file to second path
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[2].path));

  // (1, 4)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  // (1,1,4) -> (2, 4)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(0, GetSstFileCount(dbname_));

  // (1, 2, 4)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  // (1, 1, 2, 4) -> (8)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[3].path));

  // (1, 8)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[3].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  // (1, 1, 8) -> (2, 8)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[3].path));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));

  // (1, 2, 8)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[3].path));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  // (1, 1, 2, 8) -> (4, 8)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[3].path));

  // (1, 4, 8)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[3].path));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  for (int i = 0; i < key_idx; i++) {
    auto v = Get(Key(i));
    ASSERT_NE(v, "NOT_FOUND");
    ASSERT_TRUE(v.size() == 1 || v.size() == 10000);
  }

L
Lei Jin 已提交
3492
  Reopen(options);
3493 3494 3495 3496 3497 3498 3499

  for (int i = 0; i < key_idx; i++) {
    auto v = Get(Key(i));
    ASSERT_NE(v, "NOT_FOUND");
    ASSERT_TRUE(v.size() == 1 || v.size() == 10000);
  }

L
Lei Jin 已提交
3500
  Destroy(options);
3501
}
3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521

void CheckColumnFamilyMeta(const ColumnFamilyMetaData& cf_meta) {
  uint64_t cf_size = 0;
  uint64_t cf_csize = 0;
  size_t file_count = 0;
  for (auto level_meta : cf_meta.levels) {
    uint64_t level_size = 0;
    uint64_t level_csize = 0;
    file_count += level_meta.files.size();
    for (auto file_meta : level_meta.files) {
      level_size += file_meta.size;
    }
    ASSERT_EQ(level_meta.size, level_size);
    cf_size += level_size;
    cf_csize += level_csize;
  }
  ASSERT_EQ(cf_meta.file_count, file_count);
  ASSERT_EQ(cf_meta.size, cf_size);
}

I
Igor Sugak 已提交
3522
TEST_F(DBTest, ColumnFamilyMetaDataTest) {
3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536
  Options options = CurrentOptions();
  options.create_if_missing = true;
  DestroyAndReopen(options);

  Random rnd(301);
  int key_index = 0;
  ColumnFamilyMetaData cf_meta;
  for (int i = 0; i < 100; ++i) {
    GenerateNewFile(&rnd, &key_index);
    db_->GetColumnFamilyMetaData(&cf_meta);
    CheckColumnFamilyMeta(cf_meta);
  }
}

I
Igor Sugak 已提交
3537
TEST_F(DBTest, ConvertCompactionStyle) {
3538 3539 3540 3541 3542
  Random rnd(301);
  int max_key_level_insert = 200;
  int max_key_universal_insert = 600;

  // Stage 1: generate a db with level compaction
3543
  Options options;
3544 3545 3546 3547 3548 3549 3550
  options.write_buffer_size = 100<<10; //100KB
  options.num_levels = 4;
  options.level0_file_num_compaction_trigger = 3;
  options.max_bytes_for_level_base = 500<<10; // 500KB
  options.max_bytes_for_level_multiplier = 1;
  options.target_file_size_base = 200<<10; // 200KB
  options.target_file_size_multiplier = 1;
3551
  options = CurrentOptions(options);
L
Lei Jin 已提交
3552
  CreateAndReopenWithCF({"pikachu"}, options);
3553 3554 3555

  for (int i = 0; i <= max_key_level_insert; i++) {
    // each value is 10K
3556
    ASSERT_OK(Put(1, Key(i), RandomString(&rnd, 10000)));
3557
  }
3558
  ASSERT_OK(Flush(1));
3559 3560
  dbfull()->TEST_WaitForCompact();

3561
  ASSERT_GT(TotalTableFiles(1, 4), 1);
3562
  int non_level0_num_files = 0;
3563 3564
  for (int i = 1; i < options.num_levels; i++) {
    non_level0_num_files += NumTableFilesAtLevel(i, 1);
3565 3566 3567 3568 3569 3570
  }
  ASSERT_GT(non_level0_num_files, 0);

  // Stage 2: reopen with universal compaction - should fail
  options = CurrentOptions();
  options.compaction_style = kCompactionStyleUniversal;
S
sdong 已提交
3571
  options.num_levels = 1;
3572
  options = CurrentOptions(options);
L
Lei Jin 已提交
3573
  Status s = TryReopenWithColumnFamilies({"default", "pikachu"}, options);
3574 3575 3576 3577 3578 3579 3580 3581 3582
  ASSERT_TRUE(s.IsInvalidArgument());

  // Stage 3: compact into a single file and move the file to level 0
  options = CurrentOptions();
  options.disable_auto_compactions = true;
  options.target_file_size_base = INT_MAX;
  options.target_file_size_multiplier = 1;
  options.max_bytes_for_level_base = INT_MAX;
  options.max_bytes_for_level_multiplier = 1;
S
sdong 已提交
3583
  options.num_levels = 4;
3584
  options = CurrentOptions(options);
L
Lei Jin 已提交
3585
  ReopenWithColumnFamilies({"default", "pikachu"}, options);
3586

3587 3588 3589
  CompactRangeOptions compact_options;
  compact_options.change_level = true;
  compact_options.target_level = 0;
3590 3591
  compact_options.bottommost_level_compaction =
      BottommostLevelCompaction::kForce;
3592
  dbfull()->CompactRange(compact_options, handles_[1], nullptr, nullptr);
3593

3594 3595
  // Only 1 file in L0
  ASSERT_EQ("1", FilesPerLevel(1));
3596 3597 3598 3599

  // Stage 4: re-open in universal compaction style and do some db operations
  options = CurrentOptions();
  options.compaction_style = kCompactionStyleUniversal;
S
sdong 已提交
3600
  options.num_levels = 4;
3601 3602
  options.write_buffer_size = 100<<10; //100KB
  options.level0_file_num_compaction_trigger = 3;
3603
  options = CurrentOptions(options);
L
Lei Jin 已提交
3604
  ReopenWithColumnFamilies({"default", "pikachu"}, options);
3605

S
sdong 已提交
3606 3607 3608
  options.num_levels = 1;
  ReopenWithColumnFamilies({"default", "pikachu"}, options);

3609
  for (int i = max_key_level_insert / 2; i <= max_key_universal_insert; i++) {
3610
    ASSERT_OK(Put(1, Key(i), RandomString(&rnd, 10000)));
3611 3612
  }
  dbfull()->Flush(FlushOptions());
3613
  ASSERT_OK(Flush(1));
3614 3615
  dbfull()->TEST_WaitForCompact();

3616 3617
  for (int i = 1; i < options.num_levels; i++) {
    ASSERT_EQ(NumTableFilesAtLevel(i, 1), 0);
3618 3619 3620 3621 3622
  }

  // verify keys inserted in both level compaction style and universal
  // compaction style
  std::string keys_in_db;
3623
  Iterator* iter = dbfull()->NewIterator(ReadOptions(), handles_[1]);
3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638
  for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
    keys_in_db.append(iter->key().ToString());
    keys_in_db.push_back(',');
  }
  delete iter;

  std::string expected_keys;
  for (int i = 0; i <= max_key_universal_insert; i++) {
    expected_keys.append(Key(i));
    expected_keys.push_back(',');
  }

  ASSERT_EQ(keys_in_db, expected_keys);
}

S
sdong 已提交
3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663
TEST_F(DBTest, IncreaseUniversalCompactionNumLevels) {
  std::function<void(int)> verify_func = [&](int num_keys_in_db) {
    std::string keys_in_db;
    Iterator* iter = dbfull()->NewIterator(ReadOptions(), handles_[1]);
    for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
      keys_in_db.append(iter->key().ToString());
      keys_in_db.push_back(',');
    }
    delete iter;

    std::string expected_keys;
    for (int i = 0; i <= num_keys_in_db; i++) {
      expected_keys.append(Key(i));
      expected_keys.push_back(',');
    }

    ASSERT_EQ(keys_in_db, expected_keys);
  };

  Random rnd(301);
  int max_key1 = 200;
  int max_key2 = 600;
  int max_key3 = 800;

  // Stage 1: open a DB with universal compaction, num_levels=1
3664
  Options options = CurrentOptions();
S
sdong 已提交
3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709
  options.compaction_style = kCompactionStyleUniversal;
  options.num_levels = 1;
  options.write_buffer_size = 100 << 10;  // 100KB
  options.level0_file_num_compaction_trigger = 3;
  options = CurrentOptions(options);
  CreateAndReopenWithCF({"pikachu"}, options);

  for (int i = 0; i <= max_key1; i++) {
    // each value is 10K
    ASSERT_OK(Put(1, Key(i), RandomString(&rnd, 10000)));
  }
  ASSERT_OK(Flush(1));
  dbfull()->TEST_WaitForCompact();

  int non_level0_num_files = 0;
  for (int i = 1; i < options.num_levels; i++) {
    non_level0_num_files += NumTableFilesAtLevel(i, 1);
  }
  ASSERT_EQ(non_level0_num_files, 0);

  // Stage 2: reopen with universal compaction, num_levels=4
  options.compaction_style = kCompactionStyleUniversal;
  options.num_levels = 4;
  options = CurrentOptions(options);
  ReopenWithColumnFamilies({"default", "pikachu"}, options);

  verify_func(max_key1);

  // Insert more keys
  for (int i = max_key1 + 1; i <= max_key2; i++) {
    // each value is 10K
    ASSERT_OK(Put(1, Key(i), RandomString(&rnd, 10000)));
  }
  ASSERT_OK(Flush(1));
  dbfull()->TEST_WaitForCompact();

  verify_func(max_key2);
  // Compaction to non-L0 has happened.
  ASSERT_GT(NumTableFilesAtLevel(options.num_levels - 1, 1), 0);

  // Stage 3: Revert it back to one level and revert to num_levels=1.
  options.num_levels = 4;
  options.target_file_size_base = INT_MAX;
  ReopenWithColumnFamilies({"default", "pikachu"}, options);
  // Compact all to level 0
3710 3711 3712 3713
  CompactRangeOptions compact_options;
  compact_options.change_level = true;
  compact_options.target_level = 0;
  dbfull()->CompactRange(compact_options, handles_[1], nullptr, nullptr);
S
sdong 已提交
3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731
  // Need to restart it once to remove higher level records in manifest.
  ReopenWithColumnFamilies({"default", "pikachu"}, options);
  // Final reopen
  options.compaction_style = kCompactionStyleUniversal;
  options.num_levels = 1;
  options = CurrentOptions(options);
  ReopenWithColumnFamilies({"default", "pikachu"}, options);

  // Insert more keys
  for (int i = max_key2 + 1; i <= max_key3; i++) {
    // each value is 10K
    ASSERT_OK(Put(1, Key(i), RandomString(&rnd, 10000)));
  }
  ASSERT_OK(Flush(1));
  dbfull()->TEST_WaitForCompact();
  verify_func(max_key3);
}

I
Igor Canadi 已提交
3732
namespace {
3733 3734 3735 3736 3737 3738 3739 3740 3741 3742
void MinLevelHelper(DBTest* self, Options& options) {
  Random rnd(301);

  for (int num = 0;
    num < options.level0_file_num_compaction_trigger - 1;
    num++)
  {
    std::vector<std::string> values;
    // Write 120KB (12 values, each 10K)
    for (int i = 0; i < 12; i++) {
3743 3744
      values.push_back(DBTestBase::RandomString(&rnd, 10000));
      ASSERT_OK(self->Put(DBTestBase::Key(i), values[i]));
3745
    }
3746
    self->dbfull()->TEST_WaitForFlushMemTable();
3747 3748 3749 3750 3751 3752
    ASSERT_EQ(self->NumTableFilesAtLevel(0), num + 1);
  }

  //generate one more file in level-0, and should trigger level-0 compaction
  std::vector<std::string> values;
  for (int i = 0; i < 12; i++) {
3753 3754
    values.push_back(DBTestBase::RandomString(&rnd, 10000));
    ASSERT_OK(self->Put(DBTestBase::Key(i), values[i]));
3755 3756 3757 3758 3759 3760 3761
  }
  self->dbfull()->TEST_WaitForCompact();

  ASSERT_EQ(self->NumTableFilesAtLevel(0), 0);
  ASSERT_EQ(self->NumTableFilesAtLevel(1), 1);
}

A
amayank 已提交
3762 3763
// returns false if the calling-Test should be skipped
bool MinLevelToCompress(CompressionType& type, Options& options, int wbits,
3764
                        int lev, int strategy) {
3765
  fprintf(stderr, "Test with compression options : window_bits = %d, level =  %d, strategy = %d}\n", wbits, lev, strategy);
3766 3767 3768 3769
  options.write_buffer_size = 100<<10; //100KB
  options.num_levels = 3;
  options.max_mem_compaction_level = 0;
  options.level0_file_num_compaction_trigger = 3;
3770
  options.create_if_missing = true;
3771

I
Igor Canadi 已提交
3772
  if (Snappy_Supported()) {
3773 3774
    type = kSnappyCompression;
    fprintf(stderr, "using snappy\n");
I
Igor Canadi 已提交
3775
  } else if (Zlib_Supported()) {
3776 3777
    type = kZlibCompression;
    fprintf(stderr, "using zlib\n");
I
Igor Canadi 已提交
3778
  } else if (BZip2_Supported()) {
3779 3780
    type = kBZip2Compression;
    fprintf(stderr, "using bzip2\n");
I
Igor Canadi 已提交
3781
  } else if (LZ4_Supported()) {
A
Albert Strasheim 已提交
3782 3783
    type = kLZ4Compression;
    fprintf(stderr, "using lz4\n");
3784 3785
  } else {
    fprintf(stderr, "skipping test, compression disabled\n");
A
amayank 已提交
3786
    return false;
3787
  }
3788
  options.compression_per_level.resize(options.num_levels);
3789 3790 3791 3792 3793 3794 3795 3796

  // do not compress L0
  for (int i = 0; i < 1; i++) {
    options.compression_per_level[i] = kNoCompression;
  }
  for (int i = 1; i < options.num_levels; i++) {
    options.compression_per_level[i] = type;
  }
A
amayank 已提交
3797
  return true;
3798
}
I
Igor Canadi 已提交
3799
}  // namespace
3800

I
Igor Sugak 已提交
3801
TEST_F(DBTest, MinLevelToCompress1) {
3802
  Options options = CurrentOptions();
3803
  CompressionType type = kSnappyCompression;
A
amayank 已提交
3804 3805 3806
  if (!MinLevelToCompress(type, options, -14, -1, 0)) {
    return;
  }
L
Lei Jin 已提交
3807
  Reopen(options);
3808 3809 3810 3811 3812 3813 3814 3815 3816
  MinLevelHelper(this, options);

  // do not compress L0 and L1
  for (int i = 0; i < 2; i++) {
    options.compression_per_level[i] = kNoCompression;
  }
  for (int i = 2; i < options.num_levels; i++) {
    options.compression_per_level[i] = type;
  }
L
Lei Jin 已提交
3817
  DestroyAndReopen(options);
3818 3819 3820
  MinLevelHelper(this, options);
}

I
Igor Sugak 已提交
3821
TEST_F(DBTest, MinLevelToCompress2) {
3822
  Options options = CurrentOptions();
3823
  CompressionType type = kSnappyCompression;
A
amayank 已提交
3824 3825 3826
  if (!MinLevelToCompress(type, options, 15, -1, 0)) {
    return;
  }
L
Lei Jin 已提交
3827
  Reopen(options);
3828 3829
  MinLevelHelper(this, options);

3830 3831 3832 3833 3834 3835 3836
  // do not compress L0 and L1
  for (int i = 0; i < 2; i++) {
    options.compression_per_level[i] = kNoCompression;
  }
  for (int i = 2; i < options.num_levels; i++) {
    options.compression_per_level[i] = type;
  }
L
Lei Jin 已提交
3837
  DestroyAndReopen(options);
3838 3839
  MinLevelHelper(this, options);
}
3840

I
Igor Sugak 已提交
3841
TEST_F(DBTest, RepeatedWritesToSameKey) {
3842
  do {
3843
    Options options;
3844 3845
    options.env = env_;
    options.write_buffer_size = 100000;  // Small write buffer
3846
    options = CurrentOptions(options);
L
Lei Jin 已提交
3847
    CreateAndReopenWithCF({"pikachu"}, options);
3848

3849 3850
    // We must have at most one file per level except for level-0,
    // which may have up to kL0_StopWritesTrigger files.
3851 3852
    const int kMaxFiles =
        options.num_levels + options.level0_stop_writes_trigger;
3853

3854
    Random rnd(301);
3855 3856
    std::string value =
        RandomString(&rnd, static_cast<int>(2 * options.write_buffer_size));
3857
    for (int i = 0; i < 5 * kMaxFiles; i++) {
3858 3859
      ASSERT_OK(Put(1, "key", value));
      ASSERT_LE(TotalTableFiles(1), kMaxFiles);
3860 3861
    }
  } while (ChangeCompactOptions());
3862 3863
}

I
Igor Sugak 已提交
3864
TEST_F(DBTest, InPlaceUpdate) {
3865
  do {
3866
    Options options;
3867 3868 3869 3870
    options.create_if_missing = true;
    options.inplace_update_support = true;
    options.env = env_;
    options.write_buffer_size = 100000;
3871
    options = CurrentOptions(options);
L
Lei Jin 已提交
3872
    CreateAndReopenWithCF({"pikachu"}, options);
3873 3874 3875 3876 3877

    // Update key with values of smaller size
    int numValues = 10;
    for (int i = numValues; i > 0; i--) {
      std::string value = DummyString(i, 'a');
3878 3879
      ASSERT_OK(Put(1, "key", value));
      ASSERT_EQ(value, Get(1, "key"));
3880 3881 3882
    }

    // Only 1 instance for that key.
3883
    validateNumberOfEntries(1, 1);
3884 3885 3886 3887

  } while (ChangeCompactOptions());
}

I
Igor Sugak 已提交
3888
TEST_F(DBTest, InPlaceUpdateLargeNewValue) {
3889
  do {
3890
    Options options;
3891 3892 3893 3894
    options.create_if_missing = true;
    options.inplace_update_support = true;
    options.env = env_;
    options.write_buffer_size = 100000;
3895
    options = CurrentOptions(options);
L
Lei Jin 已提交
3896
    CreateAndReopenWithCF({"pikachu"}, options);
3897 3898

    // Update key with values of larger size
3899
    int numValues = 10;
3900 3901
    for (int i = 0; i < numValues; i++) {
      std::string value = DummyString(i, 'a');
3902 3903
      ASSERT_OK(Put(1, "key", value));
      ASSERT_EQ(value, Get(1, "key"));
3904 3905 3906
    }

    // All 10 updates exist in the internal iterator
3907
    validateNumberOfEntries(numValues, 1);
3908

3909 3910 3911
  } while (ChangeCompactOptions());
}

I
Igor Sugak 已提交
3912
TEST_F(DBTest, InPlaceUpdateCallbackSmallerSize) {
3913
  do {
3914
    Options options;
3915 3916 3917 3918 3919 3920
    options.create_if_missing = true;
    options.inplace_update_support = true;

    options.env = env_;
    options.write_buffer_size = 100000;
    options.inplace_callback =
3921
      rocksdb::DBTest::updateInPlaceSmallerSize;
3922
    options = CurrentOptions(options);
L
Lei Jin 已提交
3923
    CreateAndReopenWithCF({"pikachu"}, options);
3924 3925 3926

    // Update key with values of smaller size
    int numValues = 10;
3927 3928
    ASSERT_OK(Put(1, "key", DummyString(numValues, 'a')));
    ASSERT_EQ(DummyString(numValues, 'c'), Get(1, "key"));
3929 3930

    for (int i = numValues; i > 0; i--) {
3931 3932
      ASSERT_OK(Put(1, "key", DummyString(i, 'a')));
      ASSERT_EQ(DummyString(i - 1, 'b'), Get(1, "key"));
3933
    }
3934 3935

    // Only 1 instance for that key.
3936
    validateNumberOfEntries(1, 1);
3937 3938 3939 3940

  } while (ChangeCompactOptions());
}

I
Igor Sugak 已提交
3941
TEST_F(DBTest, InPlaceUpdateCallbackSmallerVarintSize) {
3942
  do {
3943
    Options options;
3944 3945 3946 3947 3948 3949 3950
    options.create_if_missing = true;
    options.inplace_update_support = true;

    options.env = env_;
    options.write_buffer_size = 100000;
    options.inplace_callback =
      rocksdb::DBTest::updateInPlaceSmallerVarintSize;
3951
    options = CurrentOptions(options);
L
Lei Jin 已提交
3952
    CreateAndReopenWithCF({"pikachu"}, options);
3953 3954 3955

    // Update key with values of smaller varint size
    int numValues = 265;
3956 3957
    ASSERT_OK(Put(1, "key", DummyString(numValues, 'a')));
    ASSERT_EQ(DummyString(numValues, 'c'), Get(1, "key"));
3958 3959

    for (int i = numValues; i > 0; i--) {
3960 3961
      ASSERT_OK(Put(1, "key", DummyString(i, 'a')));
      ASSERT_EQ(DummyString(1, 'b'), Get(1, "key"));
3962 3963 3964
    }

    // Only 1 instance for that key.
3965
    validateNumberOfEntries(1, 1);
3966

3967 3968 3969
  } while (ChangeCompactOptions());
}

I
Igor Sugak 已提交
3970
TEST_F(DBTest, InPlaceUpdateCallbackLargeNewValue) {
3971
  do {
3972
    Options options;
3973 3974 3975 3976 3977 3978
    options.create_if_missing = true;
    options.inplace_update_support = true;

    options.env = env_;
    options.write_buffer_size = 100000;
    options.inplace_callback =
3979
      rocksdb::DBTest::updateInPlaceLargerSize;
3980
    options = CurrentOptions(options);
L
Lei Jin 已提交
3981
    CreateAndReopenWithCF({"pikachu"}, options);
3982 3983 3984

    // Update key with values of larger size
    int numValues = 10;
3985
    for (int i = 0; i < numValues; i++) {
3986 3987
      ASSERT_OK(Put(1, "key", DummyString(i, 'a')));
      ASSERT_EQ(DummyString(i, 'c'), Get(1, "key"));
3988 3989 3990
    }

    // No inplace updates. All updates are puts with new seq number
3991
    // All 10 updates exist in the internal iterator
3992
    validateNumberOfEntries(numValues, 1);
3993 3994 3995 3996

  } while (ChangeCompactOptions());
}

I
Igor Sugak 已提交
3997
TEST_F(DBTest, InPlaceUpdateCallbackNoAction) {
3998
  do {
3999
    Options options;
4000 4001 4002 4003 4004 4005 4006
    options.create_if_missing = true;
    options.inplace_update_support = true;

    options.env = env_;
    options.write_buffer_size = 100000;
    options.inplace_callback =
      rocksdb::DBTest::updateInPlaceNoAction;
4007
    options = CurrentOptions(options);
L
Lei Jin 已提交
4008
    CreateAndReopenWithCF({"pikachu"}, options);
4009

4010
    // Callback function requests no actions from db
4011 4012
    ASSERT_OK(Put(1, "key", DummyString(1, 'a')));
    ASSERT_EQ(Get(1, "key"), "NOT_FOUND");
4013 4014 4015 4016

  } while (ChangeCompactOptions());
}

4017

I
Igor Sugak 已提交
4018
TEST_F(DBTest, SparseMerge) {
4019 4020 4021
  do {
    Options options = CurrentOptions();
    options.compression = kNoCompression;
L
Lei Jin 已提交
4022
    CreateAndReopenWithCF({"pikachu"}, options);
4023

4024
    FillLevels("A", "Z", 1);
4025 4026 4027 4028 4029 4030 4031 4032

    // Suppose there is:
    //    small amount of data with prefix A
    //    large amount of data with prefix B
    //    small amount of data with prefix C
    // and that recent updates have made small changes to all three prefixes.
    // Check that we do not do a compaction that merges all of B in one shot.
    const std::string value(1000, 'x');
4033
    Put(1, "A", "va");
4034 4035 4036 4037
    // Write approximately 100MB of "B" values
    for (int i = 0; i < 100000; i++) {
      char key[100];
      snprintf(key, sizeof(key), "B%010d", i);
4038
      Put(1, key, value);
4039
    }
4040 4041 4042
    Put(1, "C", "vc");
    ASSERT_OK(Flush(1));
    dbfull()->TEST_CompactRange(0, nullptr, nullptr, handles_[1]);
4043

4044
    // Make sparse update
4045 4046 4047 4048
    Put(1, "A", "va2");
    Put(1, "B100", "bvalue2");
    Put(1, "C", "vc2");
    ASSERT_OK(Flush(1));
4049 4050 4051

    // Compactions should not cause us to create a situation where
    // a file overlaps too much data at the next level.
4052 4053
    ASSERT_LE(dbfull()->TEST_MaxNextLevelOverlappingBytes(handles_[1]),
              20 * 1048576);
4054
    dbfull()->TEST_CompactRange(0, nullptr, nullptr);
4055 4056
    ASSERT_LE(dbfull()->TEST_MaxNextLevelOverlappingBytes(handles_[1]),
              20 * 1048576);
4057
    dbfull()->TEST_CompactRange(1, nullptr, nullptr);
4058 4059
    ASSERT_LE(dbfull()->TEST_MaxNextLevelOverlappingBytes(handles_[1]),
              20 * 1048576);
4060
  } while (ChangeCompactOptions());
4061 4062
}

J
jorlow@chromium.org 已提交
4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073
static bool Between(uint64_t val, uint64_t low, uint64_t high) {
  bool result = (val >= low) && (val <= high);
  if (!result) {
    fprintf(stderr, "Value %llu is not in range [%llu, %llu]\n",
            (unsigned long long)(val),
            (unsigned long long)(low),
            (unsigned long long)(high));
  }
  return result;
}

4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142 4143 4144 4145 4146 4147 4148 4149 4150 4151 4152 4153 4154 4155 4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174 4175 4176 4177 4178 4179
TEST_F(DBTest, ApproximateSizesMemTable) {
  Options options;
  options.write_buffer_size = 100000000;  // Large write buffer
  options.compression = kNoCompression;
  options.create_if_missing = true;
  options = CurrentOptions(options);
  DestroyAndReopen(options);

  const int N = 128;
  Random rnd(301);
  for (int i = 0; i < N; i++) {
    ASSERT_OK(Put(Key(i), RandomString(&rnd, 1024)));
  }

  uint64_t size;
  std::string start = Key(50);
  std::string end = Key(60);
  Range r(start, end);
  db_->GetApproximateSizes(&r, 1, &size, true);
  ASSERT_GT(size, 6000);
  ASSERT_LT(size, 204800);
  // Zero if not including mem table
  db_->GetApproximateSizes(&r, 1, &size, false);
  ASSERT_EQ(size, 0);

  start = Key(500);
  end = Key(600);
  r = Range(start, end);
  db_->GetApproximateSizes(&r, 1, &size, true);
  ASSERT_EQ(size, 0);

  for (int i = 0; i < N; i++) {
    ASSERT_OK(Put(Key(1000 + i), RandomString(&rnd, 1024)));
  }

  start = Key(500);
  end = Key(600);
  r = Range(start, end);
  db_->GetApproximateSizes(&r, 1, &size, true);
  ASSERT_EQ(size, 0);

  start = Key(100);
  end = Key(1020);
  r = Range(start, end);
  db_->GetApproximateSizes(&r, 1, &size, true);
  ASSERT_GT(size, 6000);

  options.max_write_buffer_number = 8;
  options.min_write_buffer_number_to_merge = 5;
  options.write_buffer_size = 1024 * N;  // Not very large
  DestroyAndReopen(options);

  int keys[N * 3];
  for (int i = 0; i < N; i++) {
    keys[i * 3] = i * 5;
    keys[i * 3 + 1] = i * 5 + 1;
    keys[i * 3 + 2] = i * 5 + 2;
  }
  std::random_shuffle(std::begin(keys), std::end(keys));

  for (int i = 0; i < N * 3; i++) {
    ASSERT_OK(Put(Key(keys[i] + 1000), RandomString(&rnd, 1024)));
  }

  start = Key(100);
  end = Key(300);
  r = Range(start, end);
  db_->GetApproximateSizes(&r, 1, &size, true);
  ASSERT_EQ(size, 0);

  start = Key(1050);
  end = Key(1080);
  r = Range(start, end);
  db_->GetApproximateSizes(&r, 1, &size, true);
  ASSERT_GT(size, 6000);

  start = Key(2100);
  end = Key(2300);
  r = Range(start, end);
  db_->GetApproximateSizes(&r, 1, &size, true);
  ASSERT_EQ(size, 0);

  start = Key(1050);
  end = Key(1080);
  r = Range(start, end);
  uint64_t size_with_mt, size_without_mt;
  db_->GetApproximateSizes(&r, 1, &size_with_mt, true);
  ASSERT_GT(size_with_mt, 6000);
  db_->GetApproximateSizes(&r, 1, &size_without_mt, false);
  ASSERT_EQ(size_without_mt, 0);

  Flush();

  for (int i = 0; i < N; i++) {
    ASSERT_OK(Put(Key(i + 1000), RandomString(&rnd, 1024)));
  }

  start = Key(1050);
  end = Key(1080);
  r = Range(start, end);
  db_->GetApproximateSizes(&r, 1, &size_with_mt, true);
  db_->GetApproximateSizes(&r, 1, &size_without_mt, false);
  ASSERT_GT(size_with_mt, size_without_mt);
  ASSERT_GT(size_without_mt, 6000);
}

I
Igor Sugak 已提交
4180
TEST_F(DBTest, ApproximateSizes) {
S
Sanjay Ghemawat 已提交
4181
  do {
4182
    Options options;
S
Sanjay Ghemawat 已提交
4183 4184
    options.write_buffer_size = 100000000;        // Large write buffer
    options.compression = kNoCompression;
L
Lei Jin 已提交
4185
    options.create_if_missing = true;
4186
    options = CurrentOptions(options);
L
Lei Jin 已提交
4187
    DestroyAndReopen(options);
L
Lei Jin 已提交
4188
    CreateAndReopenWithCF({"pikachu"}, options);
J
jorlow@chromium.org 已提交
4189

4190
    ASSERT_TRUE(Between(Size("", "xyz", 1), 0, 0));
L
Lei Jin 已提交
4191
    ReopenWithColumnFamilies({"default", "pikachu"}, options);
4192
    ASSERT_TRUE(Between(Size("", "xyz", 1), 0, 0));
J
jorlow@chromium.org 已提交
4193

S
Sanjay Ghemawat 已提交
4194
    // Write 8MB (80 values, each 100K)
4195
    ASSERT_EQ(NumTableFilesAtLevel(0, 1), 0);
S
Sanjay Ghemawat 已提交
4196 4197 4198 4199 4200
    const int N = 80;
    static const int S1 = 100000;
    static const int S2 = 105000;  // Allow some expansion from metadata
    Random rnd(301);
    for (int i = 0; i < N; i++) {
4201
      ASSERT_OK(Put(1, Key(i), RandomString(&rnd, S1)));
S
Sanjay Ghemawat 已提交
4202
    }
J
jorlow@chromium.org 已提交
4203

S
Sanjay Ghemawat 已提交
4204
    // 0 because GetApproximateSizes() does not account for memtable space
4205
    ASSERT_TRUE(Between(Size("", Key(50), 1), 0, 0));
D
 
dgrogan@chromium.org 已提交
4206

S
Sanjay Ghemawat 已提交
4207 4208
    // Check sizes across recovery by reopening a few times
    for (int run = 0; run < 3; run++) {
L
Lei Jin 已提交
4209
      ReopenWithColumnFamilies({"default", "pikachu"}, options);
D
dgrogan@chromium.org 已提交
4210

S
Sanjay Ghemawat 已提交
4211 4212
      for (int compact_start = 0; compact_start < N; compact_start += 10) {
        for (int i = 0; i < N; i += 10) {
4213 4214 4215 4216
          ASSERT_TRUE(Between(Size("", Key(i), 1), S1 * i, S2 * i));
          ASSERT_TRUE(Between(Size("", Key(i) + ".suffix", 1), S1 * (i + 1),
                              S2 * (i + 1)));
          ASSERT_TRUE(Between(Size(Key(i), Key(i + 10), 1), S1 * 10, S2 * 10));
S
Sanjay Ghemawat 已提交
4217
        }
4218 4219 4220
        ASSERT_TRUE(Between(Size("", Key(50), 1), S1 * 50, S2 * 50));
        ASSERT_TRUE(
            Between(Size("", Key(50) + ".suffix", 1), S1 * 50, S2 * 50));
S
Sanjay Ghemawat 已提交
4221 4222 4223 4224 4225

        std::string cstart_str = Key(compact_start);
        std::string cend_str = Key(compact_start + 9);
        Slice cstart = cstart_str;
        Slice cend = cend_str;
4226
        dbfull()->TEST_CompactRange(0, &cstart, &cend, handles_[1]);
J
jorlow@chromium.org 已提交
4227
      }
D
dgrogan@chromium.org 已提交
4228

4229 4230
      ASSERT_EQ(NumTableFilesAtLevel(0, 1), 0);
      ASSERT_GT(NumTableFilesAtLevel(1, 1), 0);
S
Sanjay Ghemawat 已提交
4231
    }
4232
    // ApproximateOffsetOf() is not yet implemented in plain table format.
I
Igor Canadi 已提交
4233
  } while (ChangeOptions(kSkipUniversalCompaction | kSkipFIFOCompaction |
S
Stanislau Hlebik 已提交
4234
                         kSkipPlainTable | kSkipHashIndex));
J
jorlow@chromium.org 已提交
4235 4236
}

I
Igor Sugak 已提交
4237
TEST_F(DBTest, ApproximateSizes_MixOfSmallAndLarge) {
S
Sanjay Ghemawat 已提交
4238 4239 4240
  do {
    Options options = CurrentOptions();
    options.compression = kNoCompression;
L
Lei Jin 已提交
4241
    CreateAndReopenWithCF({"pikachu"}, options);
J
jorlow@chromium.org 已提交
4242

S
Sanjay Ghemawat 已提交
4243 4244
    Random rnd(301);
    std::string big1 = RandomString(&rnd, 100000);
4245 4246 4247 4248 4249 4250 4251 4252
    ASSERT_OK(Put(1, Key(0), RandomString(&rnd, 10000)));
    ASSERT_OK(Put(1, Key(1), RandomString(&rnd, 10000)));
    ASSERT_OK(Put(1, Key(2), big1));
    ASSERT_OK(Put(1, Key(3), RandomString(&rnd, 10000)));
    ASSERT_OK(Put(1, Key(4), big1));
    ASSERT_OK(Put(1, Key(5), RandomString(&rnd, 10000)));
    ASSERT_OK(Put(1, Key(6), RandomString(&rnd, 300000)));
    ASSERT_OK(Put(1, Key(7), RandomString(&rnd, 10000)));
S
Sanjay Ghemawat 已提交
4253 4254 4255

    // Check sizes across recovery by reopening a few times
    for (int run = 0; run < 3; run++) {
L
Lei Jin 已提交
4256
      ReopenWithColumnFamilies({"default", "pikachu"}, options);
S
Sanjay Ghemawat 已提交
4257

4258 4259 4260 4261 4262 4263 4264 4265 4266
      ASSERT_TRUE(Between(Size("", Key(0), 1), 0, 0));
      ASSERT_TRUE(Between(Size("", Key(1), 1), 10000, 11000));
      ASSERT_TRUE(Between(Size("", Key(2), 1), 20000, 21000));
      ASSERT_TRUE(Between(Size("", Key(3), 1), 120000, 121000));
      ASSERT_TRUE(Between(Size("", Key(4), 1), 130000, 131000));
      ASSERT_TRUE(Between(Size("", Key(5), 1), 230000, 231000));
      ASSERT_TRUE(Between(Size("", Key(6), 1), 240000, 241000));
      ASSERT_TRUE(Between(Size("", Key(7), 1), 540000, 541000));
      ASSERT_TRUE(Between(Size("", Key(8), 1), 550000, 560000));
S
Sanjay Ghemawat 已提交
4267

4268
      ASSERT_TRUE(Between(Size(Key(3), Key(5), 1), 110000, 111000));
S
Sanjay Ghemawat 已提交
4269

4270
      dbfull()->TEST_CompactRange(0, nullptr, nullptr, handles_[1]);
S
Sanjay Ghemawat 已提交
4271
    }
4272 4273
    // ApproximateOffsetOf() is not yet implemented in plain table format.
  } while (ChangeOptions(kSkipPlainTable));
J
jorlow@chromium.org 已提交
4274 4275
}

I
Igor Sugak 已提交
4276
TEST_F(DBTest, IteratorPinsRef) {
4277
  do {
L
Lei Jin 已提交
4278
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
4279
    Put(1, "foo", "hello");
J
jorlow@chromium.org 已提交
4280

4281
    // Get iterator that will yield the current contents of the DB.
4282
    Iterator* iter = db_->NewIterator(ReadOptions(), handles_[1]);
J
jorlow@chromium.org 已提交
4283

4284
    // Write to force compactions
4285
    Put(1, "foo", "newvalue1");
4286
    for (int i = 0; i < 100; i++) {
4287 4288
      // 100K values
      ASSERT_OK(Put(1, Key(i), Key(i) + std::string(100000, 'v')));
4289
    }
4290
    Put(1, "foo", "newvalue2");
J
jorlow@chromium.org 已提交
4291

4292 4293 4294 4295 4296 4297 4298 4299
    iter->SeekToFirst();
    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ("foo", iter->key().ToString());
    ASSERT_EQ("hello", iter->value().ToString());
    iter->Next();
    ASSERT_TRUE(!iter->Valid());
    delete iter;
  } while (ChangeCompactOptions());
J
jorlow@chromium.org 已提交
4300 4301
}

I
Igor Sugak 已提交
4302
TEST_F(DBTest, Snapshot) {
4303 4304
  anon::OptionsOverride options_override;
  options_override.skip_policy = kSkipNoSnapshot;
S
Sanjay Ghemawat 已提交
4305
  do {
4306
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions(options_override));
4307 4308
    Put(0, "foo", "0v1");
    Put(1, "foo", "1v1");
4309

S
Sanjay Ghemawat 已提交
4310
    const Snapshot* s1 = db_->GetSnapshot();
4311 4312 4313
    ASSERT_EQ(1U, GetNumSnapshots());
    uint64_t time_snap1 = GetTimeOldestSnapshots();
    ASSERT_GT(time_snap1, 0U);
4314 4315
    Put(0, "foo", "0v2");
    Put(1, "foo", "1v2");
4316

S
sdong 已提交
4317
    env_->addon_time_.fetch_add(1);
4318

S
Sanjay Ghemawat 已提交
4319
    const Snapshot* s2 = db_->GetSnapshot();
4320 4321
    ASSERT_EQ(2U, GetNumSnapshots());
    ASSERT_EQ(time_snap1, GetTimeOldestSnapshots());
4322 4323
    Put(0, "foo", "0v3");
    Put(1, "foo", "1v3");
4324

S
Sanjay Ghemawat 已提交
4325
    const Snapshot* s3 = db_->GetSnapshot();
4326 4327
    ASSERT_EQ(3U, GetNumSnapshots());
    ASSERT_EQ(time_snap1, GetTimeOldestSnapshots());
S
Sanjay Ghemawat 已提交
4328

4329 4330 4331 4332 4333 4334 4335 4336 4337 4338
    Put(0, "foo", "0v4");
    Put(1, "foo", "1v4");
    ASSERT_EQ("0v1", Get(0, "foo", s1));
    ASSERT_EQ("1v1", Get(1, "foo", s1));
    ASSERT_EQ("0v2", Get(0, "foo", s2));
    ASSERT_EQ("1v2", Get(1, "foo", s2));
    ASSERT_EQ("0v3", Get(0, "foo", s3));
    ASSERT_EQ("1v3", Get(1, "foo", s3));
    ASSERT_EQ("0v4", Get(0, "foo"));
    ASSERT_EQ("1v4", Get(1, "foo"));
S
Sanjay Ghemawat 已提交
4339 4340

    db_->ReleaseSnapshot(s3);
4341 4342
    ASSERT_EQ(2U, GetNumSnapshots());
    ASSERT_EQ(time_snap1, GetTimeOldestSnapshots());
4343 4344 4345 4346 4347 4348
    ASSERT_EQ("0v1", Get(0, "foo", s1));
    ASSERT_EQ("1v1", Get(1, "foo", s1));
    ASSERT_EQ("0v2", Get(0, "foo", s2));
    ASSERT_EQ("1v2", Get(1, "foo", s2));
    ASSERT_EQ("0v4", Get(0, "foo"));
    ASSERT_EQ("1v4", Get(1, "foo"));
J
jorlow@chromium.org 已提交
4349

S
Sanjay Ghemawat 已提交
4350
    db_->ReleaseSnapshot(s1);
4351 4352 4353 4354
    ASSERT_EQ("0v2", Get(0, "foo", s2));
    ASSERT_EQ("1v2", Get(1, "foo", s2));
    ASSERT_EQ("0v4", Get(0, "foo"));
    ASSERT_EQ("1v4", Get(1, "foo"));
4355 4356
    ASSERT_EQ(1U, GetNumSnapshots());
    ASSERT_LT(time_snap1, GetTimeOldestSnapshots());
4357

S
Sanjay Ghemawat 已提交
4358
    db_->ReleaseSnapshot(s2);
4359
    ASSERT_EQ(0U, GetNumSnapshots());
4360 4361
    ASSERT_EQ("0v4", Get(0, "foo"));
    ASSERT_EQ("1v4", Get(1, "foo"));
4362
  } while (ChangeOptions(kSkipHashCuckoo));
S
Sanjay Ghemawat 已提交
4363
}
J
jorlow@chromium.org 已提交
4364

I
Igor Sugak 已提交
4365
TEST_F(DBTest, HiddenValuesAreRemoved) {
4366 4367
  anon::OptionsOverride options_override;
  options_override.skip_policy = kSkipNoSnapshot;
S
Sanjay Ghemawat 已提交
4368
  do {
4369
    Options options = CurrentOptions(options_override);
I
Igor Canadi 已提交
4370
    options.max_background_flushes = 0;
L
Lei Jin 已提交
4371
    CreateAndReopenWithCF({"pikachu"}, options);
S
Sanjay Ghemawat 已提交
4372
    Random rnd(301);
4373
    FillLevels("a", "z", 1);
S
Sanjay Ghemawat 已提交
4374 4375

    std::string big = RandomString(&rnd, 50000);
4376 4377
    Put(1, "foo", big);
    Put(1, "pastfoo", "v");
S
Sanjay Ghemawat 已提交
4378
    const Snapshot* snapshot = db_->GetSnapshot();
4379 4380
    Put(1, "foo", "tiny");
    Put(1, "pastfoo2", "v2");  // Advance sequence number one more
S
Sanjay Ghemawat 已提交
4381

4382 4383
    ASSERT_OK(Flush(1));
    ASSERT_GT(NumTableFilesAtLevel(0, 1), 0);
S
Sanjay Ghemawat 已提交
4384

4385 4386
    ASSERT_EQ(big, Get(1, "foo", snapshot));
    ASSERT_TRUE(Between(Size("", "pastfoo", 1), 50000, 60000));
S
Sanjay Ghemawat 已提交
4387
    db_->ReleaseSnapshot(snapshot);
4388
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ tiny, " + big + " ]");
S
Sanjay Ghemawat 已提交
4389
    Slice x("x");
4390 4391 4392 4393 4394 4395 4396 4397
    dbfull()->TEST_CompactRange(0, nullptr, &x, handles_[1]);
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ tiny ]");
    ASSERT_EQ(NumTableFilesAtLevel(0, 1), 0);
    ASSERT_GE(NumTableFilesAtLevel(1, 1), 1);
    dbfull()->TEST_CompactRange(1, nullptr, &x, handles_[1]);
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ tiny ]");

    ASSERT_TRUE(Between(Size("", "pastfoo", 1), 0, 1000));
4398 4399
    // ApproximateOffsetOf() is not yet implemented in plain table format,
    // which is used by Size().
4400
    // skip HashCuckooRep as it does not support snapshot
I
Igor Canadi 已提交
4401 4402
  } while (ChangeOptions(kSkipUniversalCompaction | kSkipFIFOCompaction |
                         kSkipPlainTable | kSkipHashCuckoo));
J
jorlow@chromium.org 已提交
4403 4404
}

I
Igor Sugak 已提交
4405
TEST_F(DBTest, CompactBetweenSnapshots) {
4406 4407
  anon::OptionsOverride options_override;
  options_override.skip_policy = kSkipNoSnapshot;
4408
  do {
4409
    Options options = CurrentOptions(options_override);
4410
    options.disable_auto_compactions = true;
L
Lei Jin 已提交
4411
    CreateAndReopenWithCF({"pikachu"}, options);
4412
    Random rnd(301);
4413
    FillLevels("a", "z", 1);
4414

4415
    Put(1, "foo", "first");
4416
    const Snapshot* snapshot1 = db_->GetSnapshot();
4417 4418 4419
    Put(1, "foo", "second");
    Put(1, "foo", "third");
    Put(1, "foo", "fourth");
4420
    const Snapshot* snapshot2 = db_->GetSnapshot();
4421 4422
    Put(1, "foo", "fifth");
    Put(1, "foo", "sixth");
4423 4424 4425

    // All entries (including duplicates) exist
    // before any compaction is triggered.
4426 4427 4428 4429 4430
    ASSERT_OK(Flush(1));
    ASSERT_EQ("sixth", Get(1, "foo"));
    ASSERT_EQ("fourth", Get(1, "foo", snapshot2));
    ASSERT_EQ("first", Get(1, "foo", snapshot1));
    ASSERT_EQ(AllEntriesFor("foo", 1),
4431 4432 4433 4434
              "[ sixth, fifth, fourth, third, second, first ]");

    // After a compaction, "second", "third" and "fifth" should
    // be removed
4435
    FillLevels("a", "z", 1);
4436 4437
    dbfull()->CompactRange(CompactRangeOptions(), handles_[1], nullptr,
                           nullptr);
4438 4439 4440 4441
    ASSERT_EQ("sixth", Get(1, "foo"));
    ASSERT_EQ("fourth", Get(1, "foo", snapshot2));
    ASSERT_EQ("first", Get(1, "foo", snapshot1));
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ sixth, fourth, first ]");
4442 4443 4444

    // after we release the snapshot1, only two values left
    db_->ReleaseSnapshot(snapshot1);
4445
    FillLevels("a", "z", 1);
4446 4447
    dbfull()->CompactRange(CompactRangeOptions(), handles_[1], nullptr,
                           nullptr);
4448 4449 4450

    // We have only one valid snapshot snapshot2. Since snapshot1 is
    // not valid anymore, "first" should be removed by a compaction.
4451 4452 4453
    ASSERT_EQ("sixth", Get(1, "foo"));
    ASSERT_EQ("fourth", Get(1, "foo", snapshot2));
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ sixth, fourth ]");
4454 4455 4456

    // after we release the snapshot2, only one value should be left
    db_->ReleaseSnapshot(snapshot2);
4457
    FillLevels("a", "z", 1);
4458 4459
    dbfull()->CompactRange(CompactRangeOptions(), handles_[1], nullptr,
                           nullptr);
4460 4461
    ASSERT_EQ("sixth", Get(1, "foo"));
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ sixth ]");
4462
    // skip HashCuckooRep as it does not support snapshot
I
Igor Canadi 已提交
4463
  } while (ChangeOptions(kSkipHashCuckoo | kSkipFIFOCompaction));
4464 4465
}

I
Igor Sugak 已提交
4466
TEST_F(DBTest, DeletionMarkers1) {
I
Igor Canadi 已提交
4467 4468
  Options options = CurrentOptions();
  options.max_background_flushes = 0;
L
Lei Jin 已提交
4469
  CreateAndReopenWithCF({"pikachu"}, options);
4470 4471 4472 4473 4474
  Put(1, "foo", "v1");
  ASSERT_OK(Flush(1));
  const int last = CurrentOptions().max_mem_compaction_level;
  // foo => v1 is now in last level
  ASSERT_EQ(NumTableFilesAtLevel(last, 1), 1);
4475 4476

  // Place a table at level last-1 to prevent merging with preceding mutation
4477 4478 4479 4480 4481 4482 4483 4484 4485 4486
  Put(1, "a", "begin");
  Put(1, "z", "end");
  Flush(1);
  ASSERT_EQ(NumTableFilesAtLevel(last, 1), 1);
  ASSERT_EQ(NumTableFilesAtLevel(last - 1, 1), 1);

  Delete(1, "foo");
  Put(1, "foo", "v2");
  ASSERT_EQ(AllEntriesFor("foo", 1), "[ v2, DEL, v1 ]");
  ASSERT_OK(Flush(1));  // Moves to level last-2
4487
  ASSERT_EQ(AllEntriesFor("foo", 1), "[ v2, v1 ]");
G
Gabor Cselle 已提交
4488
  Slice z("z");
4489
  dbfull()->TEST_CompactRange(last - 2, nullptr, &z, handles_[1]);
J
jorlow@chromium.org 已提交
4490 4491
  // DEL eliminated, but v1 remains because we aren't compacting that level
  // (DEL can be eliminated because v2 hides v1).
4492 4493
  ASSERT_EQ(AllEntriesFor("foo", 1), "[ v2, v1 ]");
  dbfull()->TEST_CompactRange(last - 1, nullptr, nullptr, handles_[1]);
4494 4495
  // Merging last-1 w/ last, so we are the base level for "foo", so
  // DEL is removed.  (as is v1).
4496
  ASSERT_EQ(AllEntriesFor("foo", 1), "[ v2 ]");
J
jorlow@chromium.org 已提交
4497 4498
}

I
Igor Sugak 已提交
4499
TEST_F(DBTest, DeletionMarkers2) {
I
Igor Canadi 已提交
4500 4501
  Options options = CurrentOptions();
  options.max_background_flushes = 0;
L
Lei Jin 已提交
4502
  CreateAndReopenWithCF({"pikachu"}, options);
4503 4504 4505 4506 4507
  Put(1, "foo", "v1");
  ASSERT_OK(Flush(1));
  const int last = CurrentOptions().max_mem_compaction_level;
  // foo => v1 is now in last level
  ASSERT_EQ(NumTableFilesAtLevel(last, 1), 1);
4508 4509

  // Place a table at level last-1 to prevent merging with preceding mutation
4510 4511 4512 4513 4514 4515 4516 4517 4518 4519 4520
  Put(1, "a", "begin");
  Put(1, "z", "end");
  Flush(1);
  ASSERT_EQ(NumTableFilesAtLevel(last, 1), 1);
  ASSERT_EQ(NumTableFilesAtLevel(last - 1, 1), 1);

  Delete(1, "foo");
  ASSERT_EQ(AllEntriesFor("foo", 1), "[ DEL, v1 ]");
  ASSERT_OK(Flush(1));  // Moves to level last-2
  ASSERT_EQ(AllEntriesFor("foo", 1), "[ DEL, v1 ]");
  dbfull()->TEST_CompactRange(last - 2, nullptr, nullptr, handles_[1]);
4521
  // DEL kept: "last" file overlaps
4522 4523
  ASSERT_EQ(AllEntriesFor("foo", 1), "[ DEL, v1 ]");
  dbfull()->TEST_CompactRange(last - 1, nullptr, nullptr, handles_[1]);
4524 4525
  // Merging last-1 w/ last, so we are the base level for "foo", so
  // DEL is removed.  (as is v1).
4526
  ASSERT_EQ(AllEntriesFor("foo", 1), "[ ]");
J
jorlow@chromium.org 已提交
4527 4528
}

I
Igor Sugak 已提交
4529
TEST_F(DBTest, OverlapInLevel0) {
S
Sanjay Ghemawat 已提交
4530
  do {
I
Igor Canadi 已提交
4531 4532
    Options options = CurrentOptions();
    options.max_background_flushes = 0;
L
Lei Jin 已提交
4533
    CreateAndReopenWithCF({"pikachu"}, options);
4534
    int tmp = CurrentOptions().max_mem_compaction_level;
4535
    ASSERT_EQ(tmp, 2) << "Fix test to match config";
G
Gabor Cselle 已提交
4536

N
Naman Gupta 已提交
4537
    //Fill levels 1 and 2 to disable the pushing of new memtables to levels > 0.
4538 4539 4540 4541 4542 4543 4544
    ASSERT_OK(Put(1, "100", "v100"));
    ASSERT_OK(Put(1, "999", "v999"));
    Flush(1);
    ASSERT_OK(Delete(1, "100"));
    ASSERT_OK(Delete(1, "999"));
    Flush(1);
    ASSERT_EQ("0,1,1", FilesPerLevel(1));
S
Sanjay Ghemawat 已提交
4545 4546 4547 4548 4549

    // Make files spanning the following ranges in level-0:
    //  files[0]  200 .. 900
    //  files[1]  300 .. 500
    // Note that files are sorted by smallest key.
4550 4551 4552 4553 4554 4555 4556 4557
    ASSERT_OK(Put(1, "300", "v300"));
    ASSERT_OK(Put(1, "500", "v500"));
    Flush(1);
    ASSERT_OK(Put(1, "200", "v200"));
    ASSERT_OK(Put(1, "600", "v600"));
    ASSERT_OK(Put(1, "900", "v900"));
    Flush(1);
    ASSERT_EQ("2,1,1", FilesPerLevel(1));
G
Gabor Cselle 已提交
4558

S
Sanjay Ghemawat 已提交
4559
    // Compact away the placeholder files we created initially
4560 4561 4562
    dbfull()->TEST_CompactRange(1, nullptr, nullptr, handles_[1]);
    dbfull()->TEST_CompactRange(2, nullptr, nullptr, handles_[1]);
    ASSERT_EQ("2", FilesPerLevel(1));
G
Gabor Cselle 已提交
4563

S
Sanjay Ghemawat 已提交
4564 4565 4566
    // Do a memtable compaction.  Before bug-fix, the compaction would
    // not detect the overlap with level-0 files and would incorrectly place
    // the deletion in a deeper level.
4567 4568 4569 4570
    ASSERT_OK(Delete(1, "600"));
    Flush(1);
    ASSERT_EQ("3", FilesPerLevel(1));
    ASSERT_EQ("NOT_FOUND", Get(1, "600"));
I
Igor Canadi 已提交
4571
  } while (ChangeOptions(kSkipUniversalCompaction | kSkipFIFOCompaction));
G
Gabor Cselle 已提交
4572 4573
}

I
Igor Sugak 已提交
4574
TEST_F(DBTest, L0_CompactionBug_Issue44_a) {
4575
  do {
L
Lei Jin 已提交
4576
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
4577
    ASSERT_OK(Put(1, "b", "v"));
L
Lei Jin 已提交
4578
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
4579 4580
    ASSERT_OK(Delete(1, "b"));
    ASSERT_OK(Delete(1, "a"));
L
Lei Jin 已提交
4581
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
4582
    ASSERT_OK(Delete(1, "a"));
L
Lei Jin 已提交
4583
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
4584
    ASSERT_OK(Put(1, "a", "v"));
L
Lei Jin 已提交
4585 4586
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
4587
    ASSERT_EQ("(a->v)", Contents(1));
4588
    env_->SleepForMicroseconds(1000000);  // Wait for compaction to finish
4589
    ASSERT_EQ("(a->v)", Contents(1));
4590
  } while (ChangeCompactOptions());
H
Hans Wennborg 已提交
4591 4592
}

I
Igor Sugak 已提交
4593
TEST_F(DBTest, L0_CompactionBug_Issue44_b) {
4594
  do {
L
Lei Jin 已提交
4595
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
4596
    Put(1, "", "");
L
Lei Jin 已提交
4597
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
4598 4599
    Delete(1, "e");
    Put(1, "", "");
L
Lei Jin 已提交
4600
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
4601
    Put(1, "c", "cv");
L
Lei Jin 已提交
4602
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
4603
    Put(1, "", "");
L
Lei Jin 已提交
4604
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
4605
    Put(1, "", "");
4606
    env_->SleepForMicroseconds(1000000);  // Wait for compaction to finish
L
Lei Jin 已提交
4607
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
4608
    Put(1, "d", "dv");
L
Lei Jin 已提交
4609
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
4610
    Put(1, "", "");
L
Lei Jin 已提交
4611
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
4612 4613
    Delete(1, "d");
    Delete(1, "b");
L
Lei Jin 已提交
4614
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
4615
    ASSERT_EQ("(->)(c->cv)", Contents(1));
4616
    env_->SleepForMicroseconds(1000000);  // Wait for compaction to finish
4617
    ASSERT_EQ("(->)(c->cv)", Contents(1));
4618
  } while (ChangeCompactOptions());
H
Hans Wennborg 已提交
4619 4620
}

I
Igor Sugak 已提交
4621
TEST_F(DBTest, ComparatorCheck) {
J
jorlow@chromium.org 已提交
4622 4623
  class NewComparator : public Comparator {
   public:
I
Igor Sugak 已提交
4624 4625 4626 4627
    virtual const char* Name() const override {
      return "rocksdb.NewComparator";
    }
    virtual int Compare(const Slice& a, const Slice& b) const override {
J
jorlow@chromium.org 已提交
4628 4629
      return BytewiseComparator()->Compare(a, b);
    }
I
Igor Sugak 已提交
4630 4631
    virtual void FindShortestSeparator(std::string* s,
                                       const Slice& l) const override {
J
jorlow@chromium.org 已提交
4632 4633
      BytewiseComparator()->FindShortestSeparator(s, l);
    }
I
Igor Sugak 已提交
4634
    virtual void FindShortSuccessor(std::string* key) const override {
J
jorlow@chromium.org 已提交
4635 4636 4637
      BytewiseComparator()->FindShortSuccessor(key);
    }
  };
4638
  Options new_options, options;
4639
  NewComparator cmp;
4640
  do {
4641
    options = CurrentOptions();
L
Lei Jin 已提交
4642
    CreateAndReopenWithCF({"pikachu"}, options);
4643
    new_options = CurrentOptions();
4644
    new_options.comparator = &cmp;
4645 4646
    // only the non-default column family has non-matching comparator
    Status s = TryReopenWithColumnFamilies({"default", "pikachu"},
L
Lei Jin 已提交
4647
        std::vector<Options>({options, new_options}));
4648 4649 4650
    ASSERT_TRUE(!s.ok());
    ASSERT_TRUE(s.ToString().find("comparator") != std::string::npos)
        << s.ToString();
4651
  } while (ChangeCompactOptions());
J
jorlow@chromium.org 已提交
4652 4653
}

I
Igor Sugak 已提交
4654
TEST_F(DBTest, CustomComparator) {
H
Hans Wennborg 已提交
4655 4656
  class NumberComparator : public Comparator {
   public:
I
Igor Sugak 已提交
4657 4658 4659 4660
    virtual const char* Name() const override {
      return "test.NumberComparator";
    }
    virtual int Compare(const Slice& a, const Slice& b) const override {
4661 4662
      return ToNumber(a) - ToNumber(b);
    }
I
Igor Sugak 已提交
4663 4664
    virtual void FindShortestSeparator(std::string* s,
                                       const Slice& l) const override {
4665 4666 4667
      ToNumber(*s);     // Check format
      ToNumber(l);      // Check format
    }
I
Igor Sugak 已提交
4668
    virtual void FindShortSuccessor(std::string* key) const override {
4669 4670 4671 4672 4673
      ToNumber(*key);   // Check format
    }
   private:
    static int ToNumber(const Slice& x) {
      // Check that there are no extra characters.
4674
      EXPECT_TRUE(x.size() >= 2 && x[0] == '[' && x[x.size() - 1] == ']')
4675 4676 4677
          << EscapeString(x);
      int val;
      char ignored;
4678
      EXPECT_TRUE(sscanf(x.ToString().c_str(), "[%i]%c", &val, &ignored) == 1)
4679 4680
          << EscapeString(x);
      return val;
H
Hans Wennborg 已提交
4681 4682
    }
  };
4683 4684
  Options new_options;
  NumberComparator cmp;
4685
  do {
4686
    new_options = CurrentOptions();
4687 4688 4689
    new_options.create_if_missing = true;
    new_options.comparator = &cmp;
    new_options.write_buffer_size = 1000;  // Compact more often
4690
    new_options = CurrentOptions(new_options);
L
Lei Jin 已提交
4691
    DestroyAndReopen(new_options);
L
Lei Jin 已提交
4692
    CreateAndReopenWithCF({"pikachu"}, new_options);
4693 4694
    ASSERT_OK(Put(1, "[10]", "ten"));
    ASSERT_OK(Put(1, "[0x14]", "twenty"));
4695
    for (int i = 0; i < 2; i++) {
4696 4697 4698 4699 4700 4701 4702
      ASSERT_EQ("ten", Get(1, "[10]"));
      ASSERT_EQ("ten", Get(1, "[0xa]"));
      ASSERT_EQ("twenty", Get(1, "[20]"));
      ASSERT_EQ("twenty", Get(1, "[0x14]"));
      ASSERT_EQ("NOT_FOUND", Get(1, "[15]"));
      ASSERT_EQ("NOT_FOUND", Get(1, "[0xf]"));
      Compact(1, "[0]", "[9999]");
4703 4704 4705 4706 4707 4708
    }

    for (int run = 0; run < 2; run++) {
      for (int i = 0; i < 1000; i++) {
        char buf[100];
        snprintf(buf, sizeof(buf), "[%d]", i*10);
4709
        ASSERT_OK(Put(1, buf, buf));
4710
      }
4711
      Compact(1, "[0]", "[1000000]");
4712
    }
4713
  } while (ChangeCompactOptions());
H
Hans Wennborg 已提交
4714 4715
}

I
Igor Sugak 已提交
4716
TEST_F(DBTest, ManualCompaction) {
I
Igor Canadi 已提交
4717 4718
  Options options = CurrentOptions();
  options.max_background_flushes = 0;
L
Lei Jin 已提交
4719
  CreateAndReopenWithCF({"pikachu"}, options);
4720
  ASSERT_EQ(dbfull()->MaxMemCompactionLevel(), 2)
G
Gabor Cselle 已提交
4721 4722
      << "Need to update this test to match kMaxMemCompactLevel";

4723 4724 4725
  // iter - 0 with 7 levels
  // iter - 1 with 3 levels
  for (int iter = 0; iter < 2; ++iter) {
4726 4727
    MakeTables(3, "p", "q", 1);
    ASSERT_EQ("1,1,1", FilesPerLevel(1));
4728 4729

    // Compaction range falls before files
4730 4731
    Compact(1, "", "c");
    ASSERT_EQ("1,1,1", FilesPerLevel(1));
G
Gabor Cselle 已提交
4732

4733
    // Compaction range falls after files
4734 4735
    Compact(1, "r", "z");
    ASSERT_EQ("1,1,1", FilesPerLevel(1));
G
Gabor Cselle 已提交
4736

4737
    // Compaction range overlaps files
4738 4739
    Compact(1, "p1", "p9");
    ASSERT_EQ("0,0,1", FilesPerLevel(1));
G
Gabor Cselle 已提交
4740

4741
    // Populate a different range
4742 4743
    MakeTables(3, "c", "e", 1);
    ASSERT_EQ("1,1,2", FilesPerLevel(1));
G
Gabor Cselle 已提交
4744

4745
    // Compact just the new range
4746 4747
    Compact(1, "b", "f");
    ASSERT_EQ("0,0,2", FilesPerLevel(1));
G
Gabor Cselle 已提交
4748

4749
    // Compact all
4750 4751
    MakeTables(1, "a", "z", 1);
    ASSERT_EQ("0,1,2", FilesPerLevel(1));
4752
    db_->CompactRange(CompactRangeOptions(), handles_[1], nullptr, nullptr);
4753
    ASSERT_EQ("0,0,1", FilesPerLevel(1));
4754 4755

    if (iter == 0) {
I
Igor Canadi 已提交
4756
      options = CurrentOptions();
I
Igor Canadi 已提交
4757
      options.max_background_flushes = 0;
4758 4759
      options.num_levels = 3;
      options.create_if_missing = true;
L
Lei Jin 已提交
4760
      DestroyAndReopen(options);
L
Lei Jin 已提交
4761
      CreateAndReopenWithCF({"pikachu"}, options);
4762 4763
    }
  }
G
Gabor Cselle 已提交
4764 4765 4766

}

S
sdong 已提交
4767

I
Igor Sugak 已提交
4768
TEST_F(DBTest, ManualLevelCompactionOutputPathId) {
4769 4770 4771 4772 4773 4774 4775 4776 4777 4778 4779 4780 4781 4782 4783 4784 4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 4799 4800 4801 4802 4803 4804 4805 4806 4807 4808 4809 4810 4811 4812 4813 4814 4815 4816
  Options options = CurrentOptions();
  options.db_paths.emplace_back(dbname_ + "_2", 2 * 10485760);
  options.db_paths.emplace_back(dbname_ + "_3", 100 * 10485760);
  options.db_paths.emplace_back(dbname_ + "_4", 120 * 10485760);
  options.max_background_flushes = 1;
  CreateAndReopenWithCF({"pikachu"}, options);
  ASSERT_EQ(dbfull()->MaxMemCompactionLevel(), 2)
      << "Need to update this test to match kMaxMemCompactLevel";

  // iter - 0 with 7 levels
  // iter - 1 with 3 levels
  for (int iter = 0; iter < 2; ++iter) {
    MakeTables(3, "p", "q", 1);
    ASSERT_EQ("3", FilesPerLevel(1));
    ASSERT_EQ(3, GetSstFileCount(options.db_paths[0].path));
    ASSERT_EQ(0, GetSstFileCount(dbname_));

    // Compaction range falls before files
    Compact(1, "", "c");
    ASSERT_EQ("3", FilesPerLevel(1));

    // Compaction range falls after files
    Compact(1, "r", "z");
    ASSERT_EQ("3", FilesPerLevel(1));

    // Compaction range overlaps files
    Compact(1, "p1", "p9", 1);
    ASSERT_EQ("0,1", FilesPerLevel(1));
    ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
    ASSERT_EQ(0, GetSstFileCount(options.db_paths[0].path));
    ASSERT_EQ(0, GetSstFileCount(dbname_));

    // Populate a different range
    MakeTables(3, "c", "e", 1);
    ASSERT_EQ("3,1", FilesPerLevel(1));

    // Compact just the new range
    Compact(1, "b", "f", 1);
    ASSERT_EQ("0,2", FilesPerLevel(1));
    ASSERT_EQ(2, GetSstFileCount(options.db_paths[1].path));
    ASSERT_EQ(0, GetSstFileCount(options.db_paths[0].path));
    ASSERT_EQ(0, GetSstFileCount(dbname_));

    // Compact all
    MakeTables(1, "a", "z", 1);
    ASSERT_EQ("1,2", FilesPerLevel(1));
    ASSERT_EQ(2, GetSstFileCount(options.db_paths[1].path));
    ASSERT_EQ(1, GetSstFileCount(options.db_paths[0].path));
4817 4818 4819
    CompactRangeOptions compact_options;
    compact_options.target_path_id = 1;
    db_->CompactRange(compact_options, handles_[1], nullptr, nullptr);
4820 4821 4822 4823 4824 4825 4826 4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837 4838
    ASSERT_EQ("0,1", FilesPerLevel(1));
    ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
    ASSERT_EQ(0, GetSstFileCount(options.db_paths[0].path));
    ASSERT_EQ(0, GetSstFileCount(dbname_));

    if (iter == 0) {
      DestroyAndReopen(options);
      options = CurrentOptions();
      options.db_paths.emplace_back(dbname_ + "_2", 2 * 10485760);
      options.db_paths.emplace_back(dbname_ + "_3", 100 * 10485760);
      options.db_paths.emplace_back(dbname_ + "_4", 120 * 10485760);
      options.max_background_flushes = 1;
      options.num_levels = 3;
      options.create_if_missing = true;
      CreateAndReopenWithCF({"pikachu"}, options);
    }
  }
}

I
Igor Sugak 已提交
4839
TEST_F(DBTest, DBOpen_Options) {
4840 4841 4842
  Options options = CurrentOptions();
  std::string dbname = test::TmpDir(env_) + "/db_options_test";
  ASSERT_OK(DestroyDB(dbname, options));
J
jorlow@chromium.org 已提交
4843 4844

  // Does not exist, and create_if_missing == false: error
A
Abhishek Kona 已提交
4845
  DB* db = nullptr;
4846 4847
  options.create_if_missing = false;
  Status s = DB::Open(options, dbname, &db);
A
Abhishek Kona 已提交
4848 4849
  ASSERT_TRUE(strstr(s.ToString().c_str(), "does not exist") != nullptr);
  ASSERT_TRUE(db == nullptr);
J
jorlow@chromium.org 已提交
4850 4851

  // Does not exist, and create_if_missing == true: OK
4852 4853
  options.create_if_missing = true;
  s = DB::Open(options, dbname, &db);
J
jorlow@chromium.org 已提交
4854
  ASSERT_OK(s);
A
Abhishek Kona 已提交
4855
  ASSERT_TRUE(db != nullptr);
J
jorlow@chromium.org 已提交
4856 4857

  delete db;
A
Abhishek Kona 已提交
4858
  db = nullptr;
J
jorlow@chromium.org 已提交
4859 4860

  // Does exist, and error_if_exists == true: error
4861 4862 4863
  options.create_if_missing = false;
  options.error_if_exists = true;
  s = DB::Open(options, dbname, &db);
A
Abhishek Kona 已提交
4864 4865
  ASSERT_TRUE(strstr(s.ToString().c_str(), "exists") != nullptr);
  ASSERT_TRUE(db == nullptr);
J
jorlow@chromium.org 已提交
4866 4867

  // Does exist, and error_if_exists == false: OK
4868 4869 4870
  options.create_if_missing = true;
  options.error_if_exists = false;
  s = DB::Open(options, dbname, &db);
J
jorlow@chromium.org 已提交
4871
  ASSERT_OK(s);
A
Abhishek Kona 已提交
4872
  ASSERT_TRUE(db != nullptr);
J
jorlow@chromium.org 已提交
4873 4874

  delete db;
A
Abhishek Kona 已提交
4875
  db = nullptr;
J
jorlow@chromium.org 已提交
4876 4877
}

I
Igor Sugak 已提交
4878
TEST_F(DBTest, DBOpen_Change_NumLevels) {
4879 4880 4881 4882
  Options options = CurrentOptions();
  options.create_if_missing = true;
  options.max_background_flushes = 0;
  DestroyAndReopen(options);
4883
  ASSERT_TRUE(db_ != nullptr);
4884
  CreateAndReopenWithCF({"pikachu"}, options);
4885 4886 4887

  ASSERT_OK(Put(1, "a", "123"));
  ASSERT_OK(Put(1, "b", "234"));
4888
  db_->CompactRange(CompactRangeOptions(), handles_[1], nullptr, nullptr);
4889
  Close();
4890

4891 4892 4893
  options.create_if_missing = false;
  options.num_levels = 2;
  Status s = TryReopenWithColumnFamilies({"default", "pikachu"}, options);
4894
  ASSERT_TRUE(strstr(s.ToString().c_str(), "Invalid argument") != nullptr);
4895
  ASSERT_TRUE(db_ == nullptr);
4896 4897
}

I
Igor Sugak 已提交
4898
TEST_F(DBTest, DestroyDBMetaDatabase) {
4899
  std::string dbname = test::TmpDir(env_) + "/db_meta";
4900
  ASSERT_OK(env_->CreateDirIfMissing(dbname));
K
Kosie van der Merwe 已提交
4901
  std::string metadbname = MetaDatabaseName(dbname, 0);
4902
  ASSERT_OK(env_->CreateDirIfMissing(metadbname));
K
Kosie van der Merwe 已提交
4903
  std::string metametadbname = MetaDatabaseName(metadbname, 0);
4904
  ASSERT_OK(env_->CreateDirIfMissing(metametadbname));
K
Kosie van der Merwe 已提交
4905 4906

  // Destroy previous versions if they exist. Using the long way.
4907 4908 4909 4910
  Options options = CurrentOptions();
  ASSERT_OK(DestroyDB(metametadbname, options));
  ASSERT_OK(DestroyDB(metadbname, options));
  ASSERT_OK(DestroyDB(dbname, options));
K
Kosie van der Merwe 已提交
4911 4912

  // Setup databases
A
Abhishek Kona 已提交
4913
  DB* db = nullptr;
4914
  ASSERT_OK(DB::Open(options, dbname, &db));
K
Kosie van der Merwe 已提交
4915
  delete db;
A
Abhishek Kona 已提交
4916
  db = nullptr;
4917
  ASSERT_OK(DB::Open(options, metadbname, &db));
K
Kosie van der Merwe 已提交
4918
  delete db;
A
Abhishek Kona 已提交
4919
  db = nullptr;
4920
  ASSERT_OK(DB::Open(options, metametadbname, &db));
K
Kosie van der Merwe 已提交
4921
  delete db;
A
Abhishek Kona 已提交
4922
  db = nullptr;
K
Kosie van der Merwe 已提交
4923 4924

  // Delete databases
4925
  ASSERT_OK(DestroyDB(dbname, options));
K
Kosie van der Merwe 已提交
4926 4927

  // Check if deletion worked.
4928 4929 4930 4931
  options.create_if_missing = false;
  ASSERT_TRUE(!(DB::Open(options, dbname, &db)).ok());
  ASSERT_TRUE(!(DB::Open(options, metadbname, &db)).ok());
  ASSERT_TRUE(!(DB::Open(options, metametadbname, &db)).ok());
K
Kosie van der Merwe 已提交
4932 4933
}

4934
// Check that number of files does not grow when writes are dropped
I
Igor Sugak 已提交
4935
TEST_F(DBTest, DropWrites) {
4936 4937 4938
  do {
    Options options = CurrentOptions();
    options.env = env_;
4939
    options.paranoid_checks = false;
L
Lei Jin 已提交
4940
    Reopen(options);
4941

4942 4943 4944
    ASSERT_OK(Put("foo", "v1"));
    ASSERT_EQ("v1", Get("foo"));
    Compact("a", "z");
4945
    const size_t num_files = CountFiles();
I
Igor Canadi 已提交
4946 4947
    // Force out-of-space errors
    env_->drop_writes_.store(true, std::memory_order_release);
4948
    env_->sleep_counter_.Reset();
K
krad 已提交
4949
    env_->no_sleep_ = true;
4950
    for (int i = 0; i < 5; i++) {
4951 4952 4953 4954 4955
      if (option_config_ != kUniversalCompactionMultiLevel) {
        for (int level = 0; level < dbfull()->NumberLevels(); level++) {
          if (level > 0 && level == dbfull()->NumberLevels() - 1) {
            break;
          }
4956 4957
          dbfull()->TEST_CompactRange(level, nullptr, nullptr, nullptr,
                                      true /* disallow trivial move */);
S
sdong 已提交
4958
        }
4959
      } else {
4960
        dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
4961
      }
4962
    }
4963 4964 4965 4966 4967

    std::string property_value;
    ASSERT_TRUE(db_->GetProperty("rocksdb.background-errors", &property_value));
    ASSERT_EQ("5", property_value);

I
Igor Canadi 已提交
4968
    env_->drop_writes_.store(false, std::memory_order_release);
4969
    ASSERT_LT(CountFiles(), num_files + 3);
4970

4971
    // Check that compaction attempts slept after errors
K
krad 已提交
4972
    ASSERT_TRUE(env_->sleep_counter_.WaitFor(5));
4973
  } while (ChangeCompactOptions());
4974 4975
}

4976
// Check background error counter bumped on flush failures.
I
Igor Sugak 已提交
4977
TEST_F(DBTest, DropWritesFlush) {
4978 4979 4980 4981
  do {
    Options options = CurrentOptions();
    options.env = env_;
    options.max_background_flushes = 1;
L
Lei Jin 已提交
4982
    Reopen(options);
4983 4984

    ASSERT_OK(Put("foo", "v1"));
I
Igor Canadi 已提交
4985 4986
    // Force out-of-space errors
    env_->drop_writes_.store(true, std::memory_order_release);
4987 4988 4989 4990 4991 4992

    std::string property_value;
    // Background error count is 0 now.
    ASSERT_TRUE(db_->GetProperty("rocksdb.background-errors", &property_value));
    ASSERT_EQ("0", property_value);

L
Lei Jin 已提交
4993 4994 4995
    dbfull()->TEST_FlushMemTable(true);

    ASSERT_TRUE(db_->GetProperty("rocksdb.background-errors", &property_value));
4996 4997
    ASSERT_EQ("1", property_value);

I
Igor Canadi 已提交
4998
    env_->drop_writes_.store(false, std::memory_order_release);
4999 5000 5001 5002 5003
  } while (ChangeCompactOptions());
}

// Check that CompactRange() returns failure if there is not enough space left
// on device
I
Igor Sugak 已提交
5004
TEST_F(DBTest, NoSpaceCompactRange) {
5005 5006 5007 5008
  do {
    Options options = CurrentOptions();
    options.env = env_;
    options.disable_auto_compactions = true;
L
Lei Jin 已提交
5009
    Reopen(options);
5010 5011 5012 5013 5014 5015 5016

    // generate 5 tables
    for (int i = 0; i < 5; ++i) {
      ASSERT_OK(Put(Key(i), Key(i) + "v"));
      ASSERT_OK(Flush());
    }

I
Igor Canadi 已提交
5017 5018
    // Force out-of-space errors
    env_->no_space_.store(true, std::memory_order_release);
5019

5020 5021
    Status s = dbfull()->TEST_CompactRange(0, nullptr, nullptr, nullptr,
                                           true /* disallow trivial move */);
5022 5023
    ASSERT_TRUE(s.IsIOError());

I
Igor Canadi 已提交
5024
    env_->no_space_.store(false, std::memory_order_release);
5025 5026 5027
  } while (ChangeCompactOptions());
}

I
Igor Sugak 已提交
5028
TEST_F(DBTest, NonWritableFileSystem) {
5029 5030 5031 5032
  do {
    Options options = CurrentOptions();
    options.write_buffer_size = 1000;
    options.env = env_;
L
Lei Jin 已提交
5033
    Reopen(options);
5034
    ASSERT_OK(Put("foo", "v1"));
5035
    env_->non_writeable_rate_.store(100);
5036 5037 5038 5039 5040 5041 5042
    std::string big(100000, 'x');
    int errors = 0;
    for (int i = 0; i < 20; i++) {
      if (!Put("foo", big).ok()) {
        errors++;
        env_->SleepForMicroseconds(100000);
      }
5043
    }
5044
    ASSERT_GT(errors, 0);
5045
    env_->non_writeable_rate_.store(0);
5046
  } while (ChangeCompactOptions());
5047 5048
}

I
Igor Sugak 已提交
5049
TEST_F(DBTest, ManifestWriteError) {
5050 5051 5052 5053 5054 5055 5056 5057 5058
  // Test for the following problem:
  // (a) Compaction produces file F
  // (b) Log record containing F is written to MANIFEST file, but Sync() fails
  // (c) GC deletes F
  // (d) After reopening DB, reads fail since deleted F is named in log record

  // We iterate twice.  In the second iteration, everything is the
  // same except the log record never makes it to the MANIFEST file.
  for (int iter = 0; iter < 2; iter++) {
I
Igor Canadi 已提交
5059
    std::atomic<bool>* error_type = (iter == 0)
5060 5061 5062 5063 5064 5065 5066 5067
        ? &env_->manifest_sync_error_
        : &env_->manifest_write_error_;

    // Insert foo=>bar mapping
    Options options = CurrentOptions();
    options.env = env_;
    options.create_if_missing = true;
    options.error_if_exists = false;
I
Igor Canadi 已提交
5068
    options.max_background_flushes = 0;
L
Lei Jin 已提交
5069
    DestroyAndReopen(options);
5070 5071 5072 5073
    ASSERT_OK(Put("foo", "bar"));
    ASSERT_EQ("bar", Get("foo"));

    // Memtable compaction (will succeed)
5074
    Flush();
5075 5076 5077 5078 5079
    ASSERT_EQ("bar", Get("foo"));
    const int last = dbfull()->MaxMemCompactionLevel();
    ASSERT_EQ(NumTableFilesAtLevel(last), 1);   // foo=>bar is now in last level

    // Merging compaction (will fail)
I
Igor Canadi 已提交
5080
    error_type->store(true, std::memory_order_release);
A
Abhishek Kona 已提交
5081
    dbfull()->TEST_CompactRange(last, nullptr, nullptr);  // Should fail
5082 5083 5084
    ASSERT_EQ("bar", Get("foo"));

    // Recovery: should not lose data
I
Igor Canadi 已提交
5085
    error_type->store(false, std::memory_order_release);
L
Lei Jin 已提交
5086
    Reopen(options);
5087 5088 5089 5090
    ASSERT_EQ("bar", Get("foo"));
  }
}

I
Igor Sugak 已提交
5091
TEST_F(DBTest, PutFailsParanoid) {
I
Igor Canadi 已提交
5092 5093 5094 5095 5096 5097 5098 5099 5100 5101
  // Test the following:
  // (a) A random put fails in paranoid mode (simulate by sync fail)
  // (b) All other puts have to fail, even if writes would succeed
  // (c) All of that should happen ONLY if paranoid_checks = true

  Options options = CurrentOptions();
  options.env = env_;
  options.create_if_missing = true;
  options.error_if_exists = false;
  options.paranoid_checks = true;
L
Lei Jin 已提交
5102
  DestroyAndReopen(options);
L
Lei Jin 已提交
5103
  CreateAndReopenWithCF({"pikachu"}, options);
I
Igor Canadi 已提交
5104 5105
  Status s;

5106 5107
  ASSERT_OK(Put(1, "foo", "bar"));
  ASSERT_OK(Put(1, "foo1", "bar1"));
I
Igor Canadi 已提交
5108
  // simulate error
I
Igor Canadi 已提交
5109
  env_->log_write_error_.store(true, std::memory_order_release);
5110
  s = Put(1, "foo2", "bar2");
I
Igor Canadi 已提交
5111
  ASSERT_TRUE(!s.ok());
I
Igor Canadi 已提交
5112
  env_->log_write_error_.store(false, std::memory_order_release);
5113
  s = Put(1, "foo3", "bar3");
I
Igor Canadi 已提交
5114 5115 5116
  // the next put should fail, too
  ASSERT_TRUE(!s.ok());
  // but we're still able to read
5117
  ASSERT_EQ("bar", Get(1, "foo"));
I
Igor Canadi 已提交
5118 5119 5120

  // do the same thing with paranoid checks off
  options.paranoid_checks = false;
L
Lei Jin 已提交
5121
  DestroyAndReopen(options);
L
Lei Jin 已提交
5122
  CreateAndReopenWithCF({"pikachu"}, options);
I
Igor Canadi 已提交
5123

5124 5125
  ASSERT_OK(Put(1, "foo", "bar"));
  ASSERT_OK(Put(1, "foo1", "bar1"));
I
Igor Canadi 已提交
5126
  // simulate error
I
Igor Canadi 已提交
5127
  env_->log_write_error_.store(true, std::memory_order_release);
5128
  s = Put(1, "foo2", "bar2");
I
Igor Canadi 已提交
5129
  ASSERT_TRUE(!s.ok());
I
Igor Canadi 已提交
5130
  env_->log_write_error_.store(false, std::memory_order_release);
5131
  s = Put(1, "foo3", "bar3");
I
Igor Canadi 已提交
5132 5133 5134 5135
  // the next put should NOT fail
  ASSERT_TRUE(s.ok());
}

I
Igor Sugak 已提交
5136
TEST_F(DBTest, FilesDeletedAfterCompaction) {
5137
  do {
L
Lei Jin 已提交
5138
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
5139 5140
    ASSERT_OK(Put(1, "foo", "v2"));
    Compact(1, "a", "z");
5141
    const size_t num_files = CountLiveFiles();
5142
    for (int i = 0; i < 10; i++) {
5143 5144
      ASSERT_OK(Put(1, "foo", "v2"));
      Compact(1, "a", "z");
5145 5146 5147
    }
    ASSERT_EQ(CountLiveFiles(), num_files);
  } while (ChangeCompactOptions());
5148 5149
}

I
Igor Sugak 已提交
5150
TEST_F(DBTest, BloomFilter) {
5151 5152
  do {
    Options options = CurrentOptions();
5153
    env_->count_random_reads_ = true;
5154
    options.env = env_;
5155 5156 5157 5158 5159 5160 5161
    // ChangeCompactOptions() only changes compaction style, which does not
    // trigger reset of table_factory
    BlockBasedTableOptions table_options;
    table_options.no_block_cache = true;
    table_options.filter_policy.reset(NewBloomFilterPolicy(10));
    options.table_factory.reset(NewBlockBasedTableFactory(table_options));

L
Lei Jin 已提交
5162
    CreateAndReopenWithCF({"pikachu"}, options);
S
Sanjay Ghemawat 已提交
5163

5164 5165 5166
    // Populate multiple layers
    const int N = 10000;
    for (int i = 0; i < N; i++) {
5167
      ASSERT_OK(Put(1, Key(i), Key(i)));
5168
    }
5169
    Compact(1, "a", "z");
5170
    for (int i = 0; i < N; i += 100) {
5171
      ASSERT_OK(Put(1, Key(i), Key(i)));
5172
    }
5173
    Flush(1);
S
Sanjay Ghemawat 已提交
5174

5175
    // Prevent auto compactions triggered by seeks
I
Igor Canadi 已提交
5176
    env_->delay_sstable_sync_.store(true, std::memory_order_release);
S
Sanjay Ghemawat 已提交
5177

5178 5179 5180
    // Lookup present keys.  Should rarely read from small sstable.
    env_->random_read_counter_.Reset();
    for (int i = 0; i < N; i++) {
5181
      ASSERT_EQ(Key(i), Get(1, Key(i)));
5182 5183 5184 5185 5186
    }
    int reads = env_->random_read_counter_.Read();
    fprintf(stderr, "%d present => %d reads\n", N, reads);
    ASSERT_GE(reads, N);
    ASSERT_LE(reads, N + 2*N/100);
S
Sanjay Ghemawat 已提交
5187

5188 5189 5190
    // Lookup present keys.  Should rarely read from either sstable.
    env_->random_read_counter_.Reset();
    for (int i = 0; i < N; i++) {
5191
      ASSERT_EQ("NOT_FOUND", Get(1, Key(i) + ".missing"));
5192 5193 5194 5195
    }
    reads = env_->random_read_counter_.Read();
    fprintf(stderr, "%d missing => %d reads\n", N, reads);
    ASSERT_LE(reads, 3*N/100);
S
Sanjay Ghemawat 已提交
5196

I
Igor Canadi 已提交
5197
    env_->delay_sstable_sync_.store(false, std::memory_order_release);
5198 5199
    Close();
  } while (ChangeCompactOptions());
S
Sanjay Ghemawat 已提交
5200 5201
}

I
Igor Sugak 已提交
5202
TEST_F(DBTest, BloomFilterRate) {
5203 5204 5205
  while (ChangeFilterOptions()) {
    Options options = CurrentOptions();
    options.statistics = rocksdb::CreateDBStatistics();
L
Lei Jin 已提交
5206
    CreateAndReopenWithCF({"pikachu"}, options);
5207 5208 5209 5210 5211 5212 5213 5214 5215 5216 5217 5218 5219 5220 5221 5222 5223 5224 5225 5226 5227 5228 5229

    const int maxKey = 10000;
    for (int i = 0; i < maxKey; i++) {
      ASSERT_OK(Put(1, Key(i), Key(i)));
    }
    // Add a large key to make the file contain wide range
    ASSERT_OK(Put(1, Key(maxKey + 55555), Key(maxKey + 55555)));
    Flush(1);

    // Check if they can be found
    for (int i = 0; i < maxKey; i++) {
      ASSERT_EQ(Key(i), Get(1, Key(i)));
    }
    ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 0);

    // Check if filter is useful
    for (int i = 0; i < maxKey; i++) {
      ASSERT_EQ("NOT_FOUND", Get(1, Key(i+33333)));
    }
    ASSERT_GE(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), maxKey*0.98);
  }
}

I
Igor Sugak 已提交
5230
TEST_F(DBTest, BloomFilterCompatibility) {
5231
  Options options = CurrentOptions();
5232 5233 5234 5235 5236 5237
  options.statistics = rocksdb::CreateDBStatistics();
  BlockBasedTableOptions table_options;
  table_options.filter_policy.reset(NewBloomFilterPolicy(10, true));
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));

  // Create with block based filter
L
Lei Jin 已提交
5238
  CreateAndReopenWithCF({"pikachu"}, options);
5239 5240 5241 5242 5243 5244 5245 5246 5247 5248 5249

  const int maxKey = 10000;
  for (int i = 0; i < maxKey; i++) {
    ASSERT_OK(Put(1, Key(i), Key(i)));
  }
  ASSERT_OK(Put(1, Key(maxKey + 55555), Key(maxKey + 55555)));
  Flush(1);

  // Check db with full filter
  table_options.filter_policy.reset(NewBloomFilterPolicy(10, false));
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
L
Lei Jin 已提交
5250
  ReopenWithColumnFamilies({"default", "pikachu"}, options);
5251 5252 5253 5254 5255 5256 5257 5258

  // Check if they can be found
  for (int i = 0; i < maxKey; i++) {
    ASSERT_EQ(Key(i), Get(1, Key(i)));
  }
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 0);
}

I
Igor Sugak 已提交
5259
TEST_F(DBTest, BloomFilterReverseCompatibility) {
5260
  Options options = CurrentOptions();
5261 5262 5263 5264 5265 5266
  options.statistics = rocksdb::CreateDBStatistics();
  BlockBasedTableOptions table_options;
  table_options.filter_policy.reset(NewBloomFilterPolicy(10, false));
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));

  // Create with full filter
L
Lei Jin 已提交
5267
  CreateAndReopenWithCF({"pikachu"}, options);
5268 5269 5270 5271 5272 5273 5274 5275 5276 5277 5278

  const int maxKey = 10000;
  for (int i = 0; i < maxKey; i++) {
    ASSERT_OK(Put(1, Key(i), Key(i)));
  }
  ASSERT_OK(Put(1, Key(maxKey + 55555), Key(maxKey + 55555)));
  Flush(1);

  // Check db with block_based filter
  table_options.filter_policy.reset(NewBloomFilterPolicy(10, true));
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
L
Lei Jin 已提交
5279
  ReopenWithColumnFamilies({"default", "pikachu"}, options);
5280 5281 5282 5283 5284 5285 5286 5287

  // Check if they can be found
  for (int i = 0; i < maxKey; i++) {
    ASSERT_EQ(Key(i), Get(1, Key(i)));
  }
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 0);
}

F
Feng Zhu 已提交
5288 5289 5290 5291 5292 5293 5294 5295 5296 5297 5298 5299 5300 5301 5302 5303 5304 5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320
namespace {
// A wrapped bloom over default FilterPolicy
class WrappedBloom : public FilterPolicy {
 public:
  explicit WrappedBloom(int bits_per_key) :
        filter_(NewBloomFilterPolicy(bits_per_key)),
        counter_(0) {}

  ~WrappedBloom() { delete filter_; }

  const char* Name() const override { return "WrappedRocksDbFilterPolicy"; }

  void CreateFilter(const rocksdb::Slice* keys, int n, std::string* dst)
      const override {
    std::unique_ptr<rocksdb::Slice[]> user_keys(new rocksdb::Slice[n]);
    for (int i = 0; i < n; ++i) {
      user_keys[i] = convertKey(keys[i]);
    }
    return filter_->CreateFilter(user_keys.get(), n, dst);
  }

  bool KeyMayMatch(const rocksdb::Slice& key, const rocksdb::Slice& filter)
      const override {
    counter_++;
    return filter_->KeyMayMatch(convertKey(key), filter);
  }

  uint32_t GetCounter() { return counter_; }

 private:
  const FilterPolicy* filter_;
  mutable uint32_t counter_;

5321
  rocksdb::Slice convertKey(const rocksdb::Slice& key) const {
F
Feng Zhu 已提交
5322 5323 5324 5325 5326
    return key;
  }
};
}  // namespace

I
Igor Sugak 已提交
5327
TEST_F(DBTest, BloomFilterWrapper) {
5328
  Options options = CurrentOptions();
F
Feng Zhu 已提交
5329 5330 5331 5332 5333 5334 5335
  options.statistics = rocksdb::CreateDBStatistics();

  BlockBasedTableOptions table_options;
  WrappedBloom* policy = new WrappedBloom(10);
  table_options.filter_policy.reset(policy);
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));

L
Lei Jin 已提交
5336
  CreateAndReopenWithCF({"pikachu"}, options);
F
Feng Zhu 已提交
5337 5338 5339 5340 5341 5342 5343

  const int maxKey = 10000;
  for (int i = 0; i < maxKey; i++) {
    ASSERT_OK(Put(1, Key(i), Key(i)));
  }
  // Add a large key to make the file contain wide range
  ASSERT_OK(Put(1, Key(maxKey + 55555), Key(maxKey + 55555)));
C
Chilledheart 已提交
5344
  ASSERT_EQ(0U, policy->GetCounter());
F
Feng Zhu 已提交
5345 5346 5347 5348 5349 5350 5351
  Flush(1);

  // Check if they can be found
  for (int i = 0; i < maxKey; i++) {
    ASSERT_EQ(Key(i), Get(1, Key(i)));
  }
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 0);
C
Chilledheart 已提交
5352
  ASSERT_EQ(1U * maxKey, policy->GetCounter());
F
Feng Zhu 已提交
5353 5354 5355 5356 5357 5358

  // Check if filter is useful
  for (int i = 0; i < maxKey; i++) {
    ASSERT_EQ("NOT_FOUND", Get(1, Key(i+33333)));
  }
  ASSERT_GE(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), maxKey*0.98);
C
Chilledheart 已提交
5359
  ASSERT_EQ(2U * maxKey, policy->GetCounter());
F
Feng Zhu 已提交
5360 5361
}

I
Igor Sugak 已提交
5362
TEST_F(DBTest, SnapshotFiles) {
5363 5364 5365
  do {
    Options options = CurrentOptions();
    options.write_buffer_size = 100000000;        // Large write buffer
L
Lei Jin 已提交
5366
    CreateAndReopenWithCF({"pikachu"}, options);
5367

5368
    Random rnd(301);
5369

5370
    // Write 8MB (80 values, each 100K)
5371
    ASSERT_EQ(NumTableFilesAtLevel(0, 1), 0);
5372 5373 5374
    std::vector<std::string> values;
    for (int i = 0; i < 80; i++) {
      values.push_back(RandomString(&rnd, 100000));
5375
      ASSERT_OK(Put((i < 40), Key(i), values[i]));
5376
    }
5377

5378
    // assert that nothing makes it to disk yet.
5379
    ASSERT_EQ(NumTableFilesAtLevel(0, 1), 0);
5380

5381 5382 5383 5384 5385 5386 5387
    // get a file snapshot
    uint64_t manifest_number = 0;
    uint64_t manifest_size = 0;
    std::vector<std::string> files;
    dbfull()->DisableFileDeletions();
    dbfull()->GetLiveFiles(files, &manifest_size);

5388 5389
    // CURRENT, MANIFEST, *.sst files (one for each CF)
    ASSERT_EQ(files.size(), 4U);
5390 5391 5392 5393 5394 5395

    uint64_t number = 0;
    FileType type;

    // copy these files to a new snapshot directory
    std::string snapdir = dbname_ + ".snapdir/";
5396
    ASSERT_OK(env_->CreateDirIfMissing(snapdir));
5397 5398

    for (unsigned int i = 0; i < files.size(); i++) {
I
Igor Canadi 已提交
5399 5400 5401 5402 5403
      // our clients require that GetLiveFiles returns
      // files with "/" as first character!
      ASSERT_EQ(files[i][0], '/');
      std::string src = dbname_ + files[i];
      std::string dest = snapdir + files[i];
5404 5405 5406 5407 5408 5409 5410 5411 5412 5413 5414 5415 5416

      uint64_t size;
      ASSERT_OK(env_->GetFileSize(src, &size));

      // record the number and the size of the
      // latest manifest file
      if (ParseFileName(files[i].substr(1), &number, &type)) {
        if (type == kDescriptorFile) {
          if (number > manifest_number) {
            manifest_number = number;
            ASSERT_GE(size, manifest_size);
            size = manifest_size; // copy only valid MANIFEST data
          }
5417 5418
        }
      }
I
Igor Canadi 已提交
5419
      CopyFile(src, dest, size);
5420 5421
    }

5422 5423 5424 5425 5426 5427
    // release file snapshot
    dbfull()->DisableFileDeletions();
    // overwrite one key, this key should not appear in the snapshot
    std::vector<std::string> extras;
    for (unsigned int i = 0; i < 1; i++) {
      extras.push_back(RandomString(&rnd, 100000));
5428
      ASSERT_OK(Put(0, Key(i), extras[i]));
5429
    }
5430

5431
    // verify that data in the snapshot are correct
5432 5433 5434 5435
    std::vector<ColumnFamilyDescriptor> column_families;
    column_families.emplace_back("default", ColumnFamilyOptions());
    column_families.emplace_back("pikachu", ColumnFamilyOptions());
    std::vector<ColumnFamilyHandle*> cf_handles;
5436
    DB* snapdb;
5437
    DBOptions opts;
5438
    opts.env = env_;
5439
    opts.create_if_missing = false;
5440 5441
    Status stat =
        DB::Open(opts, snapdir, column_families, &cf_handles, &snapdb);
N
Naman Gupta 已提交
5442
    ASSERT_OK(stat);
5443 5444 5445 5446

    ReadOptions roptions;
    std::string val;
    for (unsigned int i = 0; i < 80; i++) {
5447
      stat = snapdb->Get(roptions, cf_handles[i < 40], Key(i), &val);
5448 5449
      ASSERT_EQ(values[i].compare(val), 0);
    }
5450 5451 5452
    for (auto cfh : cf_handles) {
      delete cfh;
    }
5453 5454 5455 5456 5457 5458 5459 5460 5461 5462 5463 5464 5465 5466 5467 5468 5469 5470 5471 5472 5473 5474 5475 5476 5477 5478
    delete snapdb;

    // look at the new live files after we added an 'extra' key
    // and after we took the first snapshot.
    uint64_t new_manifest_number = 0;
    uint64_t new_manifest_size = 0;
    std::vector<std::string> newfiles;
    dbfull()->DisableFileDeletions();
    dbfull()->GetLiveFiles(newfiles, &new_manifest_size);

    // find the new manifest file. assert that this manifest file is
    // the same one as in the previous snapshot. But its size should be
    // larger because we added an extra key after taking the
    // previous shapshot.
    for (unsigned int i = 0; i < newfiles.size(); i++) {
      std::string src = dbname_ + "/" + newfiles[i];
      // record the lognumber and the size of the
      // latest manifest file
      if (ParseFileName(newfiles[i].substr(1), &number, &type)) {
        if (type == kDescriptorFile) {
          if (number > new_manifest_number) {
            uint64_t size;
            new_manifest_number = number;
            ASSERT_OK(env_->GetFileSize(src, &size));
            ASSERT_GE(size, new_manifest_size);
          }
5479 5480 5481
        }
      }
    }
5482 5483
    ASSERT_EQ(manifest_number, new_manifest_number);
    ASSERT_GT(new_manifest_size, manifest_size);
5484

5485 5486 5487
    // release file snapshot
    dbfull()->DisableFileDeletions();
  } while (ChangeCompactOptions());
5488 5489
}

I
Igor Sugak 已提交
5490
TEST_F(DBTest, CompactOnFlush) {
5491 5492
  anon::OptionsOverride options_override;
  options_override.skip_policy = kSkipNoSnapshot;
5493
  do {
5494
    Options options = CurrentOptions(options_override);
5495
    options.disable_auto_compactions = true;
L
Lei Jin 已提交
5496
    CreateAndReopenWithCF({"pikachu"}, options);
5497

5498 5499 5500
    Put(1, "foo", "v1");
    ASSERT_OK(Flush(1));
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ v1 ]");
5501

5502
    // Write two new keys
5503 5504 5505
    Put(1, "a", "begin");
    Put(1, "z", "end");
    Flush(1);
5506

5507
    // Case1: Delete followed by a put
5508 5509 5510
    Delete(1, "foo");
    Put(1, "foo", "v2");
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ v2, DEL, v1 ]");
5511

5512 5513
    // After the current memtable is flushed, the DEL should
    // have been removed
5514 5515
    ASSERT_OK(Flush(1));
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ v2, v1 ]");
5516

5517 5518
    dbfull()->CompactRange(CompactRangeOptions(), handles_[1], nullptr,
                           nullptr);
5519
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ v2 ]");
5520

5521
    // Case 2: Delete followed by another delete
5522 5523 5524 5525 5526
    Delete(1, "foo");
    Delete(1, "foo");
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ DEL, DEL, v2 ]");
    ASSERT_OK(Flush(1));
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ DEL, v2 ]");
5527 5528
    dbfull()->CompactRange(CompactRangeOptions(), handles_[1], nullptr,
                           nullptr);
5529
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ ]");
5530

5531
    // Case 3: Put followed by a delete
5532 5533 5534 5535 5536
    Put(1, "foo", "v3");
    Delete(1, "foo");
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ DEL, v3 ]");
    ASSERT_OK(Flush(1));
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ DEL ]");
5537 5538
    dbfull()->CompactRange(CompactRangeOptions(), handles_[1], nullptr,
                           nullptr);
5539
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ ]");
5540

5541
    // Case 4: Put followed by another Put
5542 5543 5544 5545 5546
    Put(1, "foo", "v4");
    Put(1, "foo", "v5");
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ v5, v4 ]");
    ASSERT_OK(Flush(1));
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ v5 ]");
5547 5548
    dbfull()->CompactRange(CompactRangeOptions(), handles_[1], nullptr,
                           nullptr);
5549
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ v5 ]");
5550

5551
    // clear database
5552
    Delete(1, "foo");
5553 5554
    dbfull()->CompactRange(CompactRangeOptions(), handles_[1], nullptr,
                           nullptr);
5555
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ ]");
5556

5557 5558
    // Case 5: Put followed by snapshot followed by another Put
    // Both puts should remain.
5559
    Put(1, "foo", "v6");
5560
    const Snapshot* snapshot = db_->GetSnapshot();
5561 5562 5563
    Put(1, "foo", "v7");
    ASSERT_OK(Flush(1));
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ v7, v6 ]");
5564
    db_->ReleaseSnapshot(snapshot);
5565

5566
    // clear database
5567
    Delete(1, "foo");
5568 5569
    dbfull()->CompactRange(CompactRangeOptions(), handles_[1], nullptr,
                           nullptr);
5570
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ ]");
5571

5572 5573 5574
    // Case 5: snapshot followed by a put followed by another Put
    // Only the last put should remain.
    const Snapshot* snapshot1 = db_->GetSnapshot();
5575 5576 5577 5578
    Put(1, "foo", "v8");
    Put(1, "foo", "v9");
    ASSERT_OK(Flush(1));
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ v9 ]");
5579 5580
    db_->ReleaseSnapshot(snapshot1);
  } while (ChangeCompactOptions());
5581 5582
}

I
Igor Canadi 已提交
5583
namespace {
S
Stanislau Hlebik 已提交
5584 5585
std::vector<std::uint64_t> ListSpecificFiles(
    Env* env, const std::string& path, const FileType expected_file_type) {
5586
  std::vector<std::string> files;
S
Stanislau Hlebik 已提交
5587
  std::vector<uint64_t> file_numbers;
5588 5589 5590 5591 5592
  env->GetChildren(path, &files);
  uint64_t number;
  FileType type;
  for (size_t i = 0; i < files.size(); ++i) {
    if (ParseFileName(files[i], &number, &type)) {
S
Stanislau Hlebik 已提交
5593
      if (type == expected_file_type) {
S
Stanislau Hlebik 已提交
5594
        file_numbers.push_back(number);
5595 5596 5597
      }
    }
  }
S
Stanislau Hlebik 已提交
5598
  return std::move(file_numbers);
5599
}
S
Stanislau Hlebik 已提交
5600 5601 5602 5603

std::vector<std::uint64_t> ListTableFiles(Env* env, const std::string& path) {
  return ListSpecificFiles(env, path, kTableFile);
}
I
Igor Canadi 已提交
5604
}  // namespace
5605

I
Igor Sugak 已提交
5606
TEST_F(DBTest, FlushOneColumnFamily) {
5607
  Options options = CurrentOptions();
S
Stanislau Hlebik 已提交
5608 5609
  CreateAndReopenWithCF({"pikachu", "ilya", "muromec", "dobrynia", "nikitich",
                         "alyosha", "popovich"},
L
Lei Jin 已提交
5610
                        options);
S
Stanislau Hlebik 已提交
5611 5612 5613 5614 5615 5616 5617 5618 5619 5620

  ASSERT_OK(Put(0, "Default", "Default"));
  ASSERT_OK(Put(1, "pikachu", "pikachu"));
  ASSERT_OK(Put(2, "ilya", "ilya"));
  ASSERT_OK(Put(3, "muromec", "muromec"));
  ASSERT_OK(Put(4, "dobrynia", "dobrynia"));
  ASSERT_OK(Put(5, "nikitich", "nikitich"));
  ASSERT_OK(Put(6, "alyosha", "alyosha"));
  ASSERT_OK(Put(7, "popovich", "popovich"));

5621
  for (int i = 0; i < 8; ++i) {
S
Stanislau Hlebik 已提交
5622 5623
    Flush(i);
    auto tables = ListTableFiles(env_, dbname_);
5624
    ASSERT_EQ(tables.size(), i + 1U);
S
Stanislau Hlebik 已提交
5625 5626 5627
  }
}

S
Stanislau Hlebik 已提交
5628 5629 5630 5631 5632
// In https://reviews.facebook.net/D20661 we change
// recovery behavior: previously for each log file each column family
// memtable was flushed, even it was empty. Now it's changed:
// we try to create the smallest number of table files by merging
// updates from multiple logs
I
Igor Sugak 已提交
5633
TEST_F(DBTest, RecoverCheckFileAmountWithSmallWriteBuffer) {
5634
  Options options = CurrentOptions();
S
Stanislau Hlebik 已提交
5635
  options.write_buffer_size = 5000000;
L
Lei Jin 已提交
5636
  CreateAndReopenWithCF({"pikachu", "dobrynia", "nikitich"}, options);
S
Stanislau Hlebik 已提交
5637 5638 5639 5640 5641 5642 5643 5644 5645 5646 5647 5648 5649 5650 5651

  // Since we will reopen DB with smaller write_buffer_size,
  // each key will go to new SST file
  ASSERT_OK(Put(1, Key(10), DummyString(1000000)));
  ASSERT_OK(Put(1, Key(10), DummyString(1000000)));
  ASSERT_OK(Put(1, Key(10), DummyString(1000000)));
  ASSERT_OK(Put(1, Key(10), DummyString(1000000)));

  ASSERT_OK(Put(3, Key(10), DummyString(1)));
  // Make 'dobrynia' to be flushed and new WAL file to be created
  ASSERT_OK(Put(2, Key(10), DummyString(7500000)));
  ASSERT_OK(Put(2, Key(1), DummyString(1)));
  dbfull()->TEST_WaitForFlushMemTable(handles_[2]);
  {
    auto tables = ListTableFiles(env_, dbname_);
I
Igor Canadi 已提交
5652
    ASSERT_EQ(tables.size(), static_cast<size_t>(1));
S
Stanislau Hlebik 已提交
5653
    // Make sure 'dobrynia' was flushed: check sst files amount
I
Igor Canadi 已提交
5654 5655
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "dobrynia"),
              static_cast<uint64_t>(1));
S
Stanislau Hlebik 已提交
5656 5657 5658 5659 5660 5661 5662 5663 5664 5665
  }
  // New WAL file
  ASSERT_OK(Put(1, Key(1), DummyString(1)));
  ASSERT_OK(Put(1, Key(1), DummyString(1)));
  ASSERT_OK(Put(3, Key(10), DummyString(1)));
  ASSERT_OK(Put(3, Key(10), DummyString(1)));
  ASSERT_OK(Put(3, Key(10), DummyString(1)));

  options.write_buffer_size = 10;
  ReopenWithColumnFamilies({"default", "pikachu", "dobrynia", "nikitich"},
L
Lei Jin 已提交
5666
                           options);
S
Stanislau Hlebik 已提交
5667 5668
  {
    // No inserts => default is empty
I
Igor Canadi 已提交
5669 5670
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "default"),
              static_cast<uint64_t>(0));
S
Stanislau Hlebik 已提交
5671
    // First 4 keys goes to separate SSTs + 1 more SST for 2 smaller keys
I
Igor Canadi 已提交
5672 5673
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "pikachu"),
              static_cast<uint64_t>(5));
S
Stanislau Hlebik 已提交
5674
    // 1 SST for big key + 1 SST for small one
I
Igor Canadi 已提交
5675 5676
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "dobrynia"),
              static_cast<uint64_t>(2));
S
Stanislau Hlebik 已提交
5677
    // 1 SST for all keys
I
Igor Canadi 已提交
5678 5679
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "nikitich"),
              static_cast<uint64_t>(1));
S
Stanislau Hlebik 已提交
5680 5681 5682 5683 5684 5685 5686 5687
  }
}

// In https://reviews.facebook.net/D20661 we change
// recovery behavior: previously for each log file each column family
// memtable was flushed, even it wasn't empty. Now it's changed:
// we try to create the smallest number of table files by merging
// updates from multiple logs
I
Igor Sugak 已提交
5688
TEST_F(DBTest, RecoverCheckFileAmount) {
5689
  Options options = CurrentOptions();
S
Stanislau Hlebik 已提交
5690
  options.write_buffer_size = 100000;
L
Lei Jin 已提交
5691
  CreateAndReopenWithCF({"pikachu", "dobrynia", "nikitich"}, options);
S
Stanislau Hlebik 已提交
5692 5693 5694 5695 5696 5697 5698 5699 5700 5701 5702 5703

  ASSERT_OK(Put(0, Key(1), DummyString(1)));
  ASSERT_OK(Put(1, Key(1), DummyString(1)));
  ASSERT_OK(Put(2, Key(1), DummyString(1)));

  // Make 'nikitich' memtable to be flushed
  ASSERT_OK(Put(3, Key(10), DummyString(1002400)));
  ASSERT_OK(Put(3, Key(1), DummyString(1)));
  dbfull()->TEST_WaitForFlushMemTable(handles_[3]);
  // 4 memtable are not flushed, 1 sst file
  {
    auto tables = ListTableFiles(env_, dbname_);
I
Igor Canadi 已提交
5704 5705 5706
    ASSERT_EQ(tables.size(), static_cast<size_t>(1));
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "nikitich"),
              static_cast<uint64_t>(1));
S
Stanislau Hlebik 已提交
5707 5708 5709 5710 5711 5712 5713 5714 5715 5716 5717 5718 5719 5720 5721 5722 5723 5724 5725 5726 5727
  }
  // Memtable for 'nikitich' has flushed, new WAL file has opened
  // 4 memtable still not flushed

  // Write to new WAL file
  ASSERT_OK(Put(0, Key(1), DummyString(1)));
  ASSERT_OK(Put(1, Key(1), DummyString(1)));
  ASSERT_OK(Put(2, Key(1), DummyString(1)));

  // Fill up 'nikitich' one more time
  ASSERT_OK(Put(3, Key(10), DummyString(1002400)));
  // make it flush
  ASSERT_OK(Put(3, Key(1), DummyString(1)));
  dbfull()->TEST_WaitForFlushMemTable(handles_[3]);
  // There are still 4 memtable not flushed, and 2 sst tables
  ASSERT_OK(Put(0, Key(1), DummyString(1)));
  ASSERT_OK(Put(1, Key(1), DummyString(1)));
  ASSERT_OK(Put(2, Key(1), DummyString(1)));

  {
    auto tables = ListTableFiles(env_, dbname_);
I
Igor Canadi 已提交
5728 5729 5730
    ASSERT_EQ(tables.size(), static_cast<size_t>(2));
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "nikitich"),
              static_cast<uint64_t>(2));
S
Stanislau Hlebik 已提交
5731 5732 5733
  }

  ReopenWithColumnFamilies({"default", "pikachu", "dobrynia", "nikitich"},
L
Lei Jin 已提交
5734
                           options);
S
Stanislau Hlebik 已提交
5735 5736 5737 5738 5739 5740
  {
    std::vector<uint64_t> table_files = ListTableFiles(env_, dbname_);
    // Check, that records for 'default', 'dobrynia' and 'pikachu' from
    // first, second and third WALs  went to the same SST.
    // So, there is 6 SSTs: three  for 'nikitich', one for 'default', one for
    // 'dobrynia', one for 'pikachu'
I
Igor Canadi 已提交
5741 5742 5743 5744 5745 5746 5747 5748
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "default"),
              static_cast<uint64_t>(1));
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "nikitich"),
              static_cast<uint64_t>(3));
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "dobrynia"),
              static_cast<uint64_t>(1));
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "pikachu"),
              static_cast<uint64_t>(1));
S
Stanislau Hlebik 已提交
5749 5750 5751
  }
}

I
Igor Sugak 已提交
5752
TEST_F(DBTest, SharedWriteBuffer) {
5753
  Options options = CurrentOptions();
5754 5755 5756 5757 5758 5759 5760 5761 5762 5763 5764 5765 5766 5767 5768 5769 5770 5771 5772 5773 5774 5775 5776 5777 5778 5779 5780 5781 5782 5783 5784 5785 5786 5787 5788 5789 5790 5791 5792 5793 5794 5795 5796 5797 5798 5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809 5810 5811 5812 5813 5814 5815 5816 5817 5818 5819 5820 5821 5822 5823 5824 5825 5826 5827 5828 5829 5830 5831
  options.db_write_buffer_size = 100000;  // this is the real limit
  options.write_buffer_size    = 500000;  // this is never hit
  CreateAndReopenWithCF({"pikachu", "dobrynia", "nikitich"}, options);

  // Trigger a flush on every CF
  ASSERT_OK(Put(0, Key(1), DummyString(1)));
  ASSERT_OK(Put(1, Key(1), DummyString(1)));
  ASSERT_OK(Put(3, Key(1), DummyString(90000)));
  ASSERT_OK(Put(2, Key(2), DummyString(20000)));
  ASSERT_OK(Put(2, Key(1), DummyString(1)));
  dbfull()->TEST_WaitForFlushMemTable(handles_[0]);
  dbfull()->TEST_WaitForFlushMemTable(handles_[1]);
  dbfull()->TEST_WaitForFlushMemTable(handles_[2]);
  dbfull()->TEST_WaitForFlushMemTable(handles_[3]);
  {
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "default"),
              static_cast<uint64_t>(1));
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "pikachu"),
              static_cast<uint64_t>(1));
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "dobrynia"),
              static_cast<uint64_t>(1));
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "nikitich"),
              static_cast<uint64_t>(1));
  }

  // Flush 'dobrynia' and 'nikitich'
  ASSERT_OK(Put(2, Key(2), DummyString(50000)));
  ASSERT_OK(Put(3, Key(2), DummyString(40000)));
  ASSERT_OK(Put(2, Key(3), DummyString(20000)));
  ASSERT_OK(Put(3, Key(2), DummyString(40000)));
  dbfull()->TEST_WaitForFlushMemTable(handles_[1]);
  dbfull()->TEST_WaitForFlushMemTable(handles_[2]);
  dbfull()->TEST_WaitForFlushMemTable(handles_[3]);
  {
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "default"),
              static_cast<uint64_t>(1));
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "pikachu"),
              static_cast<uint64_t>(1));
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "dobrynia"),
              static_cast<uint64_t>(2));
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "nikitich"),
              static_cast<uint64_t>(2));
  }

  // Make 'dobrynia' and 'nikitich' both take up 40% of space
  // When 'pikachu' puts us over 100%, all 3 flush.
  ASSERT_OK(Put(2, Key(2), DummyString(40000)));
  ASSERT_OK(Put(1, Key(2), DummyString(20000)));
  ASSERT_OK(Put(0, Key(1), DummyString(1)));
  dbfull()->TEST_WaitForFlushMemTable(handles_[2]);
  dbfull()->TEST_WaitForFlushMemTable(handles_[3]);
  {
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "default"),
              static_cast<uint64_t>(1));
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "pikachu"),
              static_cast<uint64_t>(2));
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "dobrynia"),
              static_cast<uint64_t>(3));
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "nikitich"),
              static_cast<uint64_t>(3));
  }

  // Some remaining writes so 'default' and 'nikitich' flush on closure.
  ASSERT_OK(Put(3, Key(1), DummyString(1)));
  ReopenWithColumnFamilies({"default", "pikachu", "dobrynia", "nikitich"},
                           options);
  {
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "default"),
              static_cast<uint64_t>(2));
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "pikachu"),
              static_cast<uint64_t>(2));
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "dobrynia"),
              static_cast<uint64_t>(3));
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "nikitich"),
              static_cast<uint64_t>(4));
  }
}

I
Igor Sugak 已提交
5832
TEST_F(DBTest, PurgeInfoLogs) {
5833 5834 5835 5836 5837 5838 5839 5840 5841 5842 5843
  Options options = CurrentOptions();
  options.keep_log_file_num = 5;
  options.create_if_missing = true;
  for (int mode = 0; mode <= 1; mode++) {
    if (mode == 1) {
      options.db_log_dir = dbname_ + "_logs";
      env_->CreateDirIfMissing(options.db_log_dir);
    } else {
      options.db_log_dir = "";
    }
    for (int i = 0; i < 8; i++) {
L
Lei Jin 已提交
5844
      Reopen(options);
5845 5846 5847 5848 5849 5850 5851 5852 5853 5854 5855 5856
    }

    std::vector<std::string> files;
    env_->GetChildren(options.db_log_dir.empty() ? dbname_ : options.db_log_dir,
                      &files);
    int info_log_count = 0;
    for (std::string file : files) {
      if (file.find("LOG") != std::string::npos) {
        info_log_count++;
      }
    }
    ASSERT_EQ(5, info_log_count);
5857

L
Lei Jin 已提交
5858
    Destroy(options);
I
Igor Canadi 已提交
5859
    // For mode (1), test DestroyDB() to delete all the logs under DB dir.
5860 5861 5862 5863 5864 5865 5866 5867 5868 5869 5870 5871 5872 5873 5874
    // For mode (2), no info log file should have been put under DB dir.
    std::vector<std::string> db_files;
    env_->GetChildren(dbname_, &db_files);
    for (std::string file : db_files) {
      ASSERT_TRUE(file.find("LOG") == std::string::npos);
    }

    if (mode == 1) {
      // Cleaning up
      env_->GetChildren(options.db_log_dir, &files);
      for (std::string file : files) {
        env_->DeleteFile(options.db_log_dir + "/" + file);
      }
      env_->DeleteDir(options.db_log_dir);
    }
5875 5876 5877
  }
}

5878

K
krad 已提交
5879 5880 5881 5882 5883
//
// Test WAL recovery for the various modes available
//
class RecoveryTestHelper {
 public:
5884 5885 5886 5887 5888 5889 5890 5891
  // Number of WAL files to generate
  static const int kWALFilesCount = 10;
  // Starting number for the WAL file name like 00010.log
  static const int kWALFileOffset = 10;
  // Keys to be written per WAL file
  static const int kKeysPerWALFile = 1024;
  // Size of the value
  static const int kValueSize = 10;
K
krad 已提交
5892

5893
  // Create WAL files with values filled in
S
sdong 已提交
5894 5895 5896
  static void FillData(DBTest* test, Options& options, const size_t wal_count,
                       size_t& count) {
    DBOptions& db_options = options;
5897 5898 5899 5900 5901 5902 5903 5904 5905 5906 5907 5908 5909 5910 5911 5912 5913 5914 5915 5916

    count = 0;

    shared_ptr<Cache> table_cache = NewLRUCache(50000, 16);
    EnvOptions env_options;
    WriteBuffer write_buffer(db_options.db_write_buffer_size);

    unique_ptr<VersionSet> versions;
    unique_ptr<WalManager> wal_manager;
    WriteController write_controller;

    versions.reset(new VersionSet(test->dbname_, &db_options, env_options,
                                  table_cache.get(), &write_buffer,
                                  &write_controller));

    wal_manager.reset(new WalManager(db_options, env_options));

    std::unique_ptr<log::Writer> current_log_writer;

    for (size_t j = kWALFileOffset; j < wal_count + kWALFileOffset; j++) {
S
sdong 已提交
5917
      uint64_t current_log_number = j;
5918 5919 5920 5921 5922 5923 5924 5925 5926
      std::string fname = LogFileName(test->dbname_, current_log_number);
      unique_ptr<WritableFile> file;
      ASSERT_OK(db_options.env->NewWritableFile(fname, &file, env_options));
      current_log_writer.reset(new log::Writer(std::move(file)));

      for (int i = 0; i < kKeysPerWALFile; i++) {
        std::string key = "key" + ToString(count++);
        std::string value = test->DummyString(kValueSize);
        assert(current_log_writer.get() != nullptr);
S
sdong 已提交
5927
        uint64_t seq = versions->LastSequence() + 1;
5928 5929 5930 5931 5932 5933
        WriteBatch batch;
        batch.Put(key, value);
        WriteBatchInternal::SetSequence(&batch, seq);
        current_log_writer->AddRecord(WriteBatchInternal::Contents(&batch));
        versions->SetLastSequence(seq);
      }
K
krad 已提交
5934
    }
5935 5936 5937 5938 5939 5940 5941 5942 5943 5944
  }

  // Recreate and fill the store with some data
  static size_t FillData(DBTest* test, Options& options) {
    options.create_if_missing = true;
    test->DestroyAndReopen(options);
    test->Close();

    size_t count = 0;
    FillData(test, options, kWALFilesCount, count);
K
krad 已提交
5945 5946 5947 5948 5949 5950
    return count;
  }

  // Read back all the keys we wrote and return the number of keys found
  static size_t GetData(DBTest* test) {
    size_t count = 0;
5951
    for (size_t i = 0; i < kWALFilesCount * kKeysPerWALFile; i++) {
K
krad 已提交
5952 5953 5954 5955 5956 5957 5958
      if (test->Get("key" + ToString(i)) != "NOT_FOUND") {
        ++count;
      }
    }
    return count;
  }

5959
  // Manuall corrupt the specified WAL
S
sdong 已提交
5960 5961 5962
  static void CorruptWAL(DBTest* test, Options& options, const double off,
                         const double len, const int wal_file_id,
                         const bool trunc = false) {
5963 5964 5965 5966 5967
    Env* env = options.env;
    std::string fname = LogFileName(test->dbname_, wal_file_id);
    uint64_t size;
    ASSERT_OK(env->GetFileSize(fname, &size));
    ASSERT_GT(size, 0);
D
Dmitri Smirnov 已提交
5968 5969 5970 5971 5972 5973 5974 5975
#ifdef OS_WIN
    // Windows disk cache behaves differently. When we truncate
    // the original content is still in the cache due to the original
    // handle is still open. Generally, in Windows, one prohibits
    // shared access to files and it is not needed for WAL but we allow
    // it to induce corruption at various tests.
    test->Close();
#endif
5976 5977 5978 5979 5980 5981 5982
    if (trunc) {
      ASSERT_EQ(0, truncate(fname.c_str(), size * off));
    } else {
      InduceCorruption(fname, size * off, size * len);
    }
  }

K
krad 已提交
5983 5984 5985 5986 5987 5988 5989 5990 5991 5992
  // Overwrite data with 'a' from offset for length len
  static void InduceCorruption(const std::string& filename, uint32_t offset,
                               uint32_t len) {
    ASSERT_GT(len, 0);

    int fd = open(filename.c_str(), O_RDWR);

    ASSERT_GT(fd, 0);
    ASSERT_EQ(offset, lseek(fd, offset, SEEK_SET));

D
Dmitri Smirnov 已提交
5993
    void* buf = alloca(len);
K
krad 已提交
5994 5995 5996 5997 5998 5999 6000 6001 6002 6003 6004 6005
    memset(buf, 'a', len);
    ASSERT_EQ(len, write(fd, buf, len));

    close(fd);
  }
};

// Test scope:
// - We expect to open the data store when there is incomplete trailing writes
// at the end of any of the logs
// - We do not expect to open the data store for corruption
TEST_F(DBTest, kTolerateCorruptedTailRecords) {
S
sdong 已提交
6006 6007
  const int jstart = RecoveryTestHelper::kWALFileOffset;
  const int jend = jstart + RecoveryTestHelper::kWALFilesCount;
6008

S
sdong 已提交
6009 6010
  for (auto trunc : {true, false}) {        /* Corruption style */
    for (int i = 0; i < 4; i++) {           /* Corruption offset position */
6011 6012 6013 6014 6015
      for (int j = jstart; j < jend; j++) { /* WAL file */
        // Fill data for testing
        Options options = CurrentOptions();
        const size_t row_count = RecoveryTestHelper::FillData(this, options);
        // test checksum failure or parsing
S
sdong 已提交
6016 6017
        RecoveryTestHelper::CorruptWAL(this, options, /*off=*/i * .3,
                                       /*len%=*/.1, /*wal=*/j, trunc);
6018 6019 6020 6021 6022 6023 6024 6025 6026 6027 6028 6029 6030 6031

        if (trunc) {
          options.wal_recovery_mode =
              WALRecoveryMode::kTolerateCorruptedTailRecords;
          options.create_if_missing = false;
          ASSERT_OK(TryReopen(options));
          const size_t recovered_row_count = RecoveryTestHelper::GetData(this);
          ASSERT_TRUE(i == 0 || recovered_row_count > 0);
          ASSERT_LT(recovered_row_count, row_count);
        } else {
          options.wal_recovery_mode =
              WALRecoveryMode::kTolerateCorruptedTailRecords;
          ASSERT_NOK(TryReopen(options));
        }
K
krad 已提交
6032 6033 6034 6035 6036 6037 6038 6039 6040
      }
    }
  }
}

// Test scope:
// We don't expect the data store to be opened if there is any corruption
// (leading, middle or trailing -- incomplete writes or corruption)
TEST_F(DBTest, kAbsoluteConsistency) {
S
sdong 已提交
6041 6042
  const int jstart = RecoveryTestHelper::kWALFileOffset;
  const int jend = jstart + RecoveryTestHelper::kWALFilesCount;
6043 6044

  // Verify clean slate behavior
K
krad 已提交
6045 6046 6047
  Options options = CurrentOptions();
  const size_t row_count = RecoveryTestHelper::FillData(this, options);
  options.wal_recovery_mode = WALRecoveryMode::kAbsoluteConsistency;
6048
  options.create_if_missing = false;
K
krad 已提交
6049 6050 6051
  ASSERT_OK(TryReopen(options));
  ASSERT_EQ(RecoveryTestHelper::GetData(this), row_count);

6052
  for (auto trunc : {true, false}) { /* Corruption style */
S
sdong 已提交
6053
    for (int i = 0; i < 4; i++) {    /* Corruption offset position */
K
krad 已提交
6054 6055 6056 6057
      if (trunc && i == 0) {
        continue;
      }

6058 6059 6060 6061
      for (int j = jstart; j < jend; j++) { /* wal files */
        // fill with new date
        RecoveryTestHelper::FillData(this, options);
        // corrupt the wal
S
sdong 已提交
6062
        RecoveryTestHelper::CorruptWAL(this, options, /*off=*/i * .3,
6063 6064 6065 6066 6067 6068
                                       /*len%=*/.1, j, trunc);
        // verify
        options.wal_recovery_mode = WALRecoveryMode::kAbsoluteConsistency;
        options.create_if_missing = false;
        ASSERT_NOK(TryReopen(options));
      }
K
krad 已提交
6069 6070 6071 6072 6073 6074 6075 6076
    }
  }
}

// Test scope:
// - We expect to open data store under all circumstances
// - We expect only data upto the point where the first error was encountered
TEST_F(DBTest, kPointInTimeRecovery) {
S
sdong 已提交
6077
  const int jstart = RecoveryTestHelper::kWALFileOffset;
6078
  const int jend = jstart + RecoveryTestHelper::kWALFilesCount;
S
sdong 已提交
6079 6080
  const int maxkeys =
      RecoveryTestHelper::kWALFilesCount * RecoveryTestHelper::kKeysPerWALFile;
6081

S
sdong 已提交
6082 6083
  for (auto trunc : {true, false}) {        /* Corruption style */
    for (int i = 0; i < 4; i++) {           /* Offset of corruption */
6084 6085 6086 6087 6088 6089
      for (int j = jstart; j < jend; j++) { /* WAL file */
        // Fill data for testing
        Options options = CurrentOptions();
        const size_t row_count = RecoveryTestHelper::FillData(this, options);

        // Corrupt the wal
S
sdong 已提交
6090
        RecoveryTestHelper::CorruptWAL(this, options, /*off=*/i * .3,
6091 6092 6093 6094 6095 6096
                                       /*len%=*/.1, j, trunc);

        // Verify
        options.wal_recovery_mode = WALRecoveryMode::kPointInTimeRecovery;
        options.create_if_missing = false;
        ASSERT_OK(TryReopen(options));
K
krad 已提交
6097

6098 6099 6100
        // Probe data for invariants
        size_t recovered_row_count = RecoveryTestHelper::GetData(this);
        ASSERT_LT(recovered_row_count, row_count);
K
krad 已提交
6101

6102 6103 6104 6105 6106 6107 6108 6109
        bool expect_data = true;
        for (size_t k = 0; k < maxkeys; ++k) {
          bool found = Get("key" + ToString(i)) != "NOT_FOUND";
          if (expect_data && !found) {
            expect_data = false;
          }
          ASSERT_EQ(found, expect_data);
        }
K
krad 已提交
6110

6111
        const size_t min = RecoveryTestHelper::kKeysPerWALFile *
S
sdong 已提交
6112
                           (j - RecoveryTestHelper::kWALFileOffset);
6113 6114 6115
        ASSERT_GE(recovered_row_count, min);
        if (!trunc && i != 0) {
          const size_t max = RecoveryTestHelper::kKeysPerWALFile *
S
sdong 已提交
6116
                             (j - RecoveryTestHelper::kWALFileOffset + 1);
6117
          ASSERT_LE(recovered_row_count, max);
K
krad 已提交
6118 6119 6120 6121 6122 6123 6124 6125 6126 6127
        }
      }
    }
  }
}

// Test scope:
// - We expect to open the data store under all scenarios
// - We expect to have recovered records past the corruption zone
TEST_F(DBTest, kSkipAnyCorruptedRecords) {
S
sdong 已提交
6128 6129
  const int jstart = RecoveryTestHelper::kWALFileOffset;
  const int jend = jstart + RecoveryTestHelper::kWALFilesCount;
6130

S
sdong 已提交
6131 6132
  for (auto trunc : {true, false}) {        /* Corruption style */
    for (int i = 0; i < 4; i++) {           /* Corruption offset */
6133 6134 6135 6136 6137 6138
      for (int j = jstart; j < jend; j++) { /* wal files */
        // Fill data for testing
        Options options = CurrentOptions();
        const size_t row_count = RecoveryTestHelper::FillData(this, options);

        // Corrupt the WAL
S
sdong 已提交
6139
        RecoveryTestHelper::CorruptWAL(this, options, /*off=*/i * .3,
6140 6141 6142 6143 6144 6145
                                       /*len%=*/.1, j, trunc);

        // Verify behavior
        options.wal_recovery_mode = WALRecoveryMode::kSkipAnyCorruptedRecords;
        options.create_if_missing = false;
        ASSERT_OK(TryReopen(options));
K
krad 已提交
6146

6147 6148 6149
        // Probe data for invariants
        size_t recovered_row_count = RecoveryTestHelper::GetData(this);
        ASSERT_LT(recovered_row_count, row_count);
K
krad 已提交
6150

6151 6152 6153
        if (!trunc) {
          ASSERT_TRUE(i != 0 || recovered_row_count > 0);
        }
K
krad 已提交
6154 6155 6156 6157 6158
      }
    }
  }
}

J
Jim Paton 已提交
6159

6160 6161 6162
// Multi-threaded test:
namespace {

6163 6164
static const int kColumnFamilies = 10;
static const int kNumThreads = 10;
6165 6166 6167 6168 6169
static const int kTestSeconds = 10;
static const int kNumKeys = 1000;

struct MTState {
  DBTest* test;
I
Igor Canadi 已提交
6170 6171 6172
  std::atomic<bool> stop;
  std::atomic<int> counter[kNumThreads];
  std::atomic<bool> thread_done[kNumThreads];
6173 6174 6175 6176 6177 6178 6179 6180 6181
};

struct MTThread {
  MTState* state;
  int id;
};

static void MTThreadBody(void* arg) {
  MTThread* t = reinterpret_cast<MTThread*>(arg);
6182
  int id = t->id;
6183
  DB* db = t->state->test->db_;
I
Igor Canadi 已提交
6184
  int counter = 0;
6185 6186
  fprintf(stderr, "... starting thread %d\n", id);
  Random rnd(1000 + id);
6187
  char valbuf[1500];
I
Igor Canadi 已提交
6188 6189
  while (t->state->stop.load(std::memory_order_acquire) == false) {
    t->state->counter[id].store(counter, std::memory_order_release);
6190 6191 6192 6193 6194 6195

    int key = rnd.Uniform(kNumKeys);
    char keybuf[20];
    snprintf(keybuf, sizeof(keybuf), "%016d", key);

    if (rnd.OneIn(2)) {
6196 6197
      // Write values of the form <key, my id, counter, cf, unique_id>.
      // into each of the CFs
6198
      // We add some padding for force compactions.
6199
      int unique_id = rnd.Uniform(1000000);
6200 6201 6202 6203 6204 6205 6206 6207 6208 6209 6210 6211 6212 6213 6214 6215 6216 6217 6218

      // Half of the time directly use WriteBatch. Half of the time use
      // WriteBatchWithIndex.
      if (rnd.OneIn(2)) {
        WriteBatch batch;
        for (int cf = 0; cf < kColumnFamilies; ++cf) {
          snprintf(valbuf, sizeof(valbuf), "%d.%d.%d.%d.%-1000d", key, id,
                   static_cast<int>(counter), cf, unique_id);
          batch.Put(t->state->test->handles_[cf], Slice(keybuf), Slice(valbuf));
        }
        ASSERT_OK(db->Write(WriteOptions(), &batch));
      } else {
        WriteBatchWithIndex batch(db->GetOptions().comparator);
        for (int cf = 0; cf < kColumnFamilies; ++cf) {
          snprintf(valbuf, sizeof(valbuf), "%d.%d.%d.%d.%-1000d", key, id,
                   static_cast<int>(counter), cf, unique_id);
          batch.Put(t->state->test->handles_[cf], Slice(keybuf), Slice(valbuf));
        }
        ASSERT_OK(db->Write(WriteOptions(), batch.GetWriteBatch()));
6219
      }
6220
    } else {
6221 6222 6223 6224 6225 6226 6227 6228 6229 6230 6231 6232 6233 6234
      // Read a value and verify that it matches the pattern written above
      // and that writes to all column families were atomic (unique_id is the
      // same)
      std::vector<Slice> keys(kColumnFamilies, Slice(keybuf));
      std::vector<std::string> values;
      std::vector<Status> statuses =
          db->MultiGet(ReadOptions(), t->state->test->handles_, keys, &values);
      Status s = statuses[0];
      // all statuses have to be the same
      for (size_t i = 1; i < statuses.size(); ++i) {
        // they are either both ok or both not-found
        ASSERT_TRUE((s.ok() && statuses[i].ok()) ||
                    (s.IsNotFound() && statuses[i].IsNotFound()));
      }
6235 6236 6237 6238 6239
      if (s.IsNotFound()) {
        // Key has not yet been written
      } else {
        // Check that the writer thread counter is >= the counter in the value
        ASSERT_OK(s);
6240 6241 6242 6243 6244 6245 6246 6247 6248
        int unique_id = -1;
        for (int i = 0; i < kColumnFamilies; ++i) {
          int k, w, c, cf, u;
          ASSERT_EQ(5, sscanf(values[i].c_str(), "%d.%d.%d.%d.%d", &k, &w,
                              &c, &cf, &u))
              << values[i];
          ASSERT_EQ(k, key);
          ASSERT_GE(w, 0);
          ASSERT_LT(w, kNumThreads);
I
Igor Canadi 已提交
6249
          ASSERT_LE(c, t->state->counter[w].load(std::memory_order_acquire));
6250 6251 6252 6253 6254 6255 6256 6257 6258
          ASSERT_EQ(cf, i);
          if (i == 0) {
            unique_id = u;
          } else {
            // this checks that updates across column families happened
            // atomically -- all unique ids are the same
            ASSERT_EQ(u, unique_id);
          }
        }
6259 6260 6261 6262
      }
    }
    counter++;
  }
I
Igor Canadi 已提交
6263
  t->state->thread_done[id].store(true, std::memory_order_release);
6264
  fprintf(stderr, "... stopping thread %d after %d ops\n", id, int(counter));
6265 6266
}

H
Hans Wennborg 已提交
6267
}  // namespace
6268

6269 6270 6271 6272 6273 6274 6275 6276 6277 6278 6279 6280 6281 6282 6283 6284 6285 6286
class MultiThreadedDBTest : public DBTest,
                            public ::testing::WithParamInterface<int> {
 public:
  virtual void SetUp() override { option_config_ = GetParam(); }

  static std::vector<int> GenerateOptionConfigs() {
    std::vector<int> optionConfigs;
    for (int optionConfig = kDefault; optionConfig < kEnd; ++optionConfig) {
      // skip as HashCuckooRep does not support snapshot
      if (optionConfig != kHashCuckoo) {
        optionConfigs.push_back(optionConfig);
      }
    }
    return optionConfigs;
  }
};

TEST_P(MultiThreadedDBTest, MultiThreaded) {
6287 6288
  anon::OptionsOverride options_override;
  options_override.skip_policy = kSkipNoSnapshot;
6289 6290 6291 6292 6293 6294 6295 6296 6297 6298 6299 6300 6301
  std::vector<std::string> cfs;
  for (int i = 1; i < kColumnFamilies; ++i) {
    cfs.push_back(ToString(i));
  }
  CreateAndReopenWithCF(cfs, CurrentOptions(options_override));
  // Initialize state
  MTState mt;
  mt.test = this;
  mt.stop.store(false, std::memory_order_release);
  for (int id = 0; id < kNumThreads; id++) {
    mt.counter[id].store(0, std::memory_order_release);
    mt.thread_done[id].store(false, std::memory_order_release);
  }
6302

6303 6304 6305 6306 6307 6308 6309
  // Start threads
  MTThread thread[kNumThreads];
  for (int id = 0; id < kNumThreads; id++) {
    thread[id].state = &mt;
    thread[id].id = id;
    env_->StartThread(MTThreadBody, &thread[id]);
  }
6310

6311 6312
  // Let them run for a while
  env_->SleepForMicroseconds(kTestSeconds * 1000000);
6313

6314 6315 6316 6317 6318
  // Stop the threads and wait for them to finish
  mt.stop.store(true, std::memory_order_release);
  for (int id = 0; id < kNumThreads; id++) {
    while (mt.thread_done[id].load(std::memory_order_acquire) == false) {
      env_->SleepForMicroseconds(100000);
6319
    }
6320
  }
6321 6322
}

6323 6324 6325 6326
INSTANTIATE_TEST_CASE_P(
    MultiThreaded, MultiThreadedDBTest,
    ::testing::ValuesIn(MultiThreadedDBTest::GenerateOptionConfigs()));

6327 6328 6329 6330 6331 6332 6333 6334 6335 6336 6337 6338 6339 6340 6341 6342 6343 6344 6345
// Group commit test:
namespace {

static const int kGCNumThreads = 4;
static const int kGCNumKeys = 1000;

struct GCThread {
  DB* db;
  int id;
  std::atomic<bool> done;
};

static void GCThreadBody(void* arg) {
  GCThread* t = reinterpret_cast<GCThread*>(arg);
  int id = t->id;
  DB* db = t->db;
  WriteOptions wo;

  for (int i = 0; i < kGCNumKeys; ++i) {
6346
    std::string kv(ToString(i + id * kGCNumKeys));
6347 6348 6349 6350 6351 6352 6353
    ASSERT_OK(db->Put(wo, kv, kv));
  }
  t->done = true;
}

}  // namespace

I
Igor Sugak 已提交
6354
TEST_F(DBTest, GroupCommitTest) {
6355
  do {
6356
    Options options = CurrentOptions();
6357 6358
    options.env = env_;
    env_->log_write_slowdown_.store(100);
6359
    options.statistics = rocksdb::CreateDBStatistics();
L
Lei Jin 已提交
6360
    Reopen(options);
6361

6362 6363 6364 6365 6366 6367 6368 6369 6370 6371 6372 6373 6374 6375
    // Start threads
    GCThread thread[kGCNumThreads];
    for (int id = 0; id < kGCNumThreads; id++) {
      thread[id].id = id;
      thread[id].db = db_;
      thread[id].done = false;
      env_->StartThread(GCThreadBody, &thread[id]);
    }

    for (int id = 0; id < kGCNumThreads; id++) {
      while (thread[id].done == false) {
        env_->SleepForMicroseconds(100000);
      }
    }
6376 6377
    env_->log_write_slowdown_.store(0);

6378
    ASSERT_GT(TestGetTickerCount(options, WRITE_DONE_BY_OTHER), 0);
6379 6380 6381

    std::vector<std::string> expected_db;
    for (int i = 0; i < kGCNumThreads * kGCNumKeys; ++i) {
6382
      expected_db.push_back(ToString(i));
6383 6384 6385 6386 6387 6388 6389 6390 6391 6392 6393 6394
    }
    sort(expected_db.begin(), expected_db.end());

    Iterator* itr = db_->NewIterator(ReadOptions());
    itr->SeekToFirst();
    for (auto x : expected_db) {
      ASSERT_TRUE(itr->Valid());
      ASSERT_EQ(itr->key().ToString(), x);
      ASSERT_EQ(itr->value().ToString(), x);
      itr->Next();
    }
    ASSERT_TRUE(!itr->Valid());
I
Igor Canadi 已提交
6395
    delete itr;
6396

6397 6398 6399
    HistogramData hist_data = {0};
    options.statistics->histogramData(DB_WRITE, &hist_data);
    ASSERT_GT(hist_data.average, 0.0);
6400
  } while (ChangeOptions(kSkipNoSeekToLast));
6401 6402
}

6403 6404 6405 6406
namespace {
typedef std::map<std::string, std::string> KVMap;
}

J
jorlow@chromium.org 已提交
6407 6408
class ModelDB: public DB {
 public:
6409 6410 6411
  class ModelSnapshot : public Snapshot {
   public:
    KVMap map_;
I
Igor Canadi 已提交
6412

I
Igor Sugak 已提交
6413
    virtual SequenceNumber GetSequenceNumber() const override {
I
Igor Canadi 已提交
6414 6415 6416 6417
      // no need to call this
      assert(false);
      return 0;
    }
6418 6419
  };

6420
  explicit ModelDB(const Options& options) : options_(options) {}
6421
  using DB::Put;
6422
  virtual Status Put(const WriteOptions& o, ColumnFamilyHandle* cf,
I
Igor Sugak 已提交
6423
                     const Slice& k, const Slice& v) override {
6424
    WriteBatch batch;
I
Igor Canadi 已提交
6425
    batch.Put(cf, k, v);
6426
    return Write(o, &batch);
6427 6428
  }
  using DB::Merge;
6429
  virtual Status Merge(const WriteOptions& o, ColumnFamilyHandle* cf,
I
Igor Sugak 已提交
6430
                       const Slice& k, const Slice& v) override {
6431
    WriteBatch batch;
I
Igor Canadi 已提交
6432
    batch.Merge(cf, k, v);
6433
    return Write(o, &batch);
6434 6435
  }
  using DB::Delete;
6436
  virtual Status Delete(const WriteOptions& o, ColumnFamilyHandle* cf,
I
Igor Sugak 已提交
6437
                        const Slice& key) override {
6438
    WriteBatch batch;
I
Igor Canadi 已提交
6439
    batch.Delete(cf, key);
6440
    return Write(o, &batch);
6441 6442
  }
  using DB::Get;
6443
  virtual Status Get(const ReadOptions& options, ColumnFamilyHandle* cf,
I
Igor Sugak 已提交
6444
                     const Slice& key, std::string* value) override {
6445 6446 6447
    return Status::NotSupported(key);
  }

6448 6449 6450
  using DB::MultiGet;
  virtual std::vector<Status> MultiGet(
      const ReadOptions& options,
6451
      const std::vector<ColumnFamilyHandle*>& column_family,
I
Igor Sugak 已提交
6452 6453
      const std::vector<Slice>& keys,
      std::vector<std::string>* values) override {
6454 6455 6456
    std::vector<Status> s(keys.size(),
                          Status::NotSupported("Not implemented."));
    return s;
J
jorlow@chromium.org 已提交
6457
  }
6458

I
Igor Canadi 已提交
6459
  using DB::GetPropertiesOfAllTables;
I
Igor Sugak 已提交
6460 6461 6462
  virtual Status GetPropertiesOfAllTables(
      ColumnFamilyHandle* column_family,
      TablePropertiesCollection* props) override {
6463 6464
    return Status();
  }
6465

6466
  using DB::KeyMayExist;
6467
  virtual bool KeyMayExist(const ReadOptions& options,
6468
                           ColumnFamilyHandle* column_family, const Slice& key,
I
Igor Sugak 已提交
6469 6470
                           std::string* value,
                           bool* value_found = nullptr) override {
6471 6472 6473
    if (value_found != nullptr) {
      *value_found = false;
    }
6474 6475
    return true; // Not Supported directly
  }
6476 6477
  using DB::NewIterator;
  virtual Iterator* NewIterator(const ReadOptions& options,
I
Igor Sugak 已提交
6478
                                ColumnFamilyHandle* column_family) override {
A
Abhishek Kona 已提交
6479
    if (options.snapshot == nullptr) {
J
jorlow@chromium.org 已提交
6480 6481 6482 6483 6484
      KVMap* saved = new KVMap;
      *saved = map_;
      return new ModelIter(saved, true);
    } else {
      const KVMap* snapshot_state =
6485
          &(reinterpret_cast<const ModelSnapshot*>(options.snapshot)->map_);
J
jorlow@chromium.org 已提交
6486 6487 6488
      return new ModelIter(snapshot_state, false);
    }
  }
6489 6490
  virtual Status NewIterators(
      const ReadOptions& options,
6491
      const std::vector<ColumnFamilyHandle*>& column_family,
I
Igor Sugak 已提交
6492
      std::vector<Iterator*>* iterators) override {
6493 6494
    return Status::NotSupported("Not supported yet");
  }
I
Igor Sugak 已提交
6495
  virtual const Snapshot* GetSnapshot() override {
6496 6497 6498
    ModelSnapshot* snapshot = new ModelSnapshot;
    snapshot->map_ = map_;
    return snapshot;
J
jorlow@chromium.org 已提交
6499 6500
  }

I
Igor Sugak 已提交
6501
  virtual void ReleaseSnapshot(const Snapshot* snapshot) override {
6502
    delete reinterpret_cast<const ModelSnapshot*>(snapshot);
J
jorlow@chromium.org 已提交
6503
  }
6504

I
Igor Sugak 已提交
6505 6506
  virtual Status Write(const WriteOptions& options,
                       WriteBatch* batch) override {
6507 6508 6509
    class Handler : public WriteBatch::Handler {
     public:
      KVMap* map_;
I
Igor Sugak 已提交
6510
      virtual void Put(const Slice& key, const Slice& value) override {
6511
        (*map_)[key.ToString()] = value.ToString();
J
jorlow@chromium.org 已提交
6512
      }
I
Igor Sugak 已提交
6513
      virtual void Merge(const Slice& key, const Slice& value) override {
6514 6515 6516
        // ignore merge for now
        //(*map_)[key.ToString()] = value.ToString();
      }
I
Igor Sugak 已提交
6517
      virtual void Delete(const Slice& key) override {
6518 6519 6520 6521 6522 6523
        map_->erase(key.ToString());
      }
    };
    Handler handler;
    handler.map_ = &map_;
    return batch->Iterate(&handler);
J
jorlow@chromium.org 已提交
6524 6525
  }

6526
  using DB::GetProperty;
6527
  virtual bool GetProperty(ColumnFamilyHandle* column_family,
I
Igor Sugak 已提交
6528
                           const Slice& property, std::string* value) override {
J
jorlow@chromium.org 已提交
6529 6530
    return false;
  }
6531 6532 6533 6534 6535
  using DB::GetIntProperty;
  virtual bool GetIntProperty(ColumnFamilyHandle* column_family,
                              const Slice& property, uint64_t* value) override {
    return false;
  }
6536
  using DB::GetApproximateSizes;
6537
  virtual void GetApproximateSizes(ColumnFamilyHandle* column_family,
6538 6539
                                   const Range* range, int n, uint64_t* sizes,
                                   bool include_memtable) override {
J
jorlow@chromium.org 已提交
6540 6541 6542 6543
    for (int i = 0; i < n; i++) {
      sizes[i] = 0;
    }
  }
6544
  using DB::CompactRange;
6545 6546 6547
  virtual Status CompactRange(const CompactRangeOptions& options,
                              ColumnFamilyHandle* column_family,
                              const Slice* start, const Slice* end) override {
L
Lei Jin 已提交
6548
    return Status::NotSupported("Not supported operation.");
G
Gabor Cselle 已提交
6549 6550
  }

6551 6552 6553 6554 6555 6556 6557 6558 6559
  using DB::CompactFiles;
  virtual Status CompactFiles(
      const CompactionOptions& compact_options,
      ColumnFamilyHandle* column_family,
      const std::vector<std::string>& input_file_names,
      const int output_level, const int output_path_id = -1) override {
    return Status::NotSupported("Not supported operation.");
  }

6560
  using DB::NumberLevels;
I
Igor Sugak 已提交
6561 6562 6563
  virtual int NumberLevels(ColumnFamilyHandle* column_family) override {
    return 1;
  }
6564

6565
  using DB::MaxMemCompactionLevel;
I
Igor Sugak 已提交
6566 6567
  virtual int MaxMemCompactionLevel(
      ColumnFamilyHandle* column_family) override {
6568
    return 1;
6569 6570
  }

6571
  using DB::Level0StopWriteTrigger;
I
Igor Sugak 已提交
6572 6573
  virtual int Level0StopWriteTrigger(
      ColumnFamilyHandle* column_family) override {
6574
    return -1;
6575 6576
  }

I
Igor Sugak 已提交
6577
  virtual const std::string& GetName() const override { return name_; }
I
Igor Canadi 已提交
6578

I
Igor Sugak 已提交
6579
  virtual Env* GetEnv() const override { return nullptr; }
6580

6581
  using DB::GetOptions;
I
Igor Sugak 已提交
6582 6583
  virtual const Options& GetOptions(
      ColumnFamilyHandle* column_family) const override {
I
Igor Canadi 已提交
6584 6585 6586
    return options_;
  }

6587 6588 6589
  using DB::GetDBOptions;
  virtual const DBOptions& GetDBOptions() const override { return options_; }

6590 6591
  using DB::Flush;
  virtual Status Flush(const rocksdb::FlushOptions& options,
I
Igor Sugak 已提交
6592
                       ColumnFamilyHandle* column_family) override {
H
heyongqiang 已提交
6593 6594 6595 6596
    Status ret;
    return ret;
  }

I
Igor Sugak 已提交
6597 6598
  virtual Status DisableFileDeletions() override { return Status::OK(); }
  virtual Status EnableFileDeletions(bool force) override {
6599 6600
    return Status::OK();
  }
6601
  virtual Status GetLiveFiles(std::vector<std::string>&, uint64_t* size,
I
Igor Sugak 已提交
6602
                              bool flush_memtable = true) override {
6603 6604 6605
    return Status::OK();
  }

I
Igor Sugak 已提交
6606
  virtual Status GetSortedWalFiles(VectorLogPtr& files) override {
6607 6608 6609
    return Status::OK();
  }

I
Igor Sugak 已提交
6610
  virtual Status DeleteFile(std::string name) override { return Status::OK(); }
6611

6612
  virtual Status GetDbIdentity(std::string& identity) const override {
6613 6614 6615
    return Status::OK();
  }

I
Igor Sugak 已提交
6616
  virtual SequenceNumber GetLatestSequenceNumber() const override { return 0; }
6617 6618 6619
  virtual Status GetUpdatesSince(
      rocksdb::SequenceNumber, unique_ptr<rocksdb::TransactionLogIterator>*,
      const TransactionLogIterator::ReadOptions&
I
Igor Sugak 已提交
6620
          read_options = TransactionLogIterator::ReadOptions()) override {
6621 6622 6623
    return Status::NotSupported("Not supported in Model DB");
  }

I
Igor Sugak 已提交
6624 6625 6626
  virtual ColumnFamilyHandle* DefaultColumnFamily() const override {
    return nullptr;
  }
6627

6628 6629
  virtual void GetColumnFamilyMetaData(
      ColumnFamilyHandle* column_family,
I
Igor Sugak 已提交
6630
      ColumnFamilyMetaData* metadata) override {}
6631

J
jorlow@chromium.org 已提交
6632 6633 6634 6635 6636 6637 6638 6639 6640
 private:
  class ModelIter: public Iterator {
   public:
    ModelIter(const KVMap* map, bool owned)
        : map_(map), owned_(owned), iter_(map_->end()) {
    }
    ~ModelIter() {
      if (owned_) delete map_;
    }
I
Igor Sugak 已提交
6641 6642 6643
    virtual bool Valid() const override { return iter_ != map_->end(); }
    virtual void SeekToFirst() override { iter_ = map_->begin(); }
    virtual void SeekToLast() override {
J
jorlow@chromium.org 已提交
6644 6645 6646 6647 6648 6649
      if (map_->empty()) {
        iter_ = map_->end();
      } else {
        iter_ = map_->find(map_->rbegin()->first);
      }
    }
I
Igor Sugak 已提交
6650
    virtual void Seek(const Slice& k) override {
J
jorlow@chromium.org 已提交
6651 6652
      iter_ = map_->lower_bound(k.ToString());
    }
I
Igor Sugak 已提交
6653 6654
    virtual void Next() override { ++iter_; }
    virtual void Prev() override {
S
Stanislau Hlebik 已提交
6655 6656 6657 6658 6659 6660 6661
      if (iter_ == map_->begin()) {
        iter_ = map_->end();
        return;
      }
      --iter_;
    }

I
Igor Sugak 已提交
6662 6663 6664 6665
    virtual Slice key() const override { return iter_->first; }
    virtual Slice value() const override { return iter_->second; }
    virtual Status status() const override { return Status::OK(); }

J
jorlow@chromium.org 已提交
6666 6667 6668 6669 6670 6671 6672
   private:
    const KVMap* const map_;
    const bool owned_;  // Do we own map_
    KVMap::const_iterator iter_;
  };
  const Options options_;
  KVMap map_;
I
Igor Canadi 已提交
6673
  std::string name_ = "";
J
jorlow@chromium.org 已提交
6674 6675
};

J
Jim Paton 已提交
6676 6677 6678 6679 6680 6681 6682
static std::string RandomKey(Random* rnd, int minimum = 0) {
  int len;
  do {
    len = (rnd->OneIn(3)
           ? 1                // Short sometimes to encourage collisions
           : (rnd->OneIn(100) ? rnd->Skewed(10) : rnd->Uniform(10)));
  } while (len < minimum);
J
jorlow@chromium.org 已提交
6683 6684 6685 6686 6687 6688 6689 6690 6691 6692 6693 6694 6695 6696 6697 6698 6699 6700 6701 6702 6703 6704 6705 6706 6707 6708 6709 6710 6711 6712 6713 6714 6715 6716 6717 6718 6719 6720 6721 6722 6723 6724 6725 6726 6727 6728 6729 6730 6731 6732
  return test::RandomKey(rnd, len);
}

static bool CompareIterators(int step,
                             DB* model,
                             DB* db,
                             const Snapshot* model_snap,
                             const Snapshot* db_snap) {
  ReadOptions options;
  options.snapshot = model_snap;
  Iterator* miter = model->NewIterator(options);
  options.snapshot = db_snap;
  Iterator* dbiter = db->NewIterator(options);
  bool ok = true;
  int count = 0;
  for (miter->SeekToFirst(), dbiter->SeekToFirst();
       ok && miter->Valid() && dbiter->Valid();
       miter->Next(), dbiter->Next()) {
    count++;
    if (miter->key().compare(dbiter->key()) != 0) {
      fprintf(stderr, "step %d: Key mismatch: '%s' vs. '%s'\n",
              step,
              EscapeString(miter->key()).c_str(),
              EscapeString(dbiter->key()).c_str());
      ok = false;
      break;
    }

    if (miter->value().compare(dbiter->value()) != 0) {
      fprintf(stderr, "step %d: Value mismatch for key '%s': '%s' vs. '%s'\n",
              step,
              EscapeString(miter->key()).c_str(),
              EscapeString(miter->value()).c_str(),
              EscapeString(miter->value()).c_str());
      ok = false;
    }
  }

  if (ok) {
    if (miter->Valid() != dbiter->Valid()) {
      fprintf(stderr, "step %d: Mismatch at end of iterators: %d vs. %d\n",
              step, miter->Valid(), dbiter->Valid());
      ok = false;
    }
  }
  delete miter;
  delete dbiter;
  return ok;
}

I
Igor Sugak 已提交
6733
TEST_F(DBTest, Randomized) {
6734 6735
  anon::OptionsOverride options_override;
  options_override.skip_policy = kSkipNoSnapshot;
J
jorlow@chromium.org 已提交
6736
  Random rnd(test::RandomSeed());
S
Sanjay Ghemawat 已提交
6737
  do {
6738
    ModelDB model(CurrentOptions(options_override));
S
Sanjay Ghemawat 已提交
6739
    const int N = 10000;
A
Abhishek Kona 已提交
6740 6741
    const Snapshot* model_snap = nullptr;
    const Snapshot* db_snap = nullptr;
S
Sanjay Ghemawat 已提交
6742 6743 6744 6745
    std::string k, v;
    for (int step = 0; step < N; step++) {
      // TODO(sanjay): Test Get() works
      int p = rnd.Uniform(100);
J
Jim Paton 已提交
6746
      int minimum = 0;
6747
      if (option_config_ == kHashSkipList ||
6748
          option_config_ == kHashLinkList ||
6749
          option_config_ == kHashCuckoo ||
6750 6751 6752
          option_config_ == kPlainTableFirstBytePrefix ||
          option_config_ == kBlockBasedTableWithWholeKeyHashIndex ||
          option_config_ == kBlockBasedTableWithPrefixHashIndex) {
J
Jim Paton 已提交
6753 6754
        minimum = 1;
      }
S
Sanjay Ghemawat 已提交
6755
      if (p < 45) {                               // Put
J
Jim Paton 已提交
6756
        k = RandomKey(&rnd, minimum);
S
Sanjay Ghemawat 已提交
6757 6758 6759 6760 6761 6762 6763 6764
        v = RandomString(&rnd,
                         rnd.OneIn(20)
                         ? 100 + rnd.Uniform(100)
                         : rnd.Uniform(8));
        ASSERT_OK(model.Put(WriteOptions(), k, v));
        ASSERT_OK(db_->Put(WriteOptions(), k, v));

      } else if (p < 90) {                        // Delete
J
Jim Paton 已提交
6765
        k = RandomKey(&rnd, minimum);
S
Sanjay Ghemawat 已提交
6766 6767 6768 6769 6770 6771 6772 6773 6774
        ASSERT_OK(model.Delete(WriteOptions(), k));
        ASSERT_OK(db_->Delete(WriteOptions(), k));


      } else {                                    // Multi-element batch
        WriteBatch b;
        const int num = rnd.Uniform(8);
        for (int i = 0; i < num; i++) {
          if (i == 0 || !rnd.OneIn(10)) {
J
Jim Paton 已提交
6775
            k = RandomKey(&rnd, minimum);
S
Sanjay Ghemawat 已提交
6776 6777 6778 6779 6780 6781 6782 6783 6784 6785
          } else {
            // Periodically re-use the same key from the previous iter, so
            // we have multiple entries in the write batch for the same key
          }
          if (rnd.OneIn(2)) {
            v = RandomString(&rnd, rnd.Uniform(10));
            b.Put(k, v);
          } else {
            b.Delete(k);
          }
J
jorlow@chromium.org 已提交
6786
        }
S
Sanjay Ghemawat 已提交
6787 6788
        ASSERT_OK(model.Write(WriteOptions(), &b));
        ASSERT_OK(db_->Write(WriteOptions(), &b));
J
jorlow@chromium.org 已提交
6789 6790
      }

S
Sanjay Ghemawat 已提交
6791
      if ((step % 100) == 0) {
S
Stanislau Hlebik 已提交
6792 6793 6794 6795 6796 6797 6798 6799
        // For DB instances that use the hash index + block-based table, the
        // iterator will be invalid right when seeking a non-existent key, right
        // than return a key that is close to it.
        if (option_config_ != kBlockBasedTableWithWholeKeyHashIndex &&
            option_config_ != kBlockBasedTableWithPrefixHashIndex) {
          ASSERT_TRUE(CompareIterators(step, &model, db_, nullptr, nullptr));
          ASSERT_TRUE(CompareIterators(step, &model, db_, model_snap, db_snap));
        }
6800

S
Sanjay Ghemawat 已提交
6801 6802 6803
        // Save a snapshot from each DB this time that we'll use next
        // time we compare things, to make sure the current state is
        // preserved with the snapshot
A
Abhishek Kona 已提交
6804 6805
        if (model_snap != nullptr) model.ReleaseSnapshot(model_snap);
        if (db_snap != nullptr) db_->ReleaseSnapshot(db_snap);
J
jorlow@chromium.org 已提交
6806

L
Lei Jin 已提交
6807

6808
        auto options = CurrentOptions(options_override);
L
Lei Jin 已提交
6809
        Reopen(options);
A
Abhishek Kona 已提交
6810
        ASSERT_TRUE(CompareIterators(step, &model, db_, nullptr, nullptr));
J
jorlow@chromium.org 已提交
6811

S
Sanjay Ghemawat 已提交
6812 6813 6814
        model_snap = model.GetSnapshot();
        db_snap = db_->GetSnapshot();
      }
S
Stanislau Hlebik 已提交
6815 6816

      if ((step % 2000) == 0) {
6817
        fprintf(stderr,
S
Stanislau Hlebik 已提交
6818 6819 6820
                "DBTest.Randomized, option ID: %d, step: %d out of %d\n",
                option_config_, step, N);
      }
J
jorlow@chromium.org 已提交
6821
    }
A
Abhishek Kona 已提交
6822 6823
    if (model_snap != nullptr) model.ReleaseSnapshot(model_snap);
    if (db_snap != nullptr) db_->ReleaseSnapshot(db_snap);
6824
    // skip cuckoo hash as it does not support snapshot.
S
Stanislau Hlebik 已提交
6825 6826
  } while (ChangeOptions(kSkipDeletesFilterFirst | kSkipNoSeekToLast |
                         kSkipHashCuckoo));
J
jorlow@chromium.org 已提交
6827 6828
}

I
Igor Sugak 已提交
6829
TEST_F(DBTest, MultiGetSimple) {
6830
  do {
L
Lei Jin 已提交
6831
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
6832 6833 6834 6835 6836 6837 6838 6839 6840 6841 6842 6843 6844 6845 6846
    ASSERT_OK(Put(1, "k1", "v1"));
    ASSERT_OK(Put(1, "k2", "v2"));
    ASSERT_OK(Put(1, "k3", "v3"));
    ASSERT_OK(Put(1, "k4", "v4"));
    ASSERT_OK(Delete(1, "k4"));
    ASSERT_OK(Put(1, "k5", "v5"));
    ASSERT_OK(Delete(1, "no_key"));

    std::vector<Slice> keys({"k1", "k2", "k3", "k4", "k5", "no_key"});

    std::vector<std::string> values(20, "Temporary data to be overwritten");
    std::vector<ColumnFamilyHandle*> cfs(keys.size(), handles_[1]);

    std::vector<Status> s = db_->MultiGet(ReadOptions(), cfs, keys, &values);
    ASSERT_EQ(values.size(), keys.size());
6847 6848 6849 6850 6851 6852 6853 6854 6855 6856 6857 6858
    ASSERT_EQ(values[0], "v1");
    ASSERT_EQ(values[1], "v2");
    ASSERT_EQ(values[2], "v3");
    ASSERT_EQ(values[4], "v5");

    ASSERT_OK(s[0]);
    ASSERT_OK(s[1]);
    ASSERT_OK(s[2]);
    ASSERT_TRUE(s[3].IsNotFound());
    ASSERT_OK(s[4]);
    ASSERT_TRUE(s[5].IsNotFound());
  } while (ChangeCompactOptions());
6859 6860
}

I
Igor Sugak 已提交
6861
TEST_F(DBTest, MultiGetEmpty) {
6862
  do {
L
Lei Jin 已提交
6863
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
6864 6865 6866
    // Empty Key Set
    std::vector<Slice> keys;
    std::vector<std::string> values;
6867 6868 6869
    std::vector<ColumnFamilyHandle*> cfs;
    std::vector<Status> s = db_->MultiGet(ReadOptions(), cfs, keys, &values);
    ASSERT_EQ(s.size(), 0U);
6870 6871

    // Empty Database, Empty Key Set
L
Lei Jin 已提交
6872 6873 6874
    Options options = CurrentOptions();
    options.create_if_missing = true;
    DestroyAndReopen(options);
L
Lei Jin 已提交
6875
    CreateAndReopenWithCF({"pikachu"}, options);
6876 6877
    s = db_->MultiGet(ReadOptions(), cfs, keys, &values);
    ASSERT_EQ(s.size(), 0U);
6878 6879 6880 6881 6882

    // Empty Database, Search for Keys
    keys.resize(2);
    keys[0] = "a";
    keys[1] = "b";
6883 6884 6885
    cfs.push_back(handles_[0]);
    cfs.push_back(handles_[1]);
    s = db_->MultiGet(ReadOptions(), cfs, keys, &values);
6886 6887 6888
    ASSERT_EQ((int)s.size(), 2);
    ASSERT_TRUE(s[0].IsNotFound() && s[1].IsNotFound());
  } while (ChangeCompactOptions());
6889 6890
}

I
Igor Canadi 已提交
6891
namespace {
T
Tyler Harter 已提交
6892 6893 6894 6895 6896 6897 6898 6899 6900 6901 6902 6903 6904 6905 6906 6907 6908 6909 6910 6911 6912 6913
void PrefixScanInit(DBTest *dbtest) {
  char buf[100];
  std::string keystr;
  const int small_range_sstfiles = 5;
  const int big_range_sstfiles = 5;

  // Generate 11 sst files with the following prefix ranges.
  // GROUP 0: [0,10]                              (level 1)
  // GROUP 1: [1,2], [2,3], [3,4], [4,5], [5, 6]  (level 0)
  // GROUP 2: [0,6], [0,7], [0,8], [0,9], [0,10]  (level 0)
  //
  // A seek with the previous API would do 11 random I/Os (to all the
  // files).  With the new API and a prefix filter enabled, we should
  // only do 2 random I/O, to the 2 files containing the key.

  // GROUP 0
  snprintf(buf, sizeof(buf), "%02d______:start", 0);
  keystr = std::string(buf);
  ASSERT_OK(dbtest->Put(keystr, keystr));
  snprintf(buf, sizeof(buf), "%02d______:end", 10);
  keystr = std::string(buf);
  ASSERT_OK(dbtest->Put(keystr, keystr));
6914
  dbtest->Flush();
6915 6916
  dbtest->dbfull()->CompactRange(CompactRangeOptions(), nullptr,
                                 nullptr);  // move to level 1
T
Tyler Harter 已提交
6917 6918 6919 6920 6921 6922 6923 6924 6925

  // GROUP 1
  for (int i = 1; i <= small_range_sstfiles; i++) {
    snprintf(buf, sizeof(buf), "%02d______:start", i);
    keystr = std::string(buf);
    ASSERT_OK(dbtest->Put(keystr, keystr));
    snprintf(buf, sizeof(buf), "%02d______:end", i+1);
    keystr = std::string(buf);
    ASSERT_OK(dbtest->Put(keystr, keystr));
6926
    dbtest->Flush();
T
Tyler Harter 已提交
6927 6928 6929 6930 6931 6932 6933 6934 6935 6936 6937
  }

  // GROUP 2
  for (int i = 1; i <= big_range_sstfiles; i++) {
    snprintf(buf, sizeof(buf), "%02d______:start", 0);
    keystr = std::string(buf);
    ASSERT_OK(dbtest->Put(keystr, keystr));
    snprintf(buf, sizeof(buf), "%02d______:end",
             small_range_sstfiles+i+1);
    keystr = std::string(buf);
    ASSERT_OK(dbtest->Put(keystr, keystr));
6938
    dbtest->Flush();
T
Tyler Harter 已提交
6939 6940
  }
}
I
Igor Canadi 已提交
6941
}  // namespace
T
Tyler Harter 已提交
6942

I
Igor Sugak 已提交
6943
TEST_F(DBTest, PrefixScan) {
V
Venkatesh Radhakrishnan 已提交
6944 6945
  XFUNC_TEST("", "dbtest_prefix", prefix_skip1, XFuncPoint::SetSkip,
             kSkipNoPrefix);
6946 6947 6948 6949 6950 6951 6952 6953 6954 6955 6956 6957 6958 6959 6960 6961 6962 6963
  while (ChangeFilterOptions()) {
    int count;
    Slice prefix;
    Slice key;
    char buf[100];
    Iterator* iter;
    snprintf(buf, sizeof(buf), "03______:");
    prefix = Slice(buf, 8);
    key = Slice(buf, 9);
    // db configs
    env_->count_random_reads_ = true;
    Options options = CurrentOptions();
    options.env = env_;
    options.prefix_extractor.reset(NewFixedPrefixTransform(8));
    options.disable_auto_compactions = true;
    options.max_background_compactions = 2;
    options.create_if_missing = true;
    options.memtable_factory.reset(NewHashSkipListRepFactory(16));
T
Tyler Harter 已提交
6964

6965 6966 6967 6968 6969
    BlockBasedTableOptions table_options;
    table_options.no_block_cache = true;
    table_options.filter_policy.reset(NewBloomFilterPolicy(10));
    table_options.whole_key_filtering = false;
    options.table_factory.reset(NewBlockBasedTableFactory(table_options));
6970

6971
    // 11 RAND I/Os
L
Lei Jin 已提交
6972
    DestroyAndReopen(options);
6973 6974 6975 6976 6977 6978 6979 6980 6981
    PrefixScanInit(this);
    count = 0;
    env_->random_read_counter_.Reset();
    iter = db_->NewIterator(ReadOptions());
    for (iter->Seek(prefix); iter->Valid(); iter->Next()) {
      if (! iter->key().starts_with(prefix)) {
        break;
      }
      count++;
T
Tyler Harter 已提交
6982
    }
6983 6984 6985 6986 6987 6988
    ASSERT_OK(iter->status());
    delete iter;
    ASSERT_EQ(count, 2);
    ASSERT_EQ(env_->random_read_counter_.Read(), 2);
    Close();
  }  // end of while
V
Venkatesh Radhakrishnan 已提交
6989
  XFUNC_TEST("", "dbtest_prefix", prefix_skip1, XFuncPoint::SetSkip, 0);
T
Tyler Harter 已提交
6990 6991
}

I
Igor Sugak 已提交
6992
TEST_F(DBTest, BlockBasedTablePrefixIndexTest) {
6993 6994 6995 6996 6997 6998 6999 7000
  // create a DB with block prefix index
  BlockBasedTableOptions table_options;
  Options options = CurrentOptions();
  table_options.index_type = BlockBasedTableOptions::kHashSearch;
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
  options.prefix_extractor.reset(NewFixedPrefixTransform(1));


L
Lei Jin 已提交
7001
  Reopen(options);
7002 7003 7004 7005 7006 7007 7008 7009 7010 7011
  ASSERT_OK(Put("k1", "v1"));
  Flush();
  ASSERT_OK(Put("k2", "v2"));

  // Reopen it without prefix extractor, make sure everything still works.
  // RocksDB should just fall back to the binary index.
  table_options.index_type = BlockBasedTableOptions::kBinarySearch;
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
  options.prefix_extractor.reset();

L
Lei Jin 已提交
7012
  Reopen(options);
7013 7014 7015 7016
  ASSERT_EQ("v1", Get("k1"));
  ASSERT_EQ("v2", Get("k2"));
}

I
Igor Sugak 已提交
7017
TEST_F(DBTest, ChecksumTest) {
I
xxHash  
Igor Canadi 已提交
7018 7019 7020 7021 7022
  BlockBasedTableOptions table_options;
  Options options = CurrentOptions();

  table_options.checksum = kCRC32c;
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
L
Lei Jin 已提交
7023
  Reopen(options);
I
xxHash  
Igor Canadi 已提交
7024 7025 7026 7027 7028 7029
  ASSERT_OK(Put("a", "b"));
  ASSERT_OK(Put("c", "d"));
  ASSERT_OK(Flush());  // table with crc checksum

  table_options.checksum = kxxHash;
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
L
Lei Jin 已提交
7030
  Reopen(options);
I
xxHash  
Igor Canadi 已提交
7031 7032 7033 7034 7035 7036
  ASSERT_OK(Put("e", "f"));
  ASSERT_OK(Put("g", "h"));
  ASSERT_OK(Flush());  // table with xxhash checksum

  table_options.checksum = kCRC32c;
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
L
Lei Jin 已提交
7037
  Reopen(options);
I
xxHash  
Igor Canadi 已提交
7038 7039 7040 7041
  ASSERT_EQ("b", Get("a"));
  ASSERT_EQ("d", Get("c"));
  ASSERT_EQ("f", Get("e"));
  ASSERT_EQ("h", Get("g"));
T
Tomislav Novak 已提交
7042

I
xxHash  
Igor Canadi 已提交
7043 7044
  table_options.checksum = kCRC32c;
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
L
Lei Jin 已提交
7045
  Reopen(options);
I
xxHash  
Igor Canadi 已提交
7046 7047 7048 7049 7050
  ASSERT_EQ("b", Get("a"));
  ASSERT_EQ("d", Get("c"));
  ASSERT_EQ("f", Get("e"));
  ASSERT_EQ("h", Get("g"));
}
I
Igor Canadi 已提交
7051

I
Igor Sugak 已提交
7052
TEST_F(DBTest, FIFOCompactionTest) {
I
Igor Canadi 已提交
7053 7054 7055 7056 7057 7058 7059 7060 7061 7062 7063 7064
  for (int iter = 0; iter < 2; ++iter) {
    // first iteration -- auto compaction
    // second iteration -- manual compaction
    Options options;
    options.compaction_style = kCompactionStyleFIFO;
    options.write_buffer_size = 100 << 10;                             // 100KB
    options.compaction_options_fifo.max_table_files_size = 500 << 10;  // 500KB
    options.compression = kNoCompression;
    options.create_if_missing = true;
    if (iter == 1) {
      options.disable_auto_compactions = true;
    }
7065
    options = CurrentOptions(options);
L
Lei Jin 已提交
7066
    DestroyAndReopen(options);
I
Igor Canadi 已提交
7067 7068 7069 7070

    Random rnd(301);
    for (int i = 0; i < 6; ++i) {
      for (int j = 0; j < 100; ++j) {
7071
        ASSERT_OK(Put(ToString(i * 100 + j), RandomString(&rnd, 1024)));
I
Igor Canadi 已提交
7072 7073
      }
      // flush should happen here
7074
      ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
I
Igor Canadi 已提交
7075 7076 7077 7078
    }
    if (iter == 0) {
      ASSERT_OK(dbfull()->TEST_WaitForCompact());
    } else {
7079
      ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
I
Igor Canadi 已提交
7080 7081 7082 7083 7084
    }
    // only 5 files should survive
    ASSERT_EQ(NumTableFilesAtLevel(0), 5);
    for (int i = 0; i < 50; ++i) {
      // these keys should be deleted in previous compaction
7085
      ASSERT_EQ("NOT_FOUND", Get(ToString(i)));
I
Igor Canadi 已提交
7086 7087 7088
    }
  }
}
7089

7090
// verify that we correctly deprecated timeout_hint_us
I
Igor Sugak 已提交
7091
TEST_F(DBTest, SimpleWriteTimeoutTest) {
L
Lei Jin 已提交
7092
  WriteOptions write_opt;
7093
  write_opt.timeout_hint_us = 0;
7094 7095 7096
  ASSERT_OK(Put(Key(1), Key(1) + std::string(100, 'v'), write_opt));
  write_opt.timeout_hint_us = 10;
  ASSERT_NOK(Put(Key(1), Key(1) + std::string(100, 'v'), write_opt));
7097 7098
}

L
Lei Jin 已提交
7099 7100
/*
 * This test is not reliable enough as it heavily depends on disk behavior.
L
Lei Jin 已提交
7101
 */
I
Igor Sugak 已提交
7102
TEST_F(DBTest, RateLimitingTest) {
L
Lei Jin 已提交
7103
  Options options = CurrentOptions();
L
Lei Jin 已提交
7104 7105 7106 7107 7108
  options.write_buffer_size = 1 << 20;         // 1MB
  options.level0_file_num_compaction_trigger = 2;
  options.target_file_size_base = 1 << 20;     // 1MB
  options.max_bytes_for_level_base = 4 << 20;  // 4MB
  options.max_bytes_for_level_multiplier = 4;
L
Lei Jin 已提交
7109 7110 7111
  options.compression = kNoCompression;
  options.create_if_missing = true;
  options.env = env_;
L
Lei Jin 已提交
7112
  options.IncreaseParallelism(4);
L
Lei Jin 已提交
7113
  DestroyAndReopen(options);
L
Lei Jin 已提交
7114

L
Lei Jin 已提交
7115 7116 7117
  WriteOptions wo;
  wo.disableWAL = true;

L
Lei Jin 已提交
7118 7119 7120
  // # no rate limiting
  Random rnd(301);
  uint64_t start = env_->NowMicros();
L
Lei Jin 已提交
7121 7122 7123 7124
  // Write ~96M data
  for (int64_t i = 0; i < (96 << 10); ++i) {
    ASSERT_OK(Put(RandomString(&rnd, 32),
                  RandomString(&rnd, (1 << 10) + 1), wo));
L
Lei Jin 已提交
7125 7126 7127 7128 7129 7130 7131
  }
  uint64_t elapsed = env_->NowMicros() - start;
  double raw_rate = env_->bytes_written_ * 1000000 / elapsed;
  Close();

  // # rate limiting with 0.7 x threshold
  options.rate_limiter.reset(
L
Lei Jin 已提交
7132
    NewGenericRateLimiter(static_cast<int64_t>(0.7 * raw_rate)));
L
Lei Jin 已提交
7133
  env_->bytes_written_ = 0;
L
Lei Jin 已提交
7134
  DestroyAndReopen(options);
L
Lei Jin 已提交
7135 7136

  start = env_->NowMicros();
L
Lei Jin 已提交
7137 7138 7139 7140
  // Write ~96M data
  for (int64_t i = 0; i < (96 << 10); ++i) {
    ASSERT_OK(Put(RandomString(&rnd, 32),
                  RandomString(&rnd, (1 << 10) + 1), wo));
L
Lei Jin 已提交
7141 7142 7143 7144 7145 7146 7147
  }
  elapsed = env_->NowMicros() - start;
  Close();
  ASSERT_TRUE(options.rate_limiter->GetTotalBytesThrough() ==
              env_->bytes_written_);
  double ratio = env_->bytes_written_ * 1000000 / elapsed / raw_rate;
  fprintf(stderr, "write rate ratio = %.2lf, expected 0.7\n", ratio);
L
Lei Jin 已提交
7148
  ASSERT_TRUE(ratio < 0.8);
L
Lei Jin 已提交
7149 7150 7151

  // # rate limiting with half of the raw_rate
  options.rate_limiter.reset(
L
Lei Jin 已提交
7152
    NewGenericRateLimiter(static_cast<int64_t>(raw_rate / 2)));
L
Lei Jin 已提交
7153
  env_->bytes_written_ = 0;
L
Lei Jin 已提交
7154
  DestroyAndReopen(options);
L
Lei Jin 已提交
7155 7156

  start = env_->NowMicros();
L
Lei Jin 已提交
7157 7158 7159 7160
  // Write ~96M data
  for (int64_t i = 0; i < (96 << 10); ++i) {
    ASSERT_OK(Put(RandomString(&rnd, 32),
                  RandomString(&rnd, (1 << 10) + 1), wo));
L
Lei Jin 已提交
7161 7162 7163 7164 7165 7166 7167
  }
  elapsed = env_->NowMicros() - start;
  Close();
  ASSERT_TRUE(options.rate_limiter->GetTotalBytesThrough() ==
              env_->bytes_written_);
  ratio = env_->bytes_written_ * 1000000 / elapsed / raw_rate;
  fprintf(stderr, "write rate ratio = %.2lf, expected 0.5\n", ratio);
L
Lei Jin 已提交
7168
  ASSERT_TRUE(ratio < 0.6);
L
Lei Jin 已提交
7169 7170
}

7171 7172 7173 7174 7175 7176 7177 7178 7179 7180 7181 7182 7183 7184 7185 7186 7187 7188 7189 7190 7191 7192 7193 7194 7195 7196 7197 7198 7199 7200 7201 7202 7203 7204 7205 7206 7207 7208 7209 7210 7211 7212 7213 7214 7215 7216 7217 7218 7219 7220 7221 7222
namespace {
  bool HaveOverlappingKeyRanges(
      const Comparator* c,
      const SstFileMetaData& a, const SstFileMetaData& b) {
    if (c->Compare(a.smallestkey, b.smallestkey) >= 0) {
      if (c->Compare(a.smallestkey, b.largestkey) <= 0) {
        // b.smallestkey <= a.smallestkey <= b.largestkey
        return true;
      }
    } else if (c->Compare(a.largestkey, b.smallestkey) >= 0) {
      // a.smallestkey < b.smallestkey <= a.largestkey
      return true;
    }
    if (c->Compare(a.largestkey, b.largestkey) <= 0) {
      if (c->Compare(a.largestkey, b.smallestkey) >= 0) {
        // b.smallestkey <= a.largestkey <= b.largestkey
        return true;
      }
    } else if (c->Compare(a.smallestkey, b.largestkey) <= 0) {
      // a.smallestkey <= b.largestkey < a.largestkey
      return true;
    }
    return false;
  }

  // Identifies all files between level "min_level" and "max_level"
  // which has overlapping key range with "input_file_meta".
  void GetOverlappingFileNumbersForLevelCompaction(
      const ColumnFamilyMetaData& cf_meta,
      const Comparator* comparator,
      int min_level, int max_level,
      const SstFileMetaData* input_file_meta,
      std::set<std::string>* overlapping_file_names) {
    std::set<const SstFileMetaData*> overlapping_files;
    overlapping_files.insert(input_file_meta);
    for (int m = min_level; m <= max_level; ++m) {
      for (auto& file : cf_meta.levels[m].files) {
        for (auto* included_file : overlapping_files) {
          if (HaveOverlappingKeyRanges(
                  comparator, *included_file, file)) {
            overlapping_files.insert(&file);
            overlapping_file_names->insert(file.name);
            break;
          }
        }
      }
    }
  }

  void VerifyCompactionResult(
      const ColumnFamilyMetaData& cf_meta,
      const std::set<std::string>& overlapping_file_numbers) {
C
Chris BeHanna 已提交
7223
#ifndef NDEBUG
7224 7225 7226 7227 7228 7229
    for (auto& level : cf_meta.levels) {
      for (auto& file : level.files) {
        assert(overlapping_file_numbers.find(file.name) ==
               overlapping_file_numbers.end());
      }
    }
C
Chris BeHanna 已提交
7230
#endif
7231 7232 7233 7234 7235 7236 7237 7238 7239 7240 7241 7242 7243 7244 7245 7246 7247 7248 7249 7250 7251 7252 7253
  }

  const SstFileMetaData* PickFileRandomly(
      const ColumnFamilyMetaData& cf_meta,
      Random* rand,
      int* level = nullptr) {
    auto file_id = rand->Uniform(static_cast<int>(
        cf_meta.file_count)) + 1;
    for (auto& level_meta : cf_meta.levels) {
      if (file_id <= level_meta.files.size()) {
        if (level != nullptr) {
          *level = level_meta.level;
        }
        auto result = rand->Uniform(file_id);
        return &(level_meta.files[result]);
      }
      file_id -= level_meta.files.size();
    }
    assert(false);
    return nullptr;
  }
}  // namespace

7254 7255
// TODO t6534343 -- Don't run two level 0 CompactFiles concurrently
TEST_F(DBTest, DISABLED_CompactFilesOnLevelCompaction) {
7256 7257 7258
  const int kTestKeySize = 16;
  const int kTestValueSize = 984;
  const int kEntrySize = kTestKeySize + kTestValueSize;
7259 7260 7261 7262 7263 7264 7265 7266 7267 7268 7269 7270 7271 7272 7273
  const int kEntriesPerBuffer = 100;
  Options options;
  options.create_if_missing = true;
  options.write_buffer_size = kEntrySize * kEntriesPerBuffer;
  options.compaction_style = kCompactionStyleLevel;
  options.target_file_size_base = options.write_buffer_size;
  options.max_bytes_for_level_base = options.target_file_size_base * 2;
  options.level0_stop_writes_trigger = 2;
  options.max_bytes_for_level_multiplier = 2;
  options.compression = kNoCompression;
  options = CurrentOptions(options);
  CreateAndReopenWithCF({"pikachu"}, options);

  Random rnd(301);
  for (int key = 64 * kEntriesPerBuffer; key >= 0; --key) {
7274
    ASSERT_OK(Put(1, ToString(key), RandomString(&rnd, kTestValueSize)));
7275 7276 7277 7278 7279 7280
  }
  dbfull()->TEST_WaitForFlushMemTable(handles_[1]);
  dbfull()->TEST_WaitForCompact();

  ColumnFamilyMetaData cf_meta;
  dbfull()->GetColumnFamilyMetaData(handles_[1], &cf_meta);
7281
  int output_level = static_cast<int>(cf_meta.levels.size()) - 1;
7282 7283 7284 7285 7286 7287 7288 7289 7290 7291 7292 7293 7294 7295 7296 7297 7298 7299 7300 7301 7302 7303 7304 7305
  for (int file_picked = 5; file_picked > 0; --file_picked) {
    std::set<std::string> overlapping_file_names;
    std::vector<std::string> compaction_input_file_names;
    for (int f = 0; f < file_picked; ++f) {
      int level;
      auto file_meta = PickFileRandomly(cf_meta, &rnd, &level);
      compaction_input_file_names.push_back(file_meta->name);
      GetOverlappingFileNumbersForLevelCompaction(
          cf_meta, options.comparator, level, output_level,
          file_meta, &overlapping_file_names);
    }

    ASSERT_OK(dbfull()->CompactFiles(
        CompactionOptions(), handles_[1],
        compaction_input_file_names,
        output_level));

    // Make sure all overlapping files do not exist after compaction
    dbfull()->GetColumnFamilyMetaData(handles_[1], &cf_meta);
    VerifyCompactionResult(cf_meta, overlapping_file_names);
  }

  // make sure all key-values are still there.
  for (int key = 64 * kEntriesPerBuffer; key >= 0; --key) {
7306
    ASSERT_NE(Get(1, ToString(key)), "NOT_FOUND");
7307 7308 7309
  }
}

I
Igor Sugak 已提交
7310
TEST_F(DBTest, CompactFilesOnUniversalCompaction) {
7311 7312 7313
  const int kTestKeySize = 16;
  const int kTestValueSize = 984;
  const int kEntrySize = kTestKeySize + kTestValueSize;
7314 7315 7316 7317 7318 7319 7320
  const int kEntriesPerBuffer = 10;

  ChangeCompactOptions();
  Options options;
  options.create_if_missing = true;
  options.write_buffer_size = kEntrySize * kEntriesPerBuffer;
  options.compaction_style = kCompactionStyleLevel;
S
sdong 已提交
7321
  options.num_levels = 1;
7322 7323 7324 7325 7326 7327 7328
  options.target_file_size_base = options.write_buffer_size;
  options.compression = kNoCompression;
  options = CurrentOptions(options);
  CreateAndReopenWithCF({"pikachu"}, options);
  ASSERT_EQ(options.compaction_style, kCompactionStyleUniversal);
  Random rnd(301);
  for (int key = 1024 * kEntriesPerBuffer; key >= 0; --key) {
7329
    ASSERT_OK(Put(1, ToString(key), RandomString(&rnd, kTestValueSize)));
7330 7331 7332 7333 7334 7335 7336 7337 7338 7339 7340 7341 7342 7343 7344 7345 7346 7347 7348 7349 7350 7351 7352 7353 7354 7355 7356 7357 7358 7359 7360 7361 7362 7363 7364 7365 7366 7367 7368 7369 7370 7371 7372 7373 7374 7375 7376 7377 7378 7379
  }
  dbfull()->TEST_WaitForFlushMemTable(handles_[1]);
  dbfull()->TEST_WaitForCompact();
  ColumnFamilyMetaData cf_meta;
  dbfull()->GetColumnFamilyMetaData(handles_[1], &cf_meta);
  std::vector<std::string> compaction_input_file_names;
  for (auto file : cf_meta.levels[0].files) {
    if (rnd.OneIn(2)) {
      compaction_input_file_names.push_back(file.name);
    }
  }

  if (compaction_input_file_names.size() == 0) {
    compaction_input_file_names.push_back(
        cf_meta.levels[0].files[0].name);
  }

  // expect fail since universal compaction only allow L0 output
  ASSERT_TRUE(!dbfull()->CompactFiles(
      CompactionOptions(), handles_[1],
      compaction_input_file_names, 1).ok());

  // expect ok and verify the compacted files no longer exist.
  ASSERT_OK(dbfull()->CompactFiles(
      CompactionOptions(), handles_[1],
      compaction_input_file_names, 0));

  dbfull()->GetColumnFamilyMetaData(handles_[1], &cf_meta);
  VerifyCompactionResult(
      cf_meta,
      std::set<std::string>(compaction_input_file_names.begin(),
          compaction_input_file_names.end()));

  compaction_input_file_names.clear();

  // Pick the first and the last file, expect everything is
  // compacted into one single file.
  compaction_input_file_names.push_back(
      cf_meta.levels[0].files[0].name);
  compaction_input_file_names.push_back(
      cf_meta.levels[0].files[
          cf_meta.levels[0].files.size() - 1].name);
  ASSERT_OK(dbfull()->CompactFiles(
      CompactionOptions(), handles_[1],
      compaction_input_file_names, 0));

  dbfull()->GetColumnFamilyMetaData(handles_[1], &cf_meta);
  ASSERT_EQ(cf_meta.levels[0].files.size(), 1U);
}

I
Igor Sugak 已提交
7380
TEST_F(DBTest, TableOptionsSanitizeTest) {
7381 7382
  Options options = CurrentOptions();
  options.create_if_missing = true;
L
Lei Jin 已提交
7383
  DestroyAndReopen(options);
7384 7385 7386 7387
  ASSERT_EQ(db_->GetOptions().allow_mmap_reads, false);

  options.table_factory.reset(new PlainTableFactory());
  options.prefix_extractor.reset(NewNoopTransform());
L
Lei Jin 已提交
7388
  Destroy(options);
L
Lei Jin 已提交
7389
  ASSERT_TRUE(TryReopen(options).IsNotSupported());
7390 7391 7392 7393 7394

  // Test for check of prefix_extractor when hash index is used for
  // block-based table
  BlockBasedTableOptions to;
  to.index_type = BlockBasedTableOptions::kHashSearch;
7395
  options = CurrentOptions();
7396 7397
  options.create_if_missing = true;
  options.table_factory.reset(NewBlockBasedTableFactory(to));
L
Lei Jin 已提交
7398
  ASSERT_TRUE(TryReopen(options).IsInvalidArgument());
7399
  options.prefix_extractor.reset(NewFixedPrefixTransform(1));
L
Lei Jin 已提交
7400
  ASSERT_OK(TryReopen(options));
7401 7402
}

I
Igor Sugak 已提交
7403
TEST_F(DBTest, SanitizeNumThreads) {
7404 7405 7406 7407 7408 7409 7410 7411 7412 7413 7414 7415 7416 7417 7418 7419 7420 7421 7422 7423 7424 7425 7426 7427 7428 7429 7430 7431 7432 7433 7434 7435 7436 7437 7438 7439 7440 7441
  for (int attempt = 0; attempt < 2; attempt++) {
    const size_t kTotalTasks = 8;
    SleepingBackgroundTask sleeping_tasks[kTotalTasks];

    Options options = CurrentOptions();
    if (attempt == 0) {
      options.max_background_compactions = 3;
      options.max_background_flushes = 2;
    }
    options.create_if_missing = true;
    DestroyAndReopen(options);

    for (size_t i = 0; i < kTotalTasks; i++) {
      // Insert 5 tasks to low priority queue and 5 tasks to high priority queue
      env_->Schedule(&SleepingBackgroundTask::DoSleepTask, &sleeping_tasks[i],
                     (i < 4) ? Env::Priority::LOW : Env::Priority::HIGH);
    }

    // Wait 100 milliseconds for they are scheduled.
    env_->SleepForMicroseconds(100000);

    // pool size 3, total task 4. Queue size should be 1.
    ASSERT_EQ(1U, options.env->GetThreadPoolQueueLen(Env::Priority::LOW));
    // pool size 2, total task 4. Queue size should be 2.
    ASSERT_EQ(2U, options.env->GetThreadPoolQueueLen(Env::Priority::HIGH));

    for (size_t i = 0; i < kTotalTasks; i++) {
      sleeping_tasks[i].WakeUp();
      sleeping_tasks[i].WaitUntilDone();
    }

    ASSERT_OK(Put("abc", "def"));
    ASSERT_EQ("def", Get("abc"));
    Flush();
    ASSERT_EQ("def", Get("abc"));
  }
}

I
Igor Sugak 已提交
7442
TEST_F(DBTest, DBIteratorBoundTest) {
7443
  Options options = CurrentOptions();
7444 7445 7446 7447
  options.env = env_;
  options.create_if_missing = true;

  options.prefix_extractor = nullptr;
L
Lei Jin 已提交
7448
  DestroyAndReopen(options);
7449 7450 7451 7452 7453 7454 7455 7456 7457 7458 7459 7460 7461 7462 7463 7464 7465 7466 7467 7468 7469 7470 7471 7472 7473 7474 7475 7476 7477 7478 7479
  ASSERT_OK(Put("a", "0"));
  ASSERT_OK(Put("foo", "bar"));
  ASSERT_OK(Put("foo1", "bar1"));
  ASSERT_OK(Put("g1", "0"));

  // testing basic case with no iterate_upper_bound and no prefix_extractor
  {
    ReadOptions ro;
    ro.iterate_upper_bound = nullptr;

    std::unique_ptr<Iterator> iter(db_->NewIterator(ro));

    iter->Seek("foo");

    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ(iter->key().compare(Slice("foo")), 0);

    iter->Next();
    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ(iter->key().compare(Slice("foo1")), 0);

    iter->Next();
    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ(iter->key().compare(Slice("g1")), 0);
  }

  // testing iterate_upper_bound and forward iterator
  // to make sure it stops at bound
  {
    ReadOptions ro;
    // iterate_upper_bound points beyond the last expected entry
7480 7481
    Slice prefix("foo2");
    ro.iterate_upper_bound = &prefix;
7482 7483 7484 7485 7486 7487 7488 7489 7490 7491 7492 7493 7494 7495 7496 7497

    std::unique_ptr<Iterator> iter(db_->NewIterator(ro));

    iter->Seek("foo");

    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ(iter->key().compare(Slice("foo")), 0);

    iter->Next();
    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ(iter->key().compare(("foo1")), 0);

    iter->Next();
    // should stop here...
    ASSERT_TRUE(!iter->Valid());
  }
7498 7499 7500 7501 7502 7503 7504 7505 7506 7507 7508 7509 7510
  // Testing SeekToLast with iterate_upper_bound set
  {
    ReadOptions ro;

    Slice prefix("foo");
    ro.iterate_upper_bound = &prefix;

    std::unique_ptr<Iterator> iter(db_->NewIterator(ro));

    iter->SeekToLast();
    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ(iter->key().compare(Slice("a")), 0);
  }
7511 7512 7513 7514

  // prefix is the first letter of the key
  options.prefix_extractor.reset(NewFixedPrefixTransform(1));

L
Lei Jin 已提交
7515
  DestroyAndReopen(options);
7516 7517 7518 7519 7520 7521 7522 7523 7524 7525
  ASSERT_OK(Put("a", "0"));
  ASSERT_OK(Put("foo", "bar"));
  ASSERT_OK(Put("foo1", "bar1"));
  ASSERT_OK(Put("g1", "0"));

  // testing with iterate_upper_bound and prefix_extractor
  // Seek target and iterate_upper_bound are not is same prefix
  // This should be an error
  {
    ReadOptions ro;
7526 7527
    Slice prefix("g1");
    ro.iterate_upper_bound = &prefix;
7528 7529 7530 7531 7532 7533 7534 7535 7536 7537 7538 7539 7540

    std::unique_ptr<Iterator> iter(db_->NewIterator(ro));

    iter->Seek("foo");

    ASSERT_TRUE(!iter->Valid());
    ASSERT_TRUE(iter->status().IsInvalidArgument());
  }

  // testing that iterate_upper_bound prevents iterating over deleted items
  // if the bound has already reached
  {
    options.prefix_extractor = nullptr;
L
Lei Jin 已提交
7541
    DestroyAndReopen(options);
7542 7543 7544 7545 7546 7547 7548 7549 7550 7551 7552 7553 7554 7555 7556 7557 7558 7559 7560 7561 7562 7563 7564 7565 7566 7567 7568 7569 7570 7571
    ASSERT_OK(Put("a", "0"));
    ASSERT_OK(Put("b", "0"));
    ASSERT_OK(Put("b1", "0"));
    ASSERT_OK(Put("c", "0"));
    ASSERT_OK(Put("d", "0"));
    ASSERT_OK(Put("e", "0"));
    ASSERT_OK(Delete("c"));
    ASSERT_OK(Delete("d"));

    // base case with no bound
    ReadOptions ro;
    ro.iterate_upper_bound = nullptr;

    std::unique_ptr<Iterator> iter(db_->NewIterator(ro));

    iter->Seek("b");
    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ(iter->key().compare(Slice("b")), 0);

    iter->Next();
    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ(iter->key().compare(("b1")), 0);

    perf_context.Reset();
    iter->Next();

    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ(static_cast<int>(perf_context.internal_delete_skipped_count), 2);

    // now testing with iterate_bound
7572 7573
    Slice prefix("c");
    ro.iterate_upper_bound = &prefix;
7574 7575 7576 7577 7578 7579 7580 7581 7582 7583 7584 7585 7586 7587 7588 7589 7590 7591 7592 7593 7594 7595

    iter.reset(db_->NewIterator(ro));

    perf_context.Reset();

    iter->Seek("b");
    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ(iter->key().compare(Slice("b")), 0);

    iter->Next();
    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ(iter->key().compare(("b1")), 0);

    iter->Next();
    // the iteration should stop as soon as the the bound key is reached
    // even though the key is deleted
    // hence internal_delete_skipped_count should be 0
    ASSERT_TRUE(!iter->Valid());
    ASSERT_EQ(static_cast<int>(perf_context.internal_delete_skipped_count), 0);
  }
}

I
Igor Sugak 已提交
7596
TEST_F(DBTest, WriteSingleThreadEntry) {
7597 7598 7599 7600 7601 7602 7603 7604 7605 7606 7607 7608 7609 7610 7611 7612 7613
  std::vector<std::thread> threads;
  dbfull()->TEST_LockMutex();
  auto w = dbfull()->TEST_BeginWrite();
  threads.emplace_back([&] { Put("a", "b"); });
  env_->SleepForMicroseconds(10000);
  threads.emplace_back([&] { Flush(); });
  env_->SleepForMicroseconds(10000);
  dbfull()->TEST_UnlockMutex();
  dbfull()->TEST_LockMutex();
  dbfull()->TEST_EndWrite(w);
  dbfull()->TEST_UnlockMutex();

  for (auto& t : threads) {
    t.join();
  }
}

I
Igor Sugak 已提交
7614
TEST_F(DBTest, DisableDataSyncTest) {
S
sdong 已提交
7615
  env_->sync_counter_.store(0);
7616 7617 7618 7619 7620 7621 7622
  // iter 0 -- no sync
  // iter 1 -- sync
  for (int iter = 0; iter < 2; ++iter) {
    Options options = CurrentOptions();
    options.disableDataSync = iter == 0;
    options.create_if_missing = true;
    options.env = env_;
L
Lei Jin 已提交
7623
    Reopen(options);
L
Lei Jin 已提交
7624
    CreateAndReopenWithCF({"pikachu"}, options);
7625 7626 7627 7628 7629 7630 7631 7632 7633

    MakeTables(10, "a", "z");
    Compact("a", "z");

    if (iter == 0) {
      ASSERT_EQ(env_->sync_counter_.load(), 0);
    } else {
      ASSERT_GT(env_->sync_counter_.load(), 0);
    }
L
Lei Jin 已提交
7634
    Destroy(options);
7635 7636
  }
}
7637

I
Igor Sugak 已提交
7638
TEST_F(DBTest, DynamicMemtableOptions) {
L
Lei Jin 已提交
7639 7640 7641 7642 7643 7644 7645
  const uint64_t k64KB = 1 << 16;
  const uint64_t k128KB = 1 << 17;
  const uint64_t k5KB = 5 * 1024;
  Options options;
  options.env = env_;
  options.create_if_missing = true;
  options.compression = kNoCompression;
7646
  options.max_background_compactions = 1;
L
Lei Jin 已提交
7647 7648 7649 7650 7651 7652 7653
  options.max_mem_compaction_level = 0;
  options.write_buffer_size = k64KB;
  options.max_write_buffer_number = 2;
  // Don't trigger compact/slowdown/stop
  options.level0_file_num_compaction_trigger = 1024;
  options.level0_slowdown_writes_trigger = 1024;
  options.level0_stop_writes_trigger = 1024;
L
Lei Jin 已提交
7654
  DestroyAndReopen(options);
L
Lei Jin 已提交
7655 7656 7657 7658

  auto gen_l0_kb = [this](int size) {
    Random rnd(301);
    for (int i = 0; i < size; i++) {
L
Lei Jin 已提交
7659
      ASSERT_OK(Put(Key(i), RandomString(&rnd, 1024)));
L
Lei Jin 已提交
7660 7661 7662 7663
    }
    dbfull()->TEST_WaitForFlushMemTable();
  };

L
Lei Jin 已提交
7664
  // Test write_buffer_size
L
Lei Jin 已提交
7665 7666
  gen_l0_kb(64);
  ASSERT_EQ(NumTableFilesAtLevel(0), 1);
7667 7668
  ASSERT_LT(SizeAtLevel(0), k64KB + k5KB);
  ASSERT_GT(SizeAtLevel(0), k64KB - k5KB);
L
Lei Jin 已提交
7669 7670

  // Clean up L0
7671
  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
L
Lei Jin 已提交
7672 7673 7674
  ASSERT_EQ(NumTableFilesAtLevel(0), 0);

  // Increase buffer size
7675
  ASSERT_OK(dbfull()->SetOptions({
L
Lei Jin 已提交
7676 7677 7678 7679 7680 7681 7682 7683
    {"write_buffer_size", "131072"},
  }));

  // The existing memtable is still 64KB in size, after it becomes immutable,
  // the next memtable will be 128KB in size. Write 256KB total, we should
  // have a 64KB L0 file, a 128KB L0 file, and a memtable with 64KB data
  gen_l0_kb(256);
  ASSERT_EQ(NumTableFilesAtLevel(0), 2);
7684 7685
  ASSERT_LT(SizeAtLevel(0), k128KB + k64KB + 2 * k5KB);
  ASSERT_GT(SizeAtLevel(0), k128KB + k64KB - 2 * k5KB);
L
Lei Jin 已提交
7686 7687 7688 7689 7690 7691

  // Test max_write_buffer_number
  // Block compaction thread, which will also block the flushes because
  // max_background_flushes == 0, so flushes are getting executed by the
  // compaction thread
  env_->SetBackgroundThreads(1, Env::LOW);
7692 7693
  SleepingBackgroundTask sleeping_task_low;
  env_->Schedule(&SleepingBackgroundTask::DoSleepTask, &sleeping_task_low,
L
Lei Jin 已提交
7694 7695 7696 7697 7698
                 Env::Priority::LOW);
  // Start from scratch and disable compaction/flush. Flush can only happen
  // during compaction but trigger is pretty high
  options.max_background_flushes = 0;
  options.disable_auto_compactions = true;
L
Lei Jin 已提交
7699
  DestroyAndReopen(options);
L
Lei Jin 已提交
7700

7701 7702
  // Put until writes are stopped, bounded by 256 puts. We should see stop at
  // ~128KB
L
Lei Jin 已提交
7703 7704
  int count = 0;
  Random rnd(301);
S
sdong 已提交
7705 7706

  rocksdb::SyncPoint::GetInstance()->SetCallBack(
7707 7708
      "DBImpl::DelayWrite:Wait",
      [&](void* arg) { sleeping_task_low.WakeUp(); });
S
sdong 已提交
7709
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
L
Lei Jin 已提交
7710

7711 7712
  while (!sleeping_task_low.WokenUp() && count < 256) {
    ASSERT_OK(Put(Key(count), RandomString(&rnd, 1024), WriteOptions()));
L
Lei Jin 已提交
7713 7714
    count++;
  }
7715 7716
  ASSERT_GT(static_cast<double>(count), 128 * 0.8);
  ASSERT_LT(static_cast<double>(count), 128 * 1.2);
L
Lei Jin 已提交
7717

7718
  sleeping_task_low.WaitUntilDone();
L
Lei Jin 已提交
7719 7720

  // Increase
7721
  ASSERT_OK(dbfull()->SetOptions({
L
Lei Jin 已提交
7722 7723 7724
    {"max_write_buffer_number", "8"},
  }));
  // Clean up memtable and L0
7725
  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
L
Lei Jin 已提交
7726

7727 7728
  sleeping_task_low.Reset();
  env_->Schedule(&SleepingBackgroundTask::DoSleepTask, &sleeping_task_low,
L
Lei Jin 已提交
7729 7730
                 Env::Priority::LOW);
  count = 0;
7731 7732
  while (!sleeping_task_low.WokenUp() && count < 1024) {
    ASSERT_OK(Put(Key(count), RandomString(&rnd, 1024), WriteOptions()));
L
Lei Jin 已提交
7733 7734
    count++;
  }
7735 7736
  // Windows fails this test. Will tune in the future and figure out
  // approp number
D
Dmitri Smirnov 已提交
7737
#ifndef OS_WIN
7738 7739
  ASSERT_GT(static_cast<double>(count), 512 * 0.8);
  ASSERT_LT(static_cast<double>(count), 512 * 1.2);
D
Dmitri Smirnov 已提交
7740
#endif
7741
  sleeping_task_low.WaitUntilDone();
L
Lei Jin 已提交
7742 7743

  // Decrease
7744
  ASSERT_OK(dbfull()->SetOptions({
L
Lei Jin 已提交
7745 7746 7747
    {"max_write_buffer_number", "4"},
  }));
  // Clean up memtable and L0
7748
  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
L
Lei Jin 已提交
7749

7750 7751
  sleeping_task_low.Reset();
  env_->Schedule(&SleepingBackgroundTask::DoSleepTask, &sleeping_task_low,
L
Lei Jin 已提交
7752
                 Env::Priority::LOW);
S
sdong 已提交
7753

L
Lei Jin 已提交
7754
  count = 0;
7755 7756
  while (!sleeping_task_low.WokenUp() && count < 1024) {
    ASSERT_OK(Put(Key(count), RandomString(&rnd, 1024), WriteOptions()));
L
Lei Jin 已提交
7757 7758
    count++;
  }
7759 7760
  // Windows fails this test. Will tune in the future and figure out
  // approp number
D
Dmitri Smirnov 已提交
7761
#ifndef OS_WIN
7762 7763
  ASSERT_GT(static_cast<double>(count), 256 * 0.8);
  ASSERT_LT(static_cast<double>(count), 266 * 1.2);
D
Dmitri Smirnov 已提交
7764
#endif
7765
  sleeping_task_low.WaitUntilDone();
S
sdong 已提交
7766 7767

  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
L
Lei Jin 已提交
7768 7769
}

Y
Yueh-Hsuan Chiang 已提交
7770
#if ROCKSDB_USING_THREAD_STATUS
7771 7772 7773 7774 7775 7776 7777 7778 7779 7780 7781 7782 7783 7784 7785
namespace {
void VerifyOperationCount(Env* env, ThreadStatus::OperationType op_type,
                          int expected_count) {
  int op_count = 0;
  std::vector<ThreadStatus> thread_list;
  ASSERT_OK(env->GetThreadList(&thread_list));
  for (auto thread : thread_list) {
    if (thread.operation_type == op_type) {
      op_count++;
    }
  }
  ASSERT_EQ(op_count, expected_count);
}
}  // namespace

I
Igor Sugak 已提交
7786
TEST_F(DBTest, GetThreadStatus) {
Y
Yueh-Hsuan Chiang 已提交
7787 7788
  Options options;
  options.env = env_;
7789 7790
  options.enable_thread_tracking = true;
  TryReopen(options);
Y
Yueh-Hsuan Chiang 已提交
7791 7792

  std::vector<ThreadStatus> thread_list;
7793
  Status s = env_->GetThreadList(&thread_list);
Y
Yueh-Hsuan Chiang 已提交
7794 7795 7796 7797 7798 7799 7800 7801 7802 7803 7804 7805

  for (int i = 0; i < 2; ++i) {
    // repeat the test with differet number of high / low priority threads
    const int kTestCount = 3;
    const unsigned int kHighPriCounts[kTestCount] = {3, 2, 5};
    const unsigned int kLowPriCounts[kTestCount] = {10, 15, 3};
    for (int test = 0; test < kTestCount; ++test) {
      // Change the number of threads in high / low priority pool.
      env_->SetBackgroundThreads(kHighPriCounts[test], Env::HIGH);
      env_->SetBackgroundThreads(kLowPriCounts[test], Env::LOW);
      // Wait to ensure the all threads has been registered
      env_->SleepForMicroseconds(100000);
7806
      s = env_->GetThreadList(&thread_list);
Y
Yueh-Hsuan Chiang 已提交
7807
      ASSERT_OK(s);
7808
      unsigned int thread_type_counts[ThreadStatus::NUM_THREAD_TYPES];
Y
Yueh-Hsuan Chiang 已提交
7809 7810
      memset(thread_type_counts, 0, sizeof(thread_type_counts));
      for (auto thread : thread_list) {
7811
        ASSERT_LT(thread.thread_type, ThreadStatus::NUM_THREAD_TYPES);
Y
Yueh-Hsuan Chiang 已提交
7812 7813 7814 7815
        thread_type_counts[thread.thread_type]++;
      }
      // Verify the total number of threades
      ASSERT_EQ(
7816 7817
          thread_type_counts[ThreadStatus::HIGH_PRIORITY] +
              thread_type_counts[ThreadStatus::LOW_PRIORITY],
Y
Yueh-Hsuan Chiang 已提交
7818 7819 7820
          kHighPriCounts[test] + kLowPriCounts[test]);
      // Verify the number of high-priority threads
      ASSERT_EQ(
7821
          thread_type_counts[ThreadStatus::HIGH_PRIORITY],
Y
Yueh-Hsuan Chiang 已提交
7822 7823 7824
          kHighPriCounts[test]);
      // Verify the number of low-priority threads
      ASSERT_EQ(
7825
          thread_type_counts[ThreadStatus::LOW_PRIORITY],
Y
Yueh-Hsuan Chiang 已提交
7826 7827 7828 7829 7830
          kLowPriCounts[test]);
    }
    if (i == 0) {
      // repeat the test with multiple column families
      CreateAndReopenWithCF({"pikachu", "about-to-remove"}, options);
7831 7832
      env_->GetThreadStatusUpdater()->TEST_VerifyColumnFamilyInfoMap(
          handles_, true);
Y
Yueh-Hsuan Chiang 已提交
7833 7834 7835
    }
  }
  db_->DropColumnFamily(handles_[2]);
7836
  delete handles_[2];
Y
Yueh-Hsuan Chiang 已提交
7837
  handles_.erase(handles_.begin() + 2);
7838 7839
  env_->GetThreadStatusUpdater()->TEST_VerifyColumnFamilyInfoMap(
      handles_, true);
Y
Yueh-Hsuan Chiang 已提交
7840
  Close();
7841 7842
  env_->GetThreadStatusUpdater()->TEST_VerifyColumnFamilyInfoMap(
      handles_, true);
7843 7844
}

I
Igor Sugak 已提交
7845
TEST_F(DBTest, DisableThreadStatus) {
7846 7847 7848 7849 7850 7851
  Options options;
  options.env = env_;
  options.enable_thread_tracking = false;
  TryReopen(options);
  CreateAndReopenWithCF({"pikachu", "about-to-remove"}, options);
  // Verify non of the column family info exists
7852 7853
  env_->GetThreadStatusUpdater()->TEST_VerifyColumnFamilyInfoMap(
      handles_, false);
Y
Yueh-Hsuan Chiang 已提交
7854
}
7855

I
Igor Sugak 已提交
7856
TEST_F(DBTest, ThreadStatusFlush) {
7857 7858 7859 7860 7861 7862 7863
  Options options;
  options.env = env_;
  options.write_buffer_size = 100000;  // Small write buffer
  options.enable_thread_tracking = true;
  options = CurrentOptions(options);

  rocksdb::SyncPoint::GetInstance()->LoadDependency({
7864 7865
      {"FlushJob::FlushJob()", "DBTest::ThreadStatusFlush:1"},
      {"DBTest::ThreadStatusFlush:2", "FlushJob::~FlushJob()"},
7866 7867 7868 7869 7870 7871 7872 7873 7874 7875 7876 7877 7878 7879 7880 7881 7882 7883 7884 7885 7886 7887
  });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  CreateAndReopenWithCF({"pikachu"}, options);
  VerifyOperationCount(env_, ThreadStatus::OP_FLUSH, 0);

  ASSERT_OK(Put(1, "foo", "v1"));
  ASSERT_EQ("v1", Get(1, "foo"));
  VerifyOperationCount(env_, ThreadStatus::OP_FLUSH, 0);

  Put(1, "k1", std::string(100000, 'x'));  // Fill memtable
  VerifyOperationCount(env_, ThreadStatus::OP_FLUSH, 0);
  Put(1, "k2", std::string(100000, 'y'));  // Trigger flush
  // wait for flush to be scheduled
  env_->SleepForMicroseconds(250000);
  TEST_SYNC_POINT("DBTest::ThreadStatusFlush:1");
  VerifyOperationCount(env_, ThreadStatus::OP_FLUSH, 1);
  TEST_SYNC_POINT("DBTest::ThreadStatusFlush:2");

  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
}

I
Igor Sugak 已提交
7888
TEST_F(DBTest, ThreadStatusSingleCompaction) {
7889 7890 7891 7892 7893 7894 7895 7896 7897 7898 7899 7900 7901 7902 7903 7904 7905
  const int kTestKeySize = 16;
  const int kTestValueSize = 984;
  const int kEntrySize = kTestKeySize + kTestValueSize;
  const int kEntriesPerBuffer = 100;
  Options options;
  options.create_if_missing = true;
  options.write_buffer_size = kEntrySize * kEntriesPerBuffer;
  options.compaction_style = kCompactionStyleLevel;
  options.target_file_size_base = options.write_buffer_size;
  options.max_bytes_for_level_base = options.target_file_size_base * 2;
  options.max_bytes_for_level_multiplier = 2;
  options.compression = kNoCompression;
  options = CurrentOptions(options);
  options.env = env_;
  options.enable_thread_tracking = true;
  const int kNumL0Files = 4;
  options.level0_file_num_compaction_trigger = kNumL0Files;
7906 7907

  rocksdb::SyncPoint::GetInstance()->LoadDependency({
7908 7909 7910
      {"DBTest::ThreadStatusSingleCompaction:0", "DBImpl::BGWorkCompaction"},
      {"CompactionJob::Run():Start", "DBTest::ThreadStatusSingleCompaction:1"},
      {"DBTest::ThreadStatusSingleCompaction:2", "CompactionJob::Run():End"},
7911
  });
7912
  for (int tests = 0; tests < 2; ++tests) {
7913
    DestroyAndReopen(options);
7914 7915
    rocksdb::SyncPoint::GetInstance()->ClearTrace();
    rocksdb::SyncPoint::GetInstance()->EnableProcessing();
7916 7917

    Random rnd(301);
7918
    // The Put Phase.
7919 7920 7921 7922 7923 7924
    for (int file = 0; file < kNumL0Files; ++file) {
      for (int key = 0; key < kEntriesPerBuffer; ++key) {
        ASSERT_OK(Put(ToString(key + file * kEntriesPerBuffer),
                      RandomString(&rnd, kTestValueSize)));
      }
      Flush();
7925
    }
7926 7927 7928
    // This makes sure a compaction won't be scheduled until
    // we have done with the above Put Phase.
    TEST_SYNC_POINT("DBTest::ThreadStatusSingleCompaction:0");
7929 7930
    ASSERT_GE(NumTableFilesAtLevel(0),
              options.level0_file_num_compaction_trigger);
7931

7932
    // This makes sure at least one compaction is running.
7933
    TEST_SYNC_POINT("DBTest::ThreadStatusSingleCompaction:1");
7934

7935 7936
    if (options.enable_thread_tracking) {
      // expecting one single L0 to L1 compaction
7937
      VerifyOperationCount(env_, ThreadStatus::OP_COMPACTION, 1);
7938 7939
    } else {
      // If thread tracking is not enabled, compaction count should be 0.
7940
      VerifyOperationCount(env_, ThreadStatus::OP_COMPACTION, 0);
7941
    }
7942
    // TODO(yhchiang): adding assert to verify each compaction stage.
7943
    TEST_SYNC_POINT("DBTest::ThreadStatusSingleCompaction:2");
7944 7945 7946

    // repeat the test with disabling thread tracking.
    options.enable_thread_tracking = false;
7947
    rocksdb::SyncPoint::GetInstance()->DisableProcessing();
7948 7949 7950
  }
}

I
Igor Sugak 已提交
7951
TEST_F(DBTest, PreShutdownManualCompaction) {
7952 7953 7954 7955 7956 7957 7958 7959 7960 7961 7962 7963 7964 7965 7966 7967 7968 7969 7970 7971 7972 7973 7974 7975 7976 7977 7978 7979 7980 7981 7982 7983 7984 7985 7986 7987
  Options options = CurrentOptions();
  options.max_background_flushes = 0;
  CreateAndReopenWithCF({"pikachu"}, options);
  ASSERT_EQ(dbfull()->MaxMemCompactionLevel(), 2)
      << "Need to update this test to match kMaxMemCompactLevel";

  // iter - 0 with 7 levels
  // iter - 1 with 3 levels
  for (int iter = 0; iter < 2; ++iter) {
    MakeTables(3, "p", "q", 1);
    ASSERT_EQ("1,1,1", FilesPerLevel(1));

    // Compaction range falls before files
    Compact(1, "", "c");
    ASSERT_EQ("1,1,1", FilesPerLevel(1));

    // Compaction range falls after files
    Compact(1, "r", "z");
    ASSERT_EQ("1,1,1", FilesPerLevel(1));

    // Compaction range overlaps files
    Compact(1, "p1", "p9");
    ASSERT_EQ("0,0,1", FilesPerLevel(1));

    // Populate a different range
    MakeTables(3, "c", "e", 1);
    ASSERT_EQ("1,1,2", FilesPerLevel(1));

    // Compact just the new range
    Compact(1, "b", "f");
    ASSERT_EQ("0,0,2", FilesPerLevel(1));

    // Compact all
    MakeTables(1, "a", "z", 1);
    ASSERT_EQ("0,1,2", FilesPerLevel(1));
    CancelAllBackgroundWork(db_);
7988
    db_->CompactRange(CompactRangeOptions(), handles_[1], nullptr, nullptr);
7989 7990 7991 7992 7993 7994 7995 7996 7997 7998 7999 8000 8001
    ASSERT_EQ("0,1,2", FilesPerLevel(1));

    if (iter == 0) {
      options = CurrentOptions();
      options.max_background_flushes = 0;
      options.num_levels = 3;
      options.create_if_missing = true;
      DestroyAndReopen(options);
      CreateAndReopenWithCF({"pikachu"}, options);
    }
  }
}

8002 8003 8004 8005 8006 8007 8008 8009 8010 8011 8012
TEST_F(DBTest, PreShutdownFlush) {
  Options options = CurrentOptions();
  options.max_background_flushes = 0;
  CreateAndReopenWithCF({"pikachu"}, options);
  ASSERT_OK(Put(1, "key", "value"));
  CancelAllBackgroundWork(db_);
  Status s =
      db_->CompactRange(CompactRangeOptions(), handles_[1], nullptr, nullptr);
  ASSERT_TRUE(s.IsShutdownInProgress());
}

I
Igor Sugak 已提交
8013
TEST_F(DBTest, PreShutdownMultipleCompaction) {
8014 8015 8016
  const int kTestKeySize = 16;
  const int kTestValueSize = 984;
  const int kEntrySize = kTestKeySize + kTestValueSize;
8017
  const int kEntriesPerBuffer = 40;
8018 8019 8020 8021 8022 8023 8024 8025 8026 8027 8028 8029 8030 8031 8032 8033 8034 8035 8036 8037 8038
  const int kNumL0Files = 4;

  const int kHighPriCount = 3;
  const int kLowPriCount = 5;
  env_->SetBackgroundThreads(kHighPriCount, Env::HIGH);
  env_->SetBackgroundThreads(kLowPriCount, Env::LOW);

  Options options;
  options.create_if_missing = true;
  options.write_buffer_size = kEntrySize * kEntriesPerBuffer;
  options.compaction_style = kCompactionStyleLevel;
  options.target_file_size_base = options.write_buffer_size;
  options.max_bytes_for_level_base =
      options.target_file_size_base * kNumL0Files;
  options.compression = kNoCompression;
  options = CurrentOptions(options);
  options.env = env_;
  options.enable_thread_tracking = true;
  options.level0_file_num_compaction_trigger = kNumL0Files;
  options.max_bytes_for_level_multiplier = 2;
  options.max_background_compactions = kLowPriCount;
8039 8040
  options.level0_stop_writes_trigger = 1 << 10;
  options.level0_slowdown_writes_trigger = 1 << 10;
8041 8042 8043 8044 8045 8046 8047

  TryReopen(options);
  Random rnd(301);

  std::vector<ThreadStatus> thread_list;
  // Delay both flush and compaction
  rocksdb::SyncPoint::GetInstance()->LoadDependency(
8048 8049
      {{"FlushJob::FlushJob()", "CompactionJob::Run():Start"},
       {"CompactionJob::Run():Start",
8050
        "DBTest::PreShutdownMultipleCompaction:Preshutdown"},
8051 8052
        {"CompactionJob::Run():Start",
        "DBTest::PreShutdownMultipleCompaction:VerifyCompaction"},
8053
       {"DBTest::PreShutdownMultipleCompaction:Preshutdown",
8054 8055
        "CompactionJob::Run():End"},
       {"CompactionJob::Run():End",
8056 8057 8058 8059 8060 8061 8062 8063
        "DBTest::PreShutdownMultipleCompaction:VerifyPreshutdown"}});

  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  // Make rocksdb busy
  int key = 0;
  // check how many threads are doing compaction using GetThreadList
  int operation_count[ThreadStatus::NUM_OP_TYPES] = {0};
8064
  for (int file = 0; file < 16 * kNumL0Files; ++file) {
8065 8066 8067 8068 8069 8070 8071 8072 8073 8074
    for (int k = 0; k < kEntriesPerBuffer; ++k) {
      ASSERT_OK(Put(ToString(key++), RandomString(&rnd, kTestValueSize)));
    }

    Status s = env_->GetThreadList(&thread_list);
    for (auto thread : thread_list) {
      operation_count[thread.operation_type]++;
    }

    // Speed up the test
8075 8076
    if (operation_count[ThreadStatus::OP_FLUSH] > 1 &&
        operation_count[ThreadStatus::OP_COMPACTION] >
8077 8078 8079
            0.6 * options.max_background_compactions) {
      break;
    }
8080 8081 8082
    if (file == 15 * kNumL0Files) {
      TEST_SYNC_POINT("DBTest::PreShutdownMultipleCompaction:Preshutdown");
    }
8083 8084 8085
  }

  TEST_SYNC_POINT("DBTest::PreShutdownMultipleCompaction:Preshutdown");
8086
  ASSERT_GE(operation_count[ThreadStatus::OP_COMPACTION], 1);
8087 8088 8089 8090 8091 8092 8093 8094 8095 8096 8097 8098 8099 8100
  CancelAllBackgroundWork(db_);
  TEST_SYNC_POINT("DBTest::PreShutdownMultipleCompaction:VerifyPreshutdown");
  dbfull()->TEST_WaitForCompact();
  // Record the number of compactions at a time.
  for (int i = 0; i < ThreadStatus::NUM_OP_TYPES; ++i) {
    operation_count[i] = 0;
  }
  Status s = env_->GetThreadList(&thread_list);
  for (auto thread : thread_list) {
    operation_count[thread.operation_type]++;
  }
  ASSERT_EQ(operation_count[ThreadStatus::OP_COMPACTION], 0);
}

I
Igor Sugak 已提交
8101
TEST_F(DBTest, PreShutdownCompactionMiddle) {
8102 8103 8104
  const int kTestKeySize = 16;
  const int kTestValueSize = 984;
  const int kEntrySize = kTestKeySize + kTestValueSize;
8105
  const int kEntriesPerBuffer = 40;
8106 8107 8108 8109 8110 8111 8112 8113 8114 8115 8116 8117 8118 8119 8120 8121 8122 8123 8124 8125 8126
  const int kNumL0Files = 4;

  const int kHighPriCount = 3;
  const int kLowPriCount = 5;
  env_->SetBackgroundThreads(kHighPriCount, Env::HIGH);
  env_->SetBackgroundThreads(kLowPriCount, Env::LOW);

  Options options;
  options.create_if_missing = true;
  options.write_buffer_size = kEntrySize * kEntriesPerBuffer;
  options.compaction_style = kCompactionStyleLevel;
  options.target_file_size_base = options.write_buffer_size;
  options.max_bytes_for_level_base =
      options.target_file_size_base * kNumL0Files;
  options.compression = kNoCompression;
  options = CurrentOptions(options);
  options.env = env_;
  options.enable_thread_tracking = true;
  options.level0_file_num_compaction_trigger = kNumL0Files;
  options.max_bytes_for_level_multiplier = 2;
  options.max_background_compactions = kLowPriCount;
8127 8128
  options.level0_stop_writes_trigger = 1 << 10;
  options.level0_slowdown_writes_trigger = 1 << 10;
8129 8130 8131 8132 8133 8134 8135

  TryReopen(options);
  Random rnd(301);

  std::vector<ThreadStatus> thread_list;
  // Delay both flush and compaction
  rocksdb::SyncPoint::GetInstance()->LoadDependency(
8136
      {{"DBTest::PreShutdownCompactionMiddle:Preshutdown",
8137
        "CompactionJob::Run():Inprogress"},
8138 8139
        {"CompactionJob::Run():Start",
        "DBTest::PreShutdownCompactionMiddle:VerifyCompaction"},
8140 8141
       {"CompactionJob::Run():Inprogress", "CompactionJob::Run():End"},
       {"CompactionJob::Run():End",
8142
        "DBTest::PreShutdownCompactionMiddle:VerifyPreshutdown"}});
8143 8144 8145 8146 8147 8148 8149

  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  // Make rocksdb busy
  int key = 0;
  // check how many threads are doing compaction using GetThreadList
  int operation_count[ThreadStatus::NUM_OP_TYPES] = {0};
8150
  for (int file = 0; file < 16 * kNumL0Files; ++file) {
8151 8152 8153 8154 8155 8156 8157 8158 8159 8160
    for (int k = 0; k < kEntriesPerBuffer; ++k) {
      ASSERT_OK(Put(ToString(key++), RandomString(&rnd, kTestValueSize)));
    }

    Status s = env_->GetThreadList(&thread_list);
    for (auto thread : thread_list) {
      operation_count[thread.operation_type]++;
    }

    // Speed up the test
8161 8162
    if (operation_count[ThreadStatus::OP_FLUSH] > 1 &&
        operation_count[ThreadStatus::OP_COMPACTION] >
8163 8164 8165
            0.6 * options.max_background_compactions) {
      break;
    }
8166 8167 8168
    if (file == 15 * kNumL0Files) {
      TEST_SYNC_POINT("DBTest::PreShutdownCompactionMiddle:VerifyCompaction");
    }
8169 8170
  }

8171
  ASSERT_GE(operation_count[ThreadStatus::OP_COMPACTION], 1);
8172
  CancelAllBackgroundWork(db_);
8173 8174
  TEST_SYNC_POINT("DBTest::PreShutdownCompactionMiddle:Preshutdown");
  TEST_SYNC_POINT("DBTest::PreShutdownCompactionMiddle:VerifyPreshutdown");
8175 8176 8177 8178 8179 8180 8181 8182 8183 8184 8185 8186
  dbfull()->TEST_WaitForCompact();
  // Record the number of compactions at a time.
  for (int i = 0; i < ThreadStatus::NUM_OP_TYPES; ++i) {
    operation_count[i] = 0;
  }
  Status s = env_->GetThreadList(&thread_list);
  for (auto thread : thread_list) {
    operation_count[thread.operation_type]++;
  }
  ASSERT_EQ(operation_count[ThreadStatus::OP_COMPACTION], 0);
}

Y
Yueh-Hsuan Chiang 已提交
8187 8188
#endif  // ROCKSDB_USING_THREAD_STATUS

8189 8190 8191 8192 8193 8194 8195
TEST_F(DBTest, FlushOnDestroy) {
  WriteOptions wo;
  wo.disableWAL = true;
  ASSERT_OK(Put("foo", "v1", wo));
  CancelAllBackgroundWork(db_);
}

8196 8197 8198 8199 8200 8201 8202 8203 8204 8205 8206 8207 8208 8209 8210 8211 8212 8213 8214 8215 8216 8217 8218 8219 8220 8221 8222 8223 8224 8225 8226 8227
namespace {
class OnFileDeletionListener : public EventListener {
 public:
  OnFileDeletionListener() :
      matched_count_(0),
      expected_file_name_("") {}

  void SetExpectedFileName(
      const std::string file_name) {
    expected_file_name_ = file_name;
  }

  void VerifyMatchedCount(size_t expected_value) {
    ASSERT_EQ(matched_count_, expected_value);
  }

  void OnTableFileDeleted(
      const TableFileDeletionInfo& info) override {
    if (expected_file_name_ != "") {
      ASSERT_EQ(expected_file_name_, info.file_path);
      expected_file_name_ = "";
      matched_count_++;
    }
  }

 private:
  size_t matched_count_;
  std::string expected_file_name_;
};

}  // namespace

I
Igor Sugak 已提交
8228
TEST_F(DBTest, DynamicLevelCompressionPerLevel) {
I
Igor Canadi 已提交
8229
  if (!Snappy_Supported()) {
8230 8231
    return;
  }
8232 8233 8234 8235 8236 8237 8238 8239 8240 8241 8242 8243 8244 8245 8246 8247 8248 8249 8250 8251 8252 8253 8254 8255 8256 8257 8258 8259
  const int kNKeys = 120;
  int keys[kNKeys];
  for (int i = 0; i < kNKeys; i++) {
    keys[i] = i;
  }
  std::random_shuffle(std::begin(keys), std::end(keys));

  Random rnd(301);
  Options options;
  options.create_if_missing = true;
  options.db_write_buffer_size = 20480;
  options.write_buffer_size = 20480;
  options.max_write_buffer_number = 2;
  options.level0_file_num_compaction_trigger = 2;
  options.level0_slowdown_writes_trigger = 2;
  options.level0_stop_writes_trigger = 2;
  options.target_file_size_base = 2048;
  options.level_compaction_dynamic_level_bytes = true;
  options.max_bytes_for_level_base = 102400;
  options.max_bytes_for_level_multiplier = 4;
  options.max_background_compactions = 1;
  options.num_levels = 5;

  options.compression_per_level.resize(3);
  options.compression_per_level[0] = kNoCompression;
  options.compression_per_level[1] = kNoCompression;
  options.compression_per_level[2] = kSnappyCompression;

8260 8261 8262
  OnFileDeletionListener* listener = new OnFileDeletionListener();
  options.listeners.emplace_back(listener);

8263 8264 8265 8266 8267 8268 8269 8270 8271 8272 8273 8274 8275 8276 8277 8278 8279 8280 8281 8282 8283 8284 8285 8286 8287 8288 8289 8290 8291 8292 8293 8294
  DestroyAndReopen(options);

  // Insert more than 80K. L4 should be base level. Neither L0 nor L4 should
  // be compressed, so total data size should be more than 80K.
  for (int i = 0; i < 20; i++) {
    ASSERT_OK(Put(Key(keys[i]), CompressibleString(&rnd, 4000)));
  }
  Flush();
  dbfull()->TEST_WaitForCompact();

  ASSERT_EQ(NumTableFilesAtLevel(1), 0);
  ASSERT_EQ(NumTableFilesAtLevel(2), 0);
  ASSERT_EQ(NumTableFilesAtLevel(3), 0);
  ASSERT_GT(SizeAtLevel(0) + SizeAtLevel(4), 20U * 4000U);

  // Insert 400KB. Some data will be compressed
  for (int i = 21; i < 120; i++) {
    ASSERT_OK(Put(Key(keys[i]), CompressibleString(&rnd, 4000)));
  }
  Flush();
  dbfull()->TEST_WaitForCompact();
  ASSERT_EQ(NumTableFilesAtLevel(1), 0);
  ASSERT_EQ(NumTableFilesAtLevel(2), 0);
  ASSERT_LT(SizeAtLevel(0) + SizeAtLevel(3) + SizeAtLevel(4), 120U * 4000U);
  // Make sure data in files in L3 is not compacted by removing all files
  // in L4 and calculate number of rows
  ASSERT_OK(dbfull()->SetOptions({
      {"disable_auto_compactions", "true"},
  }));
  ColumnFamilyMetaData cf_meta;
  db_->GetColumnFamilyMetaData(&cf_meta);
  for (auto file : cf_meta.levels[4].files) {
8295
    listener->SetExpectedFileName(dbname_ + file.name);
8296 8297
    ASSERT_OK(dbfull()->DeleteFile(file.name));
  }
8298 8299
  listener->VerifyMatchedCount(cf_meta.levels[4].files.size());

8300 8301 8302 8303 8304 8305 8306 8307 8308
  int num_keys = 0;
  std::unique_ptr<Iterator> iter(db_->NewIterator(ReadOptions()));
  for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
    num_keys++;
  }
  ASSERT_OK(iter->status());
  ASSERT_GT(SizeAtLevel(0) + SizeAtLevel(3), num_keys * 4000U);
}

I
Igor Sugak 已提交
8309
TEST_F(DBTest, DynamicLevelCompressionPerLevel2) {
8310 8311 8312
  if (!Snappy_Supported() || !LZ4_Supported() || !Zlib_Supported()) {
    return;
  }
8313 8314 8315 8316 8317 8318 8319 8320 8321 8322 8323 8324 8325 8326 8327 8328
  const int kNKeys = 500;
  int keys[kNKeys];
  for (int i = 0; i < kNKeys; i++) {
    keys[i] = i;
  }
  std::random_shuffle(std::begin(keys), std::end(keys));

  Random rnd(301);
  Options options;
  options.create_if_missing = true;
  options.db_write_buffer_size = 6000;
  options.write_buffer_size = 6000;
  options.max_write_buffer_number = 2;
  options.level0_file_num_compaction_trigger = 2;
  options.level0_slowdown_writes_trigger = 2;
  options.level0_stop_writes_trigger = 2;
S
sdong 已提交
8329
  options.soft_rate_limit = 1.1;
8330 8331 8332 8333 8334 8335 8336 8337 8338 8339 8340 8341 8342 8343 8344 8345 8346 8347 8348 8349 8350 8351

  // Use file size to distinguish levels
  // L1: 10, L2: 20, L3 40, L4 80
  // L0 is less than 30
  options.target_file_size_base = 10;
  options.target_file_size_multiplier = 2;

  options.level_compaction_dynamic_level_bytes = true;
  options.max_bytes_for_level_base = 200;
  options.max_bytes_for_level_multiplier = 8;
  options.max_background_compactions = 1;
  options.num_levels = 5;
  std::shared_ptr<mock::MockTableFactory> mtf(new mock::MockTableFactory);
  options.table_factory = mtf;

  options.compression_per_level.resize(3);
  options.compression_per_level[0] = kNoCompression;
  options.compression_per_level[1] = kLZ4Compression;
  options.compression_per_level[2] = kZlibCompression;

  DestroyAndReopen(options);
  // When base level is L4, L4 is LZ4.
8352 8353 8354
  std::atomic<int> num_zlib(0);
  std::atomic<int> num_lz4(0);
  std::atomic<int> num_no(0);
8355 8356 8357 8358
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "LevelCompactionPicker::PickCompaction:Return", [&](void* arg) {
        Compaction* compaction = reinterpret_cast<Compaction*>(arg);
        if (compaction->output_level() == 4) {
8359
          ASSERT_TRUE(compaction->output_compression() == kLZ4Compression);
8360
          num_lz4.fetch_add(1);
8361 8362
        }
      });
8363 8364 8365 8366 8367 8368
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "FlushJob::WriteLevel0Table:output_compression", [&](void* arg) {
        auto* compression = reinterpret_cast<CompressionType*>(arg);
        ASSERT_TRUE(*compression == kNoCompression);
        num_no.fetch_add(1);
      });
8369 8370
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

8371 8372 8373 8374 8375
  for (int i = 0; i < 100; i++) {
    ASSERT_OK(Put(Key(keys[i]), RandomString(&rnd, 200)));
  }
  Flush();
  dbfull()->TEST_WaitForCompact();
8376 8377
  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
  rocksdb::SyncPoint::GetInstance()->ClearAllCallBacks();
8378 8379 8380 8381

  ASSERT_EQ(NumTableFilesAtLevel(1), 0);
  ASSERT_EQ(NumTableFilesAtLevel(2), 0);
  ASSERT_EQ(NumTableFilesAtLevel(3), 0);
8382
  ASSERT_GT(NumTableFilesAtLevel(4), 0);
8383 8384
  ASSERT_GT(num_no.load(), 2);
  ASSERT_GT(num_lz4.load(), 0);
8385
  int prev_num_files_l4 = NumTableFilesAtLevel(4);
8386 8387

  // After base level turn L4->L3, L3 becomes LZ4 and L4 becomes Zlib
8388 8389
  num_lz4.store(0);
  num_no.store(0);
8390 8391 8392 8393
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "LevelCompactionPicker::PickCompaction:Return", [&](void* arg) {
        Compaction* compaction = reinterpret_cast<Compaction*>(arg);
        if (compaction->output_level() == 4 && compaction->start_level() == 3) {
8394
          ASSERT_TRUE(compaction->output_compression() == kZlibCompression);
8395
          num_zlib.fetch_add(1);
8396
        } else {
8397
          ASSERT_TRUE(compaction->output_compression() == kLZ4Compression);
8398
          num_lz4.fetch_add(1);
8399 8400
        }
      });
8401 8402 8403 8404 8405 8406 8407
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "FlushJob::WriteLevel0Table:output_compression", [&](void* arg) {
        auto* compression = reinterpret_cast<CompressionType*>(arg);
        ASSERT_TRUE(*compression == kNoCompression);
        num_no.fetch_add(1);
      });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
8408

8409 8410 8411 8412 8413 8414 8415
  for (int i = 101; i < 500; i++) {
    ASSERT_OK(Put(Key(keys[i]), RandomString(&rnd, 200)));
    if (i % 100 == 99) {
      Flush();
      dbfull()->TEST_WaitForCompact();
    }
  }
8416 8417 8418

  rocksdb::SyncPoint::GetInstance()->ClearAllCallBacks();
  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
8419 8420
  ASSERT_EQ(NumTableFilesAtLevel(1), 0);
  ASSERT_EQ(NumTableFilesAtLevel(2), 0);
8421 8422
  ASSERT_GT(NumTableFilesAtLevel(3), 0);
  ASSERT_GT(NumTableFilesAtLevel(4), prev_num_files_l4);
8423 8424 8425
  ASSERT_GT(num_no.load(), 2);
  ASSERT_GT(num_lz4.load(), 0);
  ASSERT_GT(num_zlib.load(), 0);
8426 8427
}

I
Igor Sugak 已提交
8428
TEST_F(DBTest, DynamicCompactionOptions) {
8429 8430
  // minimum write buffer size is enforced at 64KB
  const uint64_t k32KB = 1 << 15;
8431 8432
  const uint64_t k64KB = 1 << 16;
  const uint64_t k128KB = 1 << 17;
8433
  const uint64_t k1MB = 1 << 20;
8434
  const uint64_t k4KB = 1 << 12;
8435 8436 8437 8438
  Options options;
  options.env = env_;
  options.create_if_missing = true;
  options.compression = kNoCompression;
S
sdong 已提交
8439
  options.soft_rate_limit = 1.1;
8440
  options.write_buffer_size = k64KB;
8441 8442 8443
  options.max_write_buffer_number = 2;
  // Compaction related options
  options.level0_file_num_compaction_trigger = 3;
L
Lei Jin 已提交
8444 8445
  options.level0_slowdown_writes_trigger = 4;
  options.level0_stop_writes_trigger = 8;
8446 8447 8448
  options.max_grandparent_overlap_factor = 10;
  options.expanded_compaction_factor = 25;
  options.source_compaction_factor = 1;
8449
  options.target_file_size_base = k64KB;
8450
  options.target_file_size_multiplier = 1;
8451
  options.max_bytes_for_level_base = k128KB;
8452
  options.max_bytes_for_level_multiplier = 4;
L
Lei Jin 已提交
8453 8454 8455 8456

  // Block flush thread and disable compaction thread
  env_->SetBackgroundThreads(1, Env::LOW);
  env_->SetBackgroundThreads(1, Env::HIGH);
L
Lei Jin 已提交
8457
  DestroyAndReopen(options);
8458

8459
  auto gen_l0_kb = [this](int start, int size, int stride) {
8460 8461
    Random rnd(301);
    for (int i = 0; i < size; i++) {
L
Lei Jin 已提交
8462
      ASSERT_OK(Put(Key(start + stride * i), RandomString(&rnd, 1024)));
8463 8464 8465 8466
    }
    dbfull()->TEST_WaitForFlushMemTable();
  };

8467 8468 8469
  // Write 3 files that have the same key range.
  // Since level0_file_num_compaction_trigger is 3, compaction should be
  // triggered. The compaction should result in one L1 file
8470
  gen_l0_kb(0, 64, 1);
8471
  ASSERT_EQ(NumTableFilesAtLevel(0), 1);
8472
  gen_l0_kb(0, 64, 1);
8473
  ASSERT_EQ(NumTableFilesAtLevel(0), 2);
8474
  gen_l0_kb(0, 64, 1);
8475 8476 8477 8478
  dbfull()->TEST_WaitForCompact();
  ASSERT_EQ("0,1", FilesPerLevel());
  std::vector<LiveFileMetaData> metadata;
  db_->GetLiveFilesMetaData(&metadata);
8479
  ASSERT_EQ(1U, metadata.size());
8480 8481
  ASSERT_LE(metadata[0].size, k64KB + k4KB);
  ASSERT_GE(metadata[0].size, k64KB - k4KB);
8482

8483
  // Test compaction trigger and target_file_size_base
8484 8485 8486 8487
  // Reduce compaction trigger to 2, and reduce L1 file size to 32KB.
  // Writing to 64KB L0 files should trigger a compaction. Since these
  // 2 L0 files have the same key range, compaction merge them and should
  // result in 2 32KB L1 files.
8488
  ASSERT_OK(dbfull()->SetOptions({
8489
    {"level0_file_num_compaction_trigger", "2"},
8490
    {"target_file_size_base", ToString(k32KB) }
8491 8492
  }));

8493
  gen_l0_kb(0, 64, 1);
8494
  ASSERT_EQ("1,1", FilesPerLevel());
8495
  gen_l0_kb(0, 64, 1);
8496 8497 8498 8499
  dbfull()->TEST_WaitForCompact();
  ASSERT_EQ("0,2", FilesPerLevel());
  metadata.clear();
  db_->GetLiveFilesMetaData(&metadata);
8500
  ASSERT_EQ(2U, metadata.size());
8501 8502
  ASSERT_LE(metadata[0].size, k32KB + k4KB);
  ASSERT_GE(metadata[0].size, k32KB - k4KB);
8503 8504
  ASSERT_LE(metadata[1].size, k32KB + k4KB);
  ASSERT_GE(metadata[1].size, k32KB - k4KB);
8505

8506
  // Test max_bytes_for_level_base
8507 8508 8509
  // Increase level base size to 256KB and write enough data that will
  // fill L1 and L2. L1 size should be around 256KB while L2 size should be
  // around 256KB x 4.
8510
  ASSERT_OK(dbfull()->SetOptions({
8511
    {"max_bytes_for_level_base", ToString(k1MB) }
8512
  }));
8513

8514 8515 8516 8517
  // writing 96 x 64KB => 6 * 1024KB
  // (L1 + L2) = (1 + 4) * 1024KB
  for (int i = 0; i < 96; ++i) {
    gen_l0_kb(i, 64, 96);
8518 8519
  }
  dbfull()->TEST_WaitForCompact();
8520 8521 8522 8523 8524 8525
  ASSERT_GT(SizeAtLevel(1), k1MB / 2);
  ASSERT_LT(SizeAtLevel(1), k1MB + k1MB / 2);

  // Within (0.5, 1.5) of 4MB.
  ASSERT_GT(SizeAtLevel(2), 2 * k1MB);
  ASSERT_LT(SizeAtLevel(2), 6 * k1MB);
8526

8527
  // Test max_bytes_for_level_multiplier and
8528 8529 8530
  // max_bytes_for_level_base. Now, reduce both mulitplier and level base,
  // After filling enough data that can fit in L1 - L3, we should see L1 size
  // reduces to 128KB from 256KB which was asserted previously. Same for L2.
8531
  ASSERT_OK(dbfull()->SetOptions({
8532
    {"max_bytes_for_level_multiplier", "2"},
8533
    {"max_bytes_for_level_base", ToString(k128KB) }
8534 8535
  }));

8536 8537 8538 8539
  // writing 20 x 64KB = 10 x 128KB
  // (L1 + L2 + L3) = (1 + 2 + 4) * 128KB
  for (int i = 0; i < 20; ++i) {
    gen_l0_kb(i, 64, 32);
8540 8541
  }
  dbfull()->TEST_WaitForCompact();
8542 8543 8544
  uint64_t total_size =
    SizeAtLevel(1) + SizeAtLevel(2) + SizeAtLevel(3);
  ASSERT_TRUE(total_size < k128KB * 7 * 1.5);
L
Lei Jin 已提交
8545

8546 8547
  // Test level0_stop_writes_trigger.
  // Clean up memtable and L0. Block compaction threads. If continue to write
8548
  // and flush memtables. We should see put stop after 8 memtable flushes
8549
  // since level0_stop_writes_trigger = 8
8550
  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
L
Lei Jin 已提交
8551
  // Block compaction
8552 8553
  SleepingBackgroundTask sleeping_task_low;
  env_->Schedule(&SleepingBackgroundTask::DoSleepTask, &sleeping_task_low,
L
Lei Jin 已提交
8554
                 Env::Priority::LOW);
8555 8556 8557 8558 8559 8560

  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::DelayWrite:Wait",
      [&](void* arg) { sleeping_task_low.WakeUp(); });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

L
Lei Jin 已提交
8561 8562 8563 8564
  ASSERT_EQ(NumTableFilesAtLevel(0), 0);
  int count = 0;
  Random rnd(301);
  WriteOptions wo;
8565 8566 8567 8568 8569
  while (count < 64) {
    ASSERT_OK(Put(Key(count), RandomString(&rnd, 1024), wo));
    if (sleeping_task_low.WokenUp()) {
      break;
    }
L
Lei Jin 已提交
8570 8571 8572
    dbfull()->TEST_FlushMemTable(true);
    count++;
  }
8573
  // Stop trigger = 8
L
Lei Jin 已提交
8574 8575
  ASSERT_EQ(count, 8);
  // Unblock
8576
  sleeping_task_low.WaitUntilDone();
L
Lei Jin 已提交
8577

8578 8579
  // Now reduce level0_stop_writes_trigger to 6. Clear up memtables and L0.
  // Block compaction thread again. Perform the put and memtable flushes
8580
  // until we see the stop after 6 memtable flushes.
8581
  ASSERT_OK(dbfull()->SetOptions({
L
Lei Jin 已提交
8582 8583
    {"level0_stop_writes_trigger", "6"}
  }));
8584
  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
L
Lei Jin 已提交
8585 8586
  ASSERT_EQ(NumTableFilesAtLevel(0), 0);

8587 8588 8589
  // Block compaction again
  sleeping_task_low.Reset();
  env_->Schedule(&SleepingBackgroundTask::DoSleepTask, &sleeping_task_low,
L
Lei Jin 已提交
8590 8591
                 Env::Priority::LOW);
  count = 0;
8592 8593 8594 8595 8596
  while (count < 64) {
    ASSERT_OK(Put(Key(count), RandomString(&rnd, 1024), wo));
    if (sleeping_task_low.WokenUp()) {
      break;
    }
L
Lei Jin 已提交
8597 8598 8599 8600 8601
    dbfull()->TEST_FlushMemTable(true);
    count++;
  }
  ASSERT_EQ(count, 6);
  // Unblock
8602
  sleeping_task_low.WaitUntilDone();
L
Lei Jin 已提交
8603 8604

  // Test disable_auto_compactions
8605 8606 8607 8608
  // Compaction thread is unblocked but auto compaction is disabled. Write
  // 4 L0 files and compaction should be triggered. If auto compaction is
  // disabled, then TEST_WaitForCompact will be waiting for nothing. Number of
  // L0 files do not change after the call.
8609
  ASSERT_OK(dbfull()->SetOptions({
L
Lei Jin 已提交
8610 8611
    {"disable_auto_compactions", "true"}
  }));
8612
  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
L
Lei Jin 已提交
8613 8614 8615 8616
  ASSERT_EQ(NumTableFilesAtLevel(0), 0);

  for (int i = 0; i < 4; ++i) {
    ASSERT_OK(Put(Key(i), RandomString(&rnd, 1024)));
8617
    // Wait for compaction so that put won't stop
L
Lei Jin 已提交
8618 8619 8620 8621 8622
    dbfull()->TEST_FlushMemTable(true);
  }
  dbfull()->TEST_WaitForCompact();
  ASSERT_EQ(NumTableFilesAtLevel(0), 4);

8623 8624
  // Enable auto compaction and perform the same test, # of L0 files should be
  // reduced after compaction.
8625
  ASSERT_OK(dbfull()->SetOptions({
L
Lei Jin 已提交
8626 8627
    {"disable_auto_compactions", "false"}
  }));
8628
  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
L
Lei Jin 已提交
8629 8630 8631 8632
  ASSERT_EQ(NumTableFilesAtLevel(0), 0);

  for (int i = 0; i < 4; ++i) {
    ASSERT_OK(Put(Key(i), RandomString(&rnd, 1024)));
8633
    // Wait for compaction so that put won't stop
L
Lei Jin 已提交
8634 8635 8636 8637
    dbfull()->TEST_FlushMemTable(true);
  }
  dbfull()->TEST_WaitForCompact();
  ASSERT_LT(NumTableFilesAtLevel(0), 4);
8638

L
Lei Jin 已提交
8639
  // Test max_mem_compaction_level.
C
clark.kang 已提交
8640
  // Destroy DB and start from scratch
L
Lei Jin 已提交
8641 8642 8643
  options.max_background_compactions = 1;
  options.max_background_flushes = 0;
  options.max_mem_compaction_level = 2;
L
Lei Jin 已提交
8644
  DestroyAndReopen(options);
L
Lei Jin 已提交
8645 8646 8647 8648
  ASSERT_EQ(NumTableFilesAtLevel(0), 0);
  ASSERT_EQ(NumTableFilesAtLevel(1), 0);
  ASSERT_EQ(NumTableFilesAtLevel(2), 0);

S
sdong 已提交
8649
  ASSERT_OK(Put("max_mem_compaction_level_key", RandomString(&rnd, 8)));
L
Lei Jin 已提交
8650 8651 8652 8653 8654 8655 8656 8657
  dbfull()->TEST_FlushMemTable(true);
  ASSERT_EQ(NumTableFilesAtLevel(0), 0);
  ASSERT_EQ(NumTableFilesAtLevel(1), 0);
  ASSERT_EQ(NumTableFilesAtLevel(2), 1);

  ASSERT_TRUE(Put("max_mem_compaction_level_key",
              RandomString(&rnd, 8)).ok());
  // Set new value and it becomes effective in this flush
8658
  ASSERT_OK(dbfull()->SetOptions({
L
Lei Jin 已提交
8659 8660 8661 8662 8663 8664 8665 8666 8667 8668
    {"max_mem_compaction_level", "1"}
  }));
  dbfull()->TEST_FlushMemTable(true);
  ASSERT_EQ(NumTableFilesAtLevel(0), 0);
  ASSERT_EQ(NumTableFilesAtLevel(1), 1);
  ASSERT_EQ(NumTableFilesAtLevel(2), 1);

  ASSERT_TRUE(Put("max_mem_compaction_level_key",
              RandomString(&rnd, 8)).ok());
  // Set new value and it becomes effective in this flush
8669
  ASSERT_OK(dbfull()->SetOptions({
L
Lei Jin 已提交
8670 8671 8672 8673 8674 8675
    {"max_mem_compaction_level", "0"}
  }));
  dbfull()->TEST_FlushMemTable(true);
  ASSERT_EQ(NumTableFilesAtLevel(0), 1);
  ASSERT_EQ(NumTableFilesAtLevel(1), 1);
  ASSERT_EQ(NumTableFilesAtLevel(2), 1);
8676 8677

  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
8678
}
8679

I
Igor Sugak 已提交
8680
TEST_F(DBTest, FileCreationRandomFailure) {
8681 8682 8683 8684 8685 8686 8687 8688
  Options options;
  options.env = env_;
  options.create_if_missing = true;
  options.write_buffer_size = 100000;  // Small write buffer
  options.target_file_size_base = 200000;
  options.max_bytes_for_level_base = 1000000;
  options.max_bytes_for_level_multiplier = 2;

L
Lei Jin 已提交
8689
  DestroyAndReopen(options);
8690 8691 8692 8693 8694 8695 8696 8697 8698 8699 8700 8701 8702 8703 8704 8705 8706 8707 8708 8709 8710 8711 8712 8713 8714 8715 8716 8717 8718 8719 8720 8721 8722 8723 8724 8725 8726 8727 8728 8729 8730 8731
  Random rnd(301);

  const int kTestSize = kCDTKeysPerBuffer * 4096;
  const int kTotalIteration = 100;
  // the second half of the test involves in random failure
  // of file creation.
  const int kRandomFailureTest = kTotalIteration / 2;
  std::vector<std::string> values;
  for (int i = 0; i < kTestSize; ++i) {
    values.push_back("NOT_FOUND");
  }
  for (int j = 0; j < kTotalIteration; ++j) {
    if (j == kRandomFailureTest) {
      env_->non_writeable_rate_.store(90);
    }
    for (int k = 0; k < kTestSize; ++k) {
      // here we expect some of the Put fails.
      std::string value = RandomString(&rnd, 100);
      Status s = Put(Key(k), Slice(value));
      if (s.ok()) {
        // update the latest successful put
        values[k] = value;
      }
      // But everything before we simulate the failure-test should succeed.
      if (j < kRandomFailureTest) {
        ASSERT_OK(s);
      }
    }
  }

  // If rocksdb does not do the correct job, internal assert will fail here.
  dbfull()->TEST_WaitForFlushMemTable();
  dbfull()->TEST_WaitForCompact();

  // verify we have the latest successful update
  for (int k = 0; k < kTestSize; ++k) {
    auto v = Get(Key(k));
    ASSERT_EQ(v, values[k]);
  }

  // reopen and reverify we have the latest successful update
  env_->non_writeable_rate_.store(0);
L
Lei Jin 已提交
8732
  Reopen(options);
8733 8734 8735 8736 8737 8738
  for (int k = 0; k < kTestSize; ++k) {
    auto v = Get(Key(k));
    ASSERT_EQ(v, values[k]);
  }
}

I
Igor Sugak 已提交
8739
TEST_F(DBTest, PartialCompactionFailure) {
8740 8741 8742 8743 8744 8745 8746 8747 8748 8749 8750 8751 8752 8753 8754 8755 8756 8757
  Options options;
  const int kKeySize = 16;
  const int kKvSize = 1000;
  const int kKeysPerBuffer = 100;
  const int kNumL1Files = 5;
  options.create_if_missing = true;
  options.write_buffer_size = kKeysPerBuffer * kKvSize;
  options.max_write_buffer_number = 2;
  options.target_file_size_base =
      options.write_buffer_size *
      (options.max_write_buffer_number - 1);
  options.level0_file_num_compaction_trigger = kNumL1Files;
  options.max_bytes_for_level_base =
      options.level0_file_num_compaction_trigger *
      options.target_file_size_base;
  options.max_bytes_for_level_multiplier = 2;
  options.compression = kNoCompression;

8758 8759 8760 8761 8762 8763 8764
  env_->SetBackgroundThreads(1, Env::HIGH);
  env_->SetBackgroundThreads(1, Env::LOW);
  // stop the compaction thread until we simulate the file creation failure.
  SleepingBackgroundTask sleeping_task_low;
  env_->Schedule(&SleepingBackgroundTask::DoSleepTask, &sleeping_task_low,
                 Env::Priority::LOW);

8765 8766
  options.env = env_;

L
Lei Jin 已提交
8767
  DestroyAndReopen(options);
8768

I
Igor Canadi 已提交
8769
  const int kNumInsertedKeys =
8770 8771
      options.level0_file_num_compaction_trigger *
      (options.max_write_buffer_number - 1) *
8772
      kKeysPerBuffer;
8773 8774 8775 8776

  Random rnd(301);
  std::vector<std::string> keys;
  std::vector<std::string> values;
I
Igor Canadi 已提交
8777
  for (int k = 0; k < kNumInsertedKeys; ++k) {
8778 8779 8780 8781 8782
    keys.emplace_back(RandomString(&rnd, kKeySize));
    values.emplace_back(RandomString(&rnd, kKvSize - kKeySize));
    ASSERT_OK(Put(Slice(keys[k]), Slice(values[k])));
  }

8783 8784 8785 8786 8787
  dbfull()->TEST_FlushMemTable(true);
  // Make sure the number of L0 files can trigger compaction.
  ASSERT_GE(NumTableFilesAtLevel(0),
            options.level0_file_num_compaction_trigger);

8788
  auto previous_num_level0_files = NumTableFilesAtLevel(0);
8789

8790 8791 8792 8793
  // Fail the first file creation.
  env_->non_writable_count_ = 1;
  sleeping_task_low.WakeUp();
  sleeping_task_low.WaitUntilDone();
8794

8795 8796
  // Expect compaction to fail here as one file will fail its
  // creation.
8797
  ASSERT_TRUE(!dbfull()->TEST_WaitForCompact().ok());
8798

8799 8800
  // Verify L0 -> L1 compaction does fail.
  ASSERT_EQ(NumTableFilesAtLevel(1), 0);
8801

8802
  // Verify all L0 files are still there.
8803
  ASSERT_EQ(NumTableFilesAtLevel(0), previous_num_level0_files);
8804 8805

  // All key-values must exist after compaction fails.
I
Igor Canadi 已提交
8806
  for (int k = 0; k < kNumInsertedKeys; ++k) {
8807 8808 8809
    ASSERT_EQ(values[k], Get(keys[k]));
  }

8810
  env_->non_writable_count_ = 0;
8811

8812
  // Make sure RocksDB will not get into corrupted state.
L
Lei Jin 已提交
8813
  Reopen(options);
8814 8815

  // Verify again after reopen.
I
Igor Canadi 已提交
8816
  for (int k = 0; k < kNumInsertedKeys; ++k) {
8817 8818 8819 8820
    ASSERT_EQ(values[k], Get(keys[k]));
  }
}

I
Igor Sugak 已提交
8821
TEST_F(DBTest, DynamicMiscOptions) {
8822 8823 8824 8825 8826 8827 8828
  // Test max_sequential_skip_in_iterations
  Options options;
  options.env = env_;
  options.create_if_missing = true;
  options.max_sequential_skip_in_iterations = 16;
  options.compression = kNoCompression;
  options.statistics = rocksdb::CreateDBStatistics();
L
Lei Jin 已提交
8829
  DestroyAndReopen(options);
8830 8831 8832 8833 8834 8835 8836 8837 8838 8839 8840 8841 8842 8843 8844 8845 8846 8847 8848 8849 8850 8851 8852 8853

  auto assert_reseek_count = [this, &options](int key_start, int num_reseek) {
    int key0 = key_start;
    int key1 = key_start + 1;
    int key2 = key_start + 2;
    Random rnd(301);
    ASSERT_OK(Put(Key(key0), RandomString(&rnd, 8)));
    for (int i = 0; i < 10; ++i) {
      ASSERT_OK(Put(Key(key1), RandomString(&rnd, 8)));
    }
    ASSERT_OK(Put(Key(key2), RandomString(&rnd, 8)));
    std::unique_ptr<Iterator> iter(db_->NewIterator(ReadOptions()));
    iter->Seek(Key(key1));
    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ(iter->key().compare(Key(key1)), 0);
    iter->Next();
    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ(iter->key().compare(Key(key2)), 0);
    ASSERT_EQ(num_reseek,
              TestGetTickerCount(options, NUMBER_OF_RESEEKS_IN_ITERATION));
  };
  // No reseek
  assert_reseek_count(100, 0);

8854
  ASSERT_OK(dbfull()->SetOptions({
8855 8856 8857 8858 8859 8860 8861
    {"max_sequential_skip_in_iterations", "4"}
  }));
  // Clear memtable and make new option effective
  dbfull()->TEST_FlushMemTable(true);
  // Trigger reseek
  assert_reseek_count(200, 1);

8862
  ASSERT_OK(dbfull()->SetOptions({
8863 8864 8865 8866 8867 8868 8869 8870
    {"max_sequential_skip_in_iterations", "16"}
  }));
  // Clear memtable and make new option effective
  dbfull()->TEST_FlushMemTable(true);
  // No reseek
  assert_reseek_count(300, 1);
}

I
Igor Sugak 已提交
8871
TEST_F(DBTest, DontDeletePendingOutputs) {
I
Igor Canadi 已提交
8872 8873 8874 8875 8876 8877 8878 8879
  Options options;
  options.env = env_;
  options.create_if_missing = true;
  DestroyAndReopen(options);

  // Every time we write to a table file, call FOF/POF with full DB scan. This
  // will make sure our pending_outputs_ protection work correctly
  std::function<void()> purge_obsolete_files_function = [&]() {
8880
    JobContext job_context(0);
I
Igor Canadi 已提交
8881 8882 8883 8884
    dbfull()->TEST_LockMutex();
    dbfull()->FindObsoleteFiles(&job_context, true /*force*/);
    dbfull()->TEST_UnlockMutex();
    dbfull()->PurgeObsoleteFiles(job_context);
Y
Yueh-Hsuan Chiang 已提交
8885
    job_context.Clean();
I
Igor Canadi 已提交
8886 8887 8888 8889 8890 8891 8892 8893 8894 8895 8896 8897 8898 8899 8900 8901 8902
  };

  env_->table_write_callback_ = &purge_obsolete_files_function;

  for (int i = 0; i < 2; ++i) {
    ASSERT_OK(Put("a", "begin"));
    ASSERT_OK(Put("z", "end"));
    ASSERT_OK(Flush());
  }

  // If pending output guard does not work correctly, PurgeObsoleteFiles() will
  // delete the file that Compaction is trying to create, causing this: error
  // db/db_test.cc:975: IO error:
  // /tmp/rocksdbtest-1552237650/db_test/000009.sst: No such file or directory
  Compact("a", "b");
}

I
Igor Sugak 已提交
8903
TEST_F(DBTest, DontDeleteMovedFile) {
I
Igor Canadi 已提交
8904 8905 8906 8907 8908 8909 8910 8911 8912 8913 8914 8915 8916 8917 8918 8919 8920 8921 8922 8923 8924 8925 8926 8927 8928 8929 8930 8931 8932
  // This test triggers move compaction and verifies that the file is not
  // deleted when it's part of move compaction
  Options options = CurrentOptions();
  options.env = env_;
  options.create_if_missing = true;
  options.max_bytes_for_level_base = 1024 * 1024;  // 1 MB
  options.level0_file_num_compaction_trigger =
      2;  // trigger compaction when we have 2 files
  DestroyAndReopen(options);

  Random rnd(301);
  // Create two 1MB sst files
  for (int i = 0; i < 2; ++i) {
    // Create 1MB sst file
    for (int j = 0; j < 100; ++j) {
      ASSERT_OK(Put(Key(i * 50 + j), RandomString(&rnd, 10 * 1024)));
    }
    ASSERT_OK(Flush());
  }
  // this should execute both L0->L1 and L1->(move)->L2 compactions
  dbfull()->TEST_WaitForCompact();
  ASSERT_EQ("0,0,1", FilesPerLevel(0));

  // If the moved file is actually deleted (the move-safeguard in
  // ~Version::Version() is not there), we get this failure:
  // Corruption: Can't access /000009.sst
  Reopen(options);
}

I
Igor Sugak 已提交
8933
TEST_F(DBTest, DeleteMovedFileAfterCompaction) {
I
Igor Canadi 已提交
8934 8935 8936 8937 8938 8939 8940 8941 8942 8943 8944 8945
  // iter 1 -- delete_obsolete_files_period_micros == 0
  for (int iter = 0; iter < 2; ++iter) {
    // This test triggers move compaction and verifies that the file is not
    // deleted when it's part of move compaction
    Options options = CurrentOptions();
    options.env = env_;
    if (iter == 1) {
      options.delete_obsolete_files_period_micros = 0;
    }
    options.create_if_missing = true;
    options.level0_file_num_compaction_trigger =
        2;  // trigger compaction when we have 2 files
8946 8947
    OnFileDeletionListener* listener = new OnFileDeletionListener();
    options.listeners.emplace_back(listener);
I
Igor Canadi 已提交
8948 8949 8950 8951 8952 8953 8954 8955 8956 8957 8958 8959 8960 8961 8962 8963 8964 8965 8966 8967 8968 8969 8970 8971 8972 8973 8974 8975 8976 8977 8978 8979 8980 8981 8982 8983 8984 8985 8986 8987 8988 8989 8990 8991 8992 8993 8994 8995 8996 8997 8998 8999
    DestroyAndReopen(options);

    Random rnd(301);
    // Create two 1MB sst files
    for (int i = 0; i < 2; ++i) {
      // Create 1MB sst file
      for (int j = 0; j < 100; ++j) {
        ASSERT_OK(Put(Key(i * 50 + j), RandomString(&rnd, 10 * 1024)));
      }
      ASSERT_OK(Flush());
    }
    // this should execute L0->L1
    dbfull()->TEST_WaitForCompact();
    ASSERT_EQ("0,1", FilesPerLevel(0));

    // block compactions
    SleepingBackgroundTask sleeping_task;
    env_->Schedule(&SleepingBackgroundTask::DoSleepTask, &sleeping_task,
                   Env::Priority::LOW);

    options.max_bytes_for_level_base = 1024 * 1024;  // 1 MB
    Reopen(options);
    std::unique_ptr<Iterator> iterator(db_->NewIterator(ReadOptions()));
    ASSERT_EQ("0,1", FilesPerLevel(0));
    // let compactions go
    sleeping_task.WakeUp();
    sleeping_task.WaitUntilDone();

    // this should execute L1->L2 (move)
    dbfull()->TEST_WaitForCompact();

    ASSERT_EQ("0,0,1", FilesPerLevel(0));

    std::vector<LiveFileMetaData> metadata;
    db_->GetLiveFilesMetaData(&metadata);
    ASSERT_EQ(metadata.size(), 1U);
    auto moved_file_name = metadata[0].name;

    // Create two more 1MB sst files
    for (int i = 0; i < 2; ++i) {
      // Create 1MB sst file
      for (int j = 0; j < 100; ++j) {
        ASSERT_OK(Put(Key(i * 50 + j + 100), RandomString(&rnd, 10 * 1024)));
      }
      ASSERT_OK(Flush());
    }
    // this should execute both L0->L1 and L1->L2 (merge with previous file)
    dbfull()->TEST_WaitForCompact();

    ASSERT_EQ("0,0,2", FilesPerLevel(0));

    // iterator is holding the file
9000
    ASSERT_TRUE(env_->FileExists(dbname_ + moved_file_name));
I
Igor Canadi 已提交
9001

9002
    listener->SetExpectedFileName(dbname_ + moved_file_name);
I
Igor Canadi 已提交
9003 9004 9005
    iterator.reset();

    // this file should have been compacted away
9006 9007
    ASSERT_TRUE(!env_->FileExists(dbname_ + moved_file_name));
    listener->VerifyMatchedCount(1);
I
Igor Canadi 已提交
9008 9009 9010
  }
}

I
Igor Sugak 已提交
9011
TEST_F(DBTest, OptimizeFiltersForHits) {
9012
  Options options = CurrentOptions();
9013 9014
  options.write_buffer_size = 256 * 1024;
  options.target_file_size_base = 256 * 1024;
9015 9016 9017
  options.level0_file_num_compaction_trigger = 2;
  options.level0_slowdown_writes_trigger = 2;
  options.level0_stop_writes_trigger = 4;
9018
  options.max_bytes_for_level_base = 256 * 1024;
9019 9020 9021 9022 9023 9024 9025 9026 9027 9028 9029 9030 9031 9032 9033 9034 9035 9036 9037 9038 9039 9040 9041 9042 9043 9044 9045 9046 9047 9048 9049 9050 9051 9052 9053 9054 9055 9056 9057 9058 9059 9060 9061 9062
  options.max_write_buffer_number = 2;
  options.max_background_compactions = 8;
  options.max_background_flushes = 8;
  options.compaction_style = kCompactionStyleLevel;
  BlockBasedTableOptions bbto;
  bbto.filter_policy.reset(NewBloomFilterPolicy(10, true));
  bbto.whole_key_filtering = true;
  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
  options.optimize_filters_for_hits = true;
  options.statistics = rocksdb::CreateDBStatistics();
  CreateAndReopenWithCF({"mypikachu"}, options);

  int numkeys = 200000;
  for (int i = 0; i < 20; i += 2) {
    for (int j = i; j < numkeys; j += 20) {
      ASSERT_OK(Put(1, Key(j), "val"));
    }
  }


  ASSERT_OK(Flush(1));
  dbfull()->TEST_WaitForCompact();

  for (int i = 1; i < numkeys; i += 2) {
    ASSERT_EQ(Get(1, Key(i)), "NOT_FOUND");
  }

  ASSERT_EQ(0, TestGetTickerCount(options, GET_HIT_L0));
  ASSERT_EQ(0, TestGetTickerCount(options, GET_HIT_L1));
  ASSERT_EQ(0, TestGetTickerCount(options, GET_HIT_L2_AND_UP));

  // When the skip_filters_on_last_level is ON, the last level which has
  // most of the keys does not use bloom filters. We end up using
  // bloom filters in a very small number of cases. Without the flag.
  // this number would be close to 150000 (all the key at the last level) +
  // some use in the upper levels
  //
  ASSERT_GT(90000, TestGetTickerCount(options, BLOOM_FILTER_USEFUL));

  for (int i = 0; i < numkeys; i += 2) {
    ASSERT_EQ(Get(1, Key(i)), "val");
  }
}

I
Igor Sugak 已提交
9063
TEST_F(DBTest, L0L1L2AndUpHitCounter) {
9064 9065 9066 9067 9068 9069 9070 9071 9072 9073 9074 9075 9076 9077 9078 9079 9080 9081 9082 9083 9084 9085 9086 9087 9088 9089 9090 9091 9092 9093 9094 9095 9096 9097 9098 9099 9100
  Options options = CurrentOptions();
  options.write_buffer_size = 32 * 1024;
  options.target_file_size_base = 32 * 1024;
  options.level0_file_num_compaction_trigger = 2;
  options.level0_slowdown_writes_trigger = 2;
  options.level0_stop_writes_trigger = 4;
  options.max_bytes_for_level_base = 64 * 1024;
  options.max_write_buffer_number = 2;
  options.max_background_compactions = 8;
  options.max_background_flushes = 8;
  options.statistics = rocksdb::CreateDBStatistics();
  CreateAndReopenWithCF({"mypikachu"}, options);

  int numkeys = 20000;
  for (int i = 0; i < numkeys; i++) {
    ASSERT_OK(Put(1, Key(i), "val"));
  }
  ASSERT_EQ(0, TestGetTickerCount(options, GET_HIT_L0));
  ASSERT_EQ(0, TestGetTickerCount(options, GET_HIT_L1));
  ASSERT_EQ(0, TestGetTickerCount(options, GET_HIT_L2_AND_UP));

  ASSERT_OK(Flush(1));
  dbfull()->TEST_WaitForCompact();

  for (int i = 0; i < numkeys; i++) {
    ASSERT_EQ(Get(1, Key(i)), "val");
  }

  ASSERT_GT(TestGetTickerCount(options, GET_HIT_L0), 100);
  ASSERT_GT(TestGetTickerCount(options, GET_HIT_L1), 100);
  ASSERT_GT(TestGetTickerCount(options, GET_HIT_L2_AND_UP), 100);

  ASSERT_EQ(numkeys, TestGetTickerCount(options, GET_HIT_L0) +
                         TestGetTickerCount(options, GET_HIT_L1) +
                         TestGetTickerCount(options, GET_HIT_L2_AND_UP));
}

I
Igor Sugak 已提交
9101
TEST_F(DBTest, EncodeDecompressedBlockSizeTest) {
9102 9103 9104 9105 9106 9107 9108
  // iter 0 -- zlib
  // iter 1 -- bzip2
  // iter 2 -- lz4
  // iter 3 -- lz4HC
  CompressionType compressions[] = {kZlibCompression, kBZip2Compression,
                                    kLZ4Compression,  kLZ4HCCompression};
  for (int iter = 0; iter < 4; ++iter) {
9109 9110 9111
    if (!CompressionTypeSupported(compressions[iter])) {
      continue;
    }
9112 9113 9114 9115 9116 9117 9118 9119 9120 9121 9122 9123 9124 9125 9126 9127 9128 9129 9130 9131 9132 9133 9134 9135 9136 9137 9138 9139 9140 9141 9142 9143 9144 9145
    // first_table_version 1 -- generate with table_version == 1, read with
    // table_version == 2
    // first_table_version 2 -- generate with table_version == 2, read with
    // table_version == 1
    for (int first_table_version = 1; first_table_version <= 2;
         ++first_table_version) {
      BlockBasedTableOptions table_options;
      table_options.format_version = first_table_version;
      table_options.filter_policy.reset(NewBloomFilterPolicy(10));
      Options options = CurrentOptions();
      options.table_factory.reset(NewBlockBasedTableFactory(table_options));
      options.create_if_missing = true;
      options.compression = compressions[iter];
      DestroyAndReopen(options);

      int kNumKeysWritten = 100000;

      Random rnd(301);
      for (int i = 0; i < kNumKeysWritten; ++i) {
        // compressible string
        ASSERT_OK(Put(Key(i), RandomString(&rnd, 128) + std::string(128, 'a')));
      }

      table_options.format_version = first_table_version == 1 ? 2 : 1;
      options.table_factory.reset(NewBlockBasedTableFactory(table_options));
      Reopen(options);
      for (int i = 0; i < kNumKeysWritten; ++i) {
        auto r = Get(Key(i));
        ASSERT_EQ(r.substr(128), std::string(128, 'a'));
      }
    }
  }
}

I
Igor Sugak 已提交
9146
TEST_F(DBTest, MutexWaitStats) {
9147 9148 9149 9150 9151 9152 9153 9154 9155 9156 9157 9158 9159 9160
  Options options = CurrentOptions();
  options.create_if_missing = true;
  options.statistics = rocksdb::CreateDBStatistics();
  CreateAndReopenWithCF({"pikachu"}, options);
  const int64_t kMutexWaitDelay = 100;
  ThreadStatusUtil::TEST_SetStateDelay(
      ThreadStatus::STATE_MUTEX_WAIT, kMutexWaitDelay);
  ASSERT_OK(Put("hello", "rocksdb"));
  ASSERT_GE(TestGetTickerCount(
            options, DB_MUTEX_WAIT_MICROS), kMutexWaitDelay);
  ThreadStatusUtil::TEST_SetStateDelay(
      ThreadStatus::STATE_MUTEX_WAIT, 0);
}

I
Igor Canadi 已提交
9161 9162 9163 9164 9165 9166 9167 9168 9169 9170 9171 9172 9173 9174
// This reproduces a bug where we don't delete a file because when it was
// supposed to be deleted, it was blocked by pending_outputs
// Consider:
// 1. current file_number is 13
// 2. compaction (1) starts, blocks deletion of all files starting with 13
// (pending outputs)
// 3. file 13 is created by compaction (2)
// 4. file 13 is consumed by compaction (3) and file 15 was created. Since file
// 13 has no references, it is put into VersionSet::obsolete_files_
// 5. FindObsoleteFiles() gets file 13 from VersionSet::obsolete_files_. File 13
// is deleted from obsolete_files_ set.
// 6. PurgeObsoleteFiles() tries to delete file 13, but this file is blocked by
// pending outputs since compaction (1) is still running. It is not deleted and
// it is not present in obsolete_files_ anymore. Therefore, we never delete it.
I
Igor Sugak 已提交
9175
TEST_F(DBTest, DeleteObsoleteFilesPendingOutputs) {
I
Igor Canadi 已提交
9176 9177 9178 9179 9180 9181 9182 9183
  Options options = CurrentOptions();
  options.env = env_;
  options.write_buffer_size = 2 * 1024 * 1024;     // 2 MB
  options.max_bytes_for_level_base = 1024 * 1024;  // 1 MB
  options.level0_file_num_compaction_trigger =
      2;  // trigger compaction when we have 2 files
  options.max_background_flushes = 2;
  options.max_background_compactions = 2;
9184 9185 9186 9187

  OnFileDeletionListener* listener = new OnFileDeletionListener();
  options.listeners.emplace_back(listener);

I
Igor Canadi 已提交
9188 9189 9190 9191 9192 9193 9194 9195 9196 9197 9198 9199 9200 9201 9202 9203 9204 9205 9206 9207 9208 9209 9210 9211 9212 9213 9214 9215 9216 9217 9218 9219 9220 9221 9222 9223 9224 9225 9226 9227 9228 9229 9230 9231 9232 9233 9234 9235
  Reopen(options);

  Random rnd(301);
  // Create two 1MB sst files
  for (int i = 0; i < 2; ++i) {
    // Create 1MB sst file
    for (int j = 0; j < 100; ++j) {
      ASSERT_OK(Put(Key(i * 50 + j), RandomString(&rnd, 10 * 1024)));
    }
    ASSERT_OK(Flush());
  }
  // this should execute both L0->L1 and L1->(move)->L2 compactions
  dbfull()->TEST_WaitForCompact();
  ASSERT_EQ("0,0,1", FilesPerLevel(0));

  SleepingBackgroundTask blocking_thread;
  port::Mutex mutex_;
  bool already_blocked(false);

  // block the flush
  std::function<void()> block_first_time = [&]() {
    bool blocking = false;
    {
      MutexLock l(&mutex_);
      if (!already_blocked) {
        blocking = true;
        already_blocked = true;
      }
    }
    if (blocking) {
      blocking_thread.DoSleep();
    }
  };
  env_->table_write_callback_ = &block_first_time;
  // Create 1MB sst file
  for (int j = 0; j < 256; ++j) {
    ASSERT_OK(Put(Key(j), RandomString(&rnd, 10 * 1024)));
  }
  // this should trigger a flush, which is blocked with block_first_time
  // pending_file is protecting all the files created after

  ASSERT_OK(dbfull()->TEST_CompactRange(2, nullptr, nullptr));

  ASSERT_EQ("0,0,0,1", FilesPerLevel(0));
  std::vector<LiveFileMetaData> metadata;
  db_->GetLiveFilesMetaData(&metadata);
  ASSERT_EQ(metadata.size(), 1U);
  auto file_on_L2 = metadata[0].name;
9236
  listener->SetExpectedFileName(dbname_ + file_on_L2);
I
Igor Canadi 已提交
9237

9238 9239
  ASSERT_OK(dbfull()->TEST_CompactRange(3, nullptr, nullptr, nullptr,
                                        true /* disallow trivial move */));
I
Igor Canadi 已提交
9240 9241 9242 9243 9244 9245 9246 9247 9248 9249 9250 9251
  ASSERT_EQ("0,0,0,0,1", FilesPerLevel(0));

  // finish the flush!
  blocking_thread.WakeUp();
  blocking_thread.WaitUntilDone();
  dbfull()->TEST_WaitForFlushMemTable();
  ASSERT_EQ("1,0,0,0,1", FilesPerLevel(0));

  metadata.clear();
  db_->GetLiveFilesMetaData(&metadata);
  ASSERT_EQ(metadata.size(), 2U);

9252
  // This file should have been deleted during last compaction
9253 9254
  ASSERT_TRUE(!env_->FileExists(dbname_ + file_on_L2));
  listener->VerifyMatchedCount(1);
I
Igor Canadi 已提交
9255 9256
}

I
Igor Sugak 已提交
9257
TEST_F(DBTest, CloseSpeedup) {
9258 9259 9260 9261 9262 9263 9264 9265 9266 9267 9268 9269 9270 9271 9272 9273 9274 9275 9276 9277 9278 9279 9280 9281 9282 9283 9284 9285 9286 9287 9288 9289 9290 9291 9292 9293 9294 9295 9296 9297 9298 9299 9300 9301 9302 9303 9304 9305 9306 9307 9308 9309
  Options options = CurrentOptions();
  options.compaction_style = kCompactionStyleLevel;
  options.write_buffer_size = 100 << 10;  // 100KB
  options.level0_file_num_compaction_trigger = 2;
  options.num_levels = 4;
  options.max_bytes_for_level_base = 400 * 1024;
  options.max_write_buffer_number = 16;

  // Block background threads
  env_->SetBackgroundThreads(1, Env::LOW);
  env_->SetBackgroundThreads(1, Env::HIGH);
  SleepingBackgroundTask sleeping_task_low;
  env_->Schedule(&SleepingBackgroundTask::DoSleepTask, &sleeping_task_low,
                 Env::Priority::LOW);
  SleepingBackgroundTask sleeping_task_high;
  env_->Schedule(&SleepingBackgroundTask::DoSleepTask, &sleeping_task_high,
                 Env::Priority::HIGH);

  std::vector<std::string> filenames;
  env_->GetChildren(dbname_, &filenames);
  // Delete archival files.
  for (size_t i = 0; i < filenames.size(); ++i) {
    env_->DeleteFile(dbname_ + "/" + filenames[i]);
  }
  env_->DeleteDir(dbname_);
  DestroyAndReopen(options);

  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
  env_->SetBackgroundThreads(1, Env::LOW);
  env_->SetBackgroundThreads(1, Env::HIGH);
  Random rnd(301);
  int key_idx = 0;

  // First three 110KB files are not going to level 2
  // After that, (100K, 200K)
  for (int num = 0; num < 5; num++) {
    GenerateNewFile(&rnd, &key_idx, true);
  }

  ASSERT_EQ(0, GetSstFileCount(dbname_));

  Close();
  ASSERT_EQ(0, GetSstFileCount(dbname_));

  // Unblock background threads
  sleeping_task_high.WakeUp();
  sleeping_task_high.WaitUntilDone();
  sleeping_task_low.WakeUp();
  sleeping_task_low.WaitUntilDone();

  Destroy(options);
}
9310 9311 9312 9313 9314 9315 9316 9317 9318 9319

class DelayedMergeOperator : public AssociativeMergeOperator {
 private:
  DBTest* db_test_;

 public:
  explicit DelayedMergeOperator(DBTest* d) : db_test_(d) {}
  virtual bool Merge(const Slice& key, const Slice* existing_value,
                     const Slice& value, std::string* new_value,
                     Logger* logger) const override {
S
sdong 已提交
9320
    db_test_->env_->addon_time_.fetch_add(1000);
9321 9322 9323 9324 9325 9326 9327 9328 9329 9330 9331 9332 9333 9334
    return true;
  }

  virtual const char* Name() const override { return "DelayedMergeOperator"; }
};

TEST_F(DBTest, MergeTestTime) {
  std::string one, two, three;
  PutFixed64(&one, 1);
  PutFixed64(&two, 2);
  PutFixed64(&three, 3);

  // Enable time profiling
  SetPerfLevel(kEnableTime);
S
sdong 已提交
9335
  this->env_->addon_time_.store(0);
9336 9337 9338 9339 9340 9341 9342 9343 9344 9345 9346 9347 9348 9349 9350 9351 9352 9353 9354 9355
  Options options;
  options = CurrentOptions(options);
  options.statistics = rocksdb::CreateDBStatistics();
  options.merge_operator.reset(new DelayedMergeOperator(this));
  DestroyAndReopen(options);

  ASSERT_EQ(TestGetTickerCount(options, MERGE_OPERATION_TOTAL_TIME), 0);
  db_->Put(WriteOptions(), "foo", one);
  ASSERT_OK(Flush());
  ASSERT_OK(db_->Merge(WriteOptions(), "foo", two));
  ASSERT_OK(Flush());
  ASSERT_OK(db_->Merge(WriteOptions(), "foo", three));
  ASSERT_OK(Flush());

  ReadOptions opt;
  opt.verify_checksums = true;
  opt.snapshot = nullptr;
  std::string result;
  db_->Get(opt, "foo", &result);

S
sdong 已提交
9356 9357
  ASSERT_LT(TestGetTickerCount(options, MERGE_OPERATION_TOTAL_TIME), 2800000);
  ASSERT_GT(TestGetTickerCount(options, MERGE_OPERATION_TOTAL_TIME), 1200000);
9358 9359 9360 9361 9362 9363 9364 9365 9366 9367 9368

  ReadOptions read_options;
  std::unique_ptr<Iterator> iter(db_->NewIterator(read_options));
  int count = 0;
  for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
    ASSERT_OK(iter->status());
    ++count;
  }

  ASSERT_EQ(1, count);

S
sdong 已提交
9369 9370
  ASSERT_LT(TestGetTickerCount(options, MERGE_OPERATION_TOTAL_TIME), 6000000);
  ASSERT_GT(TestGetTickerCount(options, MERGE_OPERATION_TOTAL_TIME), 3200000);
9371 9372 9373 9374 9375 9376 9377 9378 9379 9380 9381 9382 9383 9384 9385 9386 9387 9388 9389 9390 9391 9392 9393 9394 9395 9396 9397 9398 9399 9400 9401 9402 9403 9404 9405 9406 9407 9408 9409 9410
}

TEST_F(DBTest, MergeCompactionTimeTest) {
  SetPerfLevel(kEnableTime);
  Options options;
  options = CurrentOptions(options);
  options.compaction_filter_factory = std::make_shared<KeepFilterFactory>();
  options.statistics = rocksdb::CreateDBStatistics();
  options.merge_operator.reset(new DelayedMergeOperator(this));
  options.compaction_style = kCompactionStyleUniversal;
  DestroyAndReopen(options);

  for (int i = 0; i < 1000; i++) {
    ASSERT_OK(db_->Merge(WriteOptions(), "foo", "TEST"));
    ASSERT_OK(Flush());
  }
  dbfull()->TEST_WaitForFlushMemTable();
  dbfull()->TEST_WaitForCompact();

  ASSERT_NE(TestGetTickerCount(options, MERGE_OPERATION_TOTAL_TIME), 0);
}

TEST_F(DBTest, FilterCompactionTimeTest) {
  Options options;
  options.compaction_filter_factory =
      std::make_shared<DelayFilterFactory>(this);
  options.disable_auto_compactions = true;
  options.create_if_missing = true;
  options.statistics = rocksdb::CreateDBStatistics();
  options = CurrentOptions(options);
  DestroyAndReopen(options);

  // put some data
  for (int table = 0; table < 4; ++table) {
    for (int i = 0; i < 10 + table; ++i) {
      Put(ToString(table * 100 + i), "val");
    }
    Flush();
  }

9411
  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
9412 9413 9414 9415 9416 9417 9418 9419 9420 9421
  ASSERT_EQ(0U, CountLiveFiles());

  Reopen(options);

  Iterator* itr = db_->NewIterator(ReadOptions());
  itr->SeekToFirst();
  ASSERT_NE(TestGetTickerCount(options, FILTER_OPERATION_TOTAL_TIME), 0);
  delete itr;
}

9422 9423 9424 9425 9426 9427 9428 9429 9430 9431 9432 9433 9434 9435 9436
TEST_F(DBTest, TestLogCleanup) {
  Options options = CurrentOptions();
  options.write_buffer_size = 64 * 1024;  // very small
  // only two memtables allowed ==> only two log files
  options.max_write_buffer_number = 2;
  Reopen(options);

  for (int i = 0; i < 100000; ++i) {
    Put(Key(i), "val");
    // only 2 memtables will be alive, so logs_to_free needs to always be below
    // 2
    ASSERT_LT(dbfull()->TEST_LogsToFreeSize(), static_cast<size_t>(3));
  }
}

9437 9438 9439 9440 9441 9442 9443 9444 9445 9446 9447
TEST_F(DBTest, EmptyCompactedDB) {
  Options options;
  options.max_open_files = -1;
  options = CurrentOptions(options);
  Close();
  ASSERT_OK(ReadOnlyReopen(options));
  Status s = Put("new", "value");
  ASSERT_TRUE(s.IsNotSupported());
  Close();
}

9448
TEST_F(DBTest, CompressLevelCompaction) {
9449 9450 9451
  if (!Zlib_Supported()) {
    return;
  }
9452 9453 9454 9455 9456 9457 9458 9459 9460 9461 9462 9463 9464 9465 9466
  Options options = CurrentOptions();
  options.compaction_style = kCompactionStyleLevel;
  options.write_buffer_size = 100 << 10;  // 100KB
  options.level0_file_num_compaction_trigger = 2;
  options.num_levels = 4;
  options.max_bytes_for_level_base = 400 * 1024;
  // First two levels have no compression, so that a trivial move between
  // them will be allowed. Level 2 has Zlib compression so that a trivial
  // move to level 3 will not be allowed
  options.compression_per_level = {kNoCompression, kNoCompression,
                                   kZlibCompression};
  int matches = 0, didnt_match = 0, trivial_move = 0, non_trivial = 0;

  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "Compaction::InputCompressionMatchesOutput:Matches",
9467
      [&](void* arg) { matches++; });
9468 9469
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "Compaction::InputCompressionMatchesOutput:DidntMatch",
9470
      [&](void* arg) { didnt_match++; });
9471
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
9472 9473
      "DBImpl::BackgroundCompaction:NonTrivial",
      [&](void* arg) { non_trivial++; });
9474
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
9475 9476
      "DBImpl::BackgroundCompaction:TrivialMove",
      [&](void* arg) { trivial_move++; });
9477 9478 9479 9480 9481 9482 9483 9484 9485 9486 9487 9488 9489 9490 9491 9492 9493 9494 9495 9496 9497 9498 9499 9500 9501 9502 9503 9504 9505 9506 9507 9508 9509 9510 9511 9512 9513 9514 9515 9516 9517 9518 9519 9520 9521 9522 9523 9524 9525 9526 9527 9528 9529 9530
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  Reopen(options);

  Random rnd(301);
  int key_idx = 0;

  // First three 110KB files are going to level 0
  // After that, (100K, 200K)
  for (int num = 0; num < 3; num++) {
    GenerateNewFile(&rnd, &key_idx);
  }

  // Another 110KB triggers a compaction to 400K file to fill up level 0
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(4, GetSstFileCount(dbname_));

  // (1, 4)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4", FilesPerLevel(0));

  // (1, 4, 1)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4,1", FilesPerLevel(0));

  // (1, 4, 2)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4,2", FilesPerLevel(0));

  // (1, 4, 3)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4,3", FilesPerLevel(0));

  // (1, 4, 4)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4,4", FilesPerLevel(0));

  // (1, 4, 5)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4,5", FilesPerLevel(0));

  // (1, 4, 6)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4,6", FilesPerLevel(0));

  // (1, 4, 7)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4,7", FilesPerLevel(0));

  // (1, 4, 8)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4,8", FilesPerLevel(0));

  ASSERT_EQ(matches, 12);
9531 9532 9533 9534
  // Currently, the test relies on the number of calls to
  // InputCompressionMatchesOutput() per compaction.
  const int kCallsToInputCompressionMatch = 2;
  ASSERT_EQ(didnt_match, 8 * kCallsToInputCompressionMatch);
9535 9536 9537 9538 9539 9540 9541 9542 9543 9544 9545 9546 9547 9548 9549 9550 9551 9552 9553 9554 9555 9556
  ASSERT_EQ(trivial_move, 12);
  ASSERT_EQ(non_trivial, 8);

  rocksdb::SyncPoint::GetInstance()->DisableProcessing();

  for (int i = 0; i < key_idx; i++) {
    auto v = Get(Key(i));
    ASSERT_NE(v, "NOT_FOUND");
    ASSERT_TRUE(v.size() == 1 || v.size() == 10000);
  }

  Reopen(options);

  for (int i = 0; i < key_idx; i++) {
    auto v = Get(Key(i));
    ASSERT_NE(v, "NOT_FOUND");
    ASSERT_TRUE(v.size() == 1 || v.size() == 10000);
  }

  Destroy(options);
}

9557 9558 9559 9560 9561 9562 9563 9564 9565 9566 9567 9568 9569 9570 9571 9572 9573 9574 9575 9576 9577 9578 9579 9580 9581 9582 9583 9584 9585 9586 9587 9588 9589 9590 9591 9592 9593 9594 9595 9596 9597 9598 9599 9600 9601 9602 9603 9604 9605 9606 9607 9608
class CountingDeleteTabPropCollector : public TablePropertiesCollector {
 public:
  const char* Name() const override { return "CountingDeleteTabPropCollector"; }

  Status AddUserKey(const Slice& user_key, const Slice& value, EntryType type,
                    SequenceNumber seq, uint64_t file_size) override {
    if (type == kEntryDelete) {
      num_deletes_++;
    }
    return Status::OK();
  }

  bool NeedCompact() const override { return num_deletes_ > 10; }

  UserCollectedProperties GetReadableProperties() const override {
    return UserCollectedProperties{};
  }

  Status Finish(UserCollectedProperties* properties) override {
    *properties =
        UserCollectedProperties{{"num_delete", ToString(num_deletes_)}};
    return Status::OK();
  }

 private:
  uint32_t num_deletes_ = 0;
};

class CountingDeleteTabPropCollectorFactory
    : public TablePropertiesCollectorFactory {
 public:
  virtual TablePropertiesCollector* CreateTablePropertiesCollector() override {
    return new CountingDeleteTabPropCollector();
  }
  const char* Name() const override {
    return "CountingDeleteTabPropCollectorFactory";
  }
};

TEST_F(DBTest, TablePropertiesNeedCompactTest) {
  Random rnd(301);

  Options options;
  options.create_if_missing = true;
  options.write_buffer_size = 4096;
  options.max_write_buffer_number = 8;
  options.level0_file_num_compaction_trigger = 2;
  options.level0_slowdown_writes_trigger = 2;
  options.level0_stop_writes_trigger = 4;
  options.target_file_size_base = 2048;
  options.max_bytes_for_level_base = 10240;
  options.max_bytes_for_level_multiplier = 4;
S
sdong 已提交
9609
  options.soft_rate_limit = 1.1;
9610 9611 9612 9613 9614 9615 9616 9617 9618 9619 9620 9621 9622 9623 9624 9625 9626 9627 9628 9629 9630 9631 9632 9633 9634 9635 9636 9637 9638 9639 9640 9641 9642 9643 9644 9645 9646 9647 9648 9649 9650 9651 9652 9653 9654 9655 9656 9657 9658 9659 9660 9661 9662 9663 9664 9665 9666 9667 9668 9669 9670 9671
  options.num_levels = 8;

  std::shared_ptr<TablePropertiesCollectorFactory> collector_factory(
      new CountingDeleteTabPropCollectorFactory);
  options.table_properties_collector_factories.resize(1);
  options.table_properties_collector_factories[0] = collector_factory;

  DestroyAndReopen(options);

  const int kMaxKey = 1000;
  for (int i = 0; i < kMaxKey; i++) {
    ASSERT_OK(Put(Key(i), RandomString(&rnd, 102)));
    ASSERT_OK(Put(Key(kMaxKey + i), RandomString(&rnd, 102)));
  }
  Flush();
  dbfull()->TEST_WaitForCompact();
  if (NumTableFilesAtLevel(0) == 1) {
    // Clear Level 0 so that when later flush a file with deletions,
    // we don't trigger an organic compaction.
    ASSERT_OK(Put(Key(0), ""));
    ASSERT_OK(Put(Key(kMaxKey * 2), ""));
    Flush();
    dbfull()->TEST_WaitForCompact();
  }
  ASSERT_EQ(NumTableFilesAtLevel(0), 0);

  {
    int c = 0;
    std::unique_ptr<Iterator> iter(db_->NewIterator(ReadOptions()));
    iter->Seek(Key(kMaxKey - 100));
    while (iter->Valid() && iter->key().compare(Key(kMaxKey + 100)) < 0) {
      iter->Next();
      ++c;
    }
    ASSERT_EQ(c, 200);
  }

  Delete(Key(0));
  for (int i = kMaxKey - 100; i < kMaxKey + 100; i++) {
    Delete(Key(i));
  }
  Delete(Key(kMaxKey * 2));

  Flush();
  dbfull()->TEST_WaitForCompact();

  {
    SetPerfLevel(kEnableCount);
    perf_context.Reset();
    int c = 0;
    std::unique_ptr<Iterator> iter(db_->NewIterator(ReadOptions()));
    iter->Seek(Key(kMaxKey - 100));
    while (iter->Valid() && iter->key().compare(Key(kMaxKey + 100)) < 0) {
      iter->Next();
    }
    ASSERT_EQ(c, 0);
    ASSERT_LT(perf_context.internal_delete_skipped_count, 30u);
    ASSERT_LT(perf_context.internal_key_skipped_count, 30u);
    SetPerfLevel(kDisable);
  }
}

9672
TEST_F(DBTest, SuggestCompactRangeTest) {
9673 9674 9675
  class CompactionFilterFactoryGetContext : public CompactionFilterFactory {
   public:
    virtual std::unique_ptr<CompactionFilter> CreateCompactionFilter(
I
Igor Canadi 已提交
9676
        const CompactionFilter::Context& context) override {
9677 9678 9679 9680 9681 9682 9683 9684 9685
      saved_context = context;
      std::unique_ptr<CompactionFilter> empty_filter;
      return empty_filter;
    }
    const char* Name() const override {
      return "CompactionFilterFactoryGetContext";
    }
    static bool IsManual(CompactionFilterFactory* compaction_filter_factory) {
      return reinterpret_cast<CompactionFilterFactoryGetContext*>(
9686
                 compaction_filter_factory)->saved_context.is_manual_compaction;
9687 9688 9689 9690
    }
    CompactionFilter::Context saved_context;
  };

9691 9692
  Options options = CurrentOptions();
  options.compaction_style = kCompactionStyleLevel;
9693 9694 9695 9696
  options.compaction_filter_factory.reset(
      new CompactionFilterFactoryGetContext());
  options.write_buffer_size = 110 << 10;
  options.level0_file_num_compaction_trigger = 4;
9697
  options.num_levels = 4;
9698 9699 9700 9701
  options.compression = kNoCompression;
  options.max_bytes_for_level_base = 450 << 10;
  options.target_file_size_base = 98 << 10;
  options.max_grandparent_overlap_factor = 1 << 20;  // inf
9702 9703 9704 9705 9706 9707

  Reopen(options);

  Random rnd(301);

  for (int num = 0; num < 3; num++) {
9708
    GenerateNewRandomFile(&rnd);
9709 9710
  }

9711 9712 9713 9714
  GenerateNewRandomFile(&rnd);
  ASSERT_EQ("0,4", FilesPerLevel(0));
  ASSERT_TRUE(!CompactionFilterFactoryGetContext::IsManual(
                   options.compaction_filter_factory.get()));
9715

9716
  GenerateNewRandomFile(&rnd);
9717 9718
  ASSERT_EQ("1,4", FilesPerLevel(0));

9719 9720
  GenerateNewRandomFile(&rnd);
  ASSERT_EQ("2,4", FilesPerLevel(0));
9721

9722 9723
  GenerateNewRandomFile(&rnd);
  ASSERT_EQ("3,4", FilesPerLevel(0));
9724

9725 9726
  GenerateNewRandomFile(&rnd);
  ASSERT_EQ("0,4,4", FilesPerLevel(0));
9727

9728
  GenerateNewRandomFile(&rnd);
9729 9730
  ASSERT_EQ("1,4,4", FilesPerLevel(0));

9731 9732
  GenerateNewRandomFile(&rnd);
  ASSERT_EQ("2,4,4", FilesPerLevel(0));
9733

9734 9735
  GenerateNewRandomFile(&rnd);
  ASSERT_EQ("3,4,4", FilesPerLevel(0));
9736

9737 9738
  GenerateNewRandomFile(&rnd);
  ASSERT_EQ("0,4,8", FilesPerLevel(0));
9739

9740
  GenerateNewRandomFile(&rnd);
9741 9742 9743 9744 9745 9746 9747 9748 9749 9750
  ASSERT_EQ("1,4,8", FilesPerLevel(0));

  // compact it three times
  for (int i = 0; i < 3; ++i) {
    ASSERT_OK(experimental::SuggestCompactRange(db_, nullptr, nullptr));
    dbfull()->TEST_WaitForCompact();
  }

  ASSERT_EQ("0,0,13", FilesPerLevel(0));

9751
  GenerateNewRandomFile(&rnd);
9752 9753 9754 9755 9756 9757 9758 9759 9760 9761 9762 9763 9764 9765
  ASSERT_EQ("1,0,13", FilesPerLevel(0));

  // nonoverlapping with the file on level 0
  Slice start("a"), end("b");
  ASSERT_OK(experimental::SuggestCompactRange(db_, &start, &end));
  dbfull()->TEST_WaitForCompact();

  // should not compact the level 0 file
  ASSERT_EQ("1,0,13", FilesPerLevel(0));

  start = Slice("j");
  end = Slice("m");
  ASSERT_OK(experimental::SuggestCompactRange(db_, &start, &end));
  dbfull()->TEST_WaitForCompact();
9766 9767
  ASSERT_TRUE(CompactionFilterFactoryGetContext::IsManual(
      options.compaction_filter_factory.get()));
9768 9769 9770 9771 9772

  // now it should compact the level 0 file
  ASSERT_EQ("0,1,13", FilesPerLevel(0));
}

9773 9774 9775 9776 9777 9778 9779 9780 9781 9782 9783 9784 9785 9786 9787 9788 9789 9790 9791 9792 9793 9794 9795 9796 9797 9798 9799 9800 9801 9802 9803 9804 9805 9806 9807 9808 9809 9810 9811 9812 9813 9814 9815 9816 9817 9818 9819 9820 9821 9822 9823 9824 9825 9826 9827
TEST_F(DBTest, PromoteL0) {
  Options options = CurrentOptions();
  options.disable_auto_compactions = true;
  options.write_buffer_size = 10 * 1024 * 1024;
  DestroyAndReopen(options);

  // non overlapping ranges
  std::vector<std::pair<int32_t, int32_t>> ranges = {
      {81, 160}, {0, 80}, {161, 240}, {241, 320}};

  int32_t value_size = 10 * 1024;  // 10 KB

  Random rnd(301);
  std::map<int32_t, std::string> values;
  for (const auto& range : ranges) {
    for (int32_t j = range.first; j < range.second; j++) {
      values[j] = RandomString(&rnd, value_size);
      ASSERT_OK(Put(Key(j), values[j]));
    }
    ASSERT_OK(Flush());
  }

  int32_t level0_files = NumTableFilesAtLevel(0, 0);
  ASSERT_EQ(level0_files, ranges.size());
  ASSERT_EQ(NumTableFilesAtLevel(1, 0), 0);  // No files in L1

  // Promote L0 level to L2.
  ASSERT_OK(experimental::PromoteL0(db_, db_->DefaultColumnFamily(), 2));
  // We expect that all the files were trivially moved from L0 to L2
  ASSERT_EQ(NumTableFilesAtLevel(0, 0), 0);
  ASSERT_EQ(NumTableFilesAtLevel(2, 0), level0_files);

  for (const auto& kv : values) {
    ASSERT_EQ(Get(Key(kv.first)), kv.second);
  }
}

TEST_F(DBTest, PromoteL0Failure) {
  Options options = CurrentOptions();
  options.disable_auto_compactions = true;
  options.write_buffer_size = 10 * 1024 * 1024;
  DestroyAndReopen(options);

  // Produce two L0 files with overlapping ranges.
  ASSERT_OK(Put(Key(0), ""));
  ASSERT_OK(Put(Key(3), ""));
  ASSERT_OK(Flush());
  ASSERT_OK(Put(Key(1), ""));
  ASSERT_OK(Flush());

  Status status;
  // Fails because L0 has overlapping files.
  status = experimental::PromoteL0(db_, db_->DefaultColumnFamily());
  ASSERT_TRUE(status.IsInvalidArgument());

9828
  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
9829 9830 9831 9832 9833 9834 9835 9836 9837 9838
  // Now there is a file in L1.
  ASSERT_GE(NumTableFilesAtLevel(1, 0), 1);

  ASSERT_OK(Put(Key(5), ""));
  ASSERT_OK(Flush());
  // Fails because L1 is non-empty.
  status = experimental::PromoteL0(db_, db_->DefaultColumnFamily());
  ASSERT_TRUE(status.IsInvalidArgument());
}

9839 9840 9841 9842 9843 9844 9845 9846 9847 9848 9849 9850 9851 9852 9853 9854
// Github issue #596
TEST_F(DBTest, HugeNumberOfLevels) {
  Options options = CurrentOptions();
  options.write_buffer_size = 2 * 1024 * 1024;         // 2MB
  options.max_bytes_for_level_base = 2 * 1024 * 1024;  // 2MB
  options.num_levels = 12;
  options.max_background_compactions = 10;
  options.max_bytes_for_level_multiplier = 2;
  options.level_compaction_dynamic_level_bytes = true;
  DestroyAndReopen(options);

  Random rnd(301);
  for (int i = 0; i < 300000; ++i) {
    ASSERT_OK(Put(Key(i), RandomString(&rnd, 1024)));
  }

9855
  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
9856 9857
}

9858 9859 9860 9861 9862 9863 9864 9865 9866 9867 9868 9869 9870 9871 9872 9873 9874
// Github issue #595
// Large write batch with column families
TEST_F(DBTest, LargeBatchWithColumnFamilies) {
  Options options;
  options.env = env_;
  options = CurrentOptions(options);
  options.write_buffer_size = 100000;  // Small write buffer
  CreateAndReopenWithCF({"pikachu"}, options);
  int64_t j = 0;
  for (int i = 0; i < 5; i++) {
    for (int pass = 1; pass <= 3; pass++) {
      WriteBatch batch;
      size_t write_size = 1024 * 1024 * (5 + i);
      fprintf(stderr, "prepare: %ld MB, pass:%d\n", (write_size / 1024 / 1024),
              pass);
      for (;;) {
        std::string data(3000, j++ % 127 + 20);
S
sdong 已提交
9875
        data += ToString(j);
9876 9877 9878 9879 9880 9881 9882 9883 9884 9885 9886 9887 9888 9889
        batch.Put(handles_[0], Slice(data), Slice(data));
        if (batch.GetDataSize() > write_size) {
          break;
        }
      }
      fprintf(stderr, "write: %ld MB\n", (batch.GetDataSize() / 1024 / 1024));
      ASSERT_OK(dbfull()->Write(WriteOptions(), &batch));
      fprintf(stderr, "done\n");
    }
  }
  // make sure we can re-open it.
  ASSERT_OK(TryReopenWithColumnFamilies({"default", "pikachu"}, options));
}

9890 9891 9892 9893 9894 9895 9896 9897 9898 9899 9900 9901 9902 9903 9904 9905 9906 9907 9908 9909 9910 9911 9912 9913 9914 9915 9916 9917 9918 9919 9920 9921 9922 9923 9924 9925 9926 9927 9928 9929 9930 9931 9932 9933 9934 9935 9936 9937 9938 9939 9940 9941 9942 9943 9944 9945 9946 9947 9948 9949 9950 9951 9952
// Make sure that Flushes can proceed in parallel with CompactRange()
TEST_F(DBTest, FlushesInParallelWithCompactRange) {
  // iter == 0 -- leveled
  // iter == 1 -- leveled, but throw in a flush between two levels compacting
  // iter == 2 -- universal
  for (int iter = 0; iter < 3; ++iter) {
    Options options = CurrentOptions();
    if (iter < 2) {
      options.compaction_style = kCompactionStyleLevel;
    } else {
      options.compaction_style = kCompactionStyleUniversal;
    }
    options.write_buffer_size = 110 << 10;
    options.level0_file_num_compaction_trigger = 4;
    options.num_levels = 4;
    options.compression = kNoCompression;
    options.max_bytes_for_level_base = 450 << 10;
    options.target_file_size_base = 98 << 10;
    options.max_write_buffer_number = 2;

    DestroyAndReopen(options);

    Random rnd(301);
    for (int num = 0; num < 14; num++) {
      GenerateNewRandomFile(&rnd);
    }

    if (iter == 1) {
    rocksdb::SyncPoint::GetInstance()->LoadDependency(
        {{"DBImpl::RunManualCompaction()::1",
          "DBTest::FlushesInParallelWithCompactRange:1"},
         {"DBTest::FlushesInParallelWithCompactRange:2",
          "DBImpl::RunManualCompaction()::2"}});
    } else {
      rocksdb::SyncPoint::GetInstance()->LoadDependency(
          {{"CompactionJob::Run():Start",
            "DBTest::FlushesInParallelWithCompactRange:1"},
           {"DBTest::FlushesInParallelWithCompactRange:2",
            "CompactionJob::Run():End"}});
    }
    rocksdb::SyncPoint::GetInstance()->EnableProcessing();

    std::vector<std::thread> threads;
    threads.emplace_back([&]() { Compact("a", "z"); });

    TEST_SYNC_POINT("DBTest::FlushesInParallelWithCompactRange:1");

    // this has to start a flush. if flushes are blocked, this will try to
    // create
    // 3 memtables, and that will fail because max_write_buffer_number is 2
    for (int num = 0; num < 3; num++) {
      GenerateNewRandomFile(&rnd, /* nowait */ true);
    }

    TEST_SYNC_POINT("DBTest::FlushesInParallelWithCompactRange:2");

    for (auto& t : threads) {
      t.join();
    }
    rocksdb::SyncPoint::GetInstance()->DisableProcessing();
  }
}

9953 9954 9955 9956 9957 9958 9959 9960 9961 9962 9963 9964 9965 9966 9967 9968 9969 9970 9971 9972 9973 9974 9975 9976 9977 9978 9979 9980
TEST_F(DBTest, UniversalCompactionTargetLevel) {
  Options options;
  options.compaction_style = kCompactionStyleUniversal;
  options.write_buffer_size = 100 << 10;     // 100KB
  options.num_levels = 7;
  options.disable_auto_compactions = true;
  options = CurrentOptions(options);
  DestroyAndReopen(options);

  // Generate 3 overlapping files
  Random rnd(301);
  for (int i = 0; i < 210; i++) {
    ASSERT_OK(Put(Key(i), RandomString(&rnd, 100)));
  }
  ASSERT_OK(Flush());

  for (int i = 200; i < 300; i++) {
    ASSERT_OK(Put(Key(i), RandomString(&rnd, 100)));
  }
  ASSERT_OK(Flush());

  for (int i = 250; i < 260; i++) {
    ASSERT_OK(Put(Key(i), RandomString(&rnd, 100)));
  }
  ASSERT_OK(Flush());

  ASSERT_EQ("3", FilesPerLevel(0));
  // Compact all files into 1 file and put it in L4
9981 9982 9983 9984
  CompactRangeOptions compact_options;
  compact_options.change_level = true;
  compact_options.target_level = 4;
  db_->CompactRange(compact_options, nullptr, nullptr);
9985 9986 9987
  ASSERT_EQ("0,0,0,0,1", FilesPerLevel(0));
}

9988 9989 9990 9991 9992 9993 9994 9995 9996 9997 9998 9999 10000 10001 10002 10003 10004 10005 10006 10007 10008
// This tests for a bug that could cause two level0 compactions running
// concurrently
TEST_F(DBTest, SuggestCompactRangeNoTwoLevel0Compactions) {
  Options options = CurrentOptions();
  options.compaction_style = kCompactionStyleLevel;
  options.write_buffer_size = 110 << 10;
  options.level0_file_num_compaction_trigger = 4;
  options.num_levels = 4;
  options.compression = kNoCompression;
  options.max_bytes_for_level_base = 450 << 10;
  options.target_file_size_base = 98 << 10;
  options.max_write_buffer_number = 2;
  options.max_background_compactions = 2;

  DestroyAndReopen(options);

  // fill up the DB
  Random rnd(301);
  for (int num = 0; num < 10; num++) {
    GenerateNewRandomFile(&rnd);
  }
10009
  db_->CompactRange(CompactRangeOptions(), nullptr, nullptr);
10010 10011 10012 10013 10014 10015 10016 10017 10018 10019 10020 10021 10022 10023 10024 10025 10026 10027 10028 10029 10030 10031 10032 10033 10034 10035 10036 10037

  rocksdb::SyncPoint::GetInstance()->LoadDependency(
      {{"CompactionJob::Run():Start",
        "DBTest::SuggestCompactRangeNoTwoLevel0Compactions:1"},
       {"DBTest::SuggestCompactRangeNoTwoLevel0Compactions:2",
        "CompactionJob::Run():End"}});

  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  // trigger L0 compaction
  for (int num = 0; num < options.level0_file_num_compaction_trigger + 1;
       num++) {
    GenerateNewRandomFile(&rnd, /* nowait */ true);
  }

  TEST_SYNC_POINT("DBTest::SuggestCompactRangeNoTwoLevel0Compactions:1");

  GenerateNewRandomFile(&rnd, /* nowait */ true);
  dbfull()->TEST_WaitForFlushMemTable();
  ASSERT_OK(experimental::SuggestCompactRange(db_, nullptr, nullptr));
  for (int num = 0; num < options.level0_file_num_compaction_trigger + 1;
       num++) {
    GenerateNewRandomFile(&rnd, /* nowait */ true);
  }

  TEST_SYNC_POINT("DBTest::SuggestCompactRangeNoTwoLevel0Compactions:2");
}

S
sdong 已提交
10038 10039 10040 10041 10042 10043 10044 10045 10046 10047 10048 10049 10050 10051 10052 10053 10054 10055 10056 10057 10058 10059 10060 10061 10062 10063 10064 10065 10066 10067 10068 10069 10070 10071 10072 10073 10074 10075 10076 10077 10078 10079 10080 10081 10082 10083 10084 10085 10086 10087 10088 10089 10090 10091 10092 10093 10094 10095 10096 10097 10098 10099 10100 10101 10102 10103 10104 10105 10106 10107 10108 10109 10110 10111 10112 10113 10114 10115 10116 10117 10118 10119 10120 10121 10122 10123 10124 10125 10126 10127 10128 10129 10130 10131 10132 10133 10134 10135 10136 10137 10138 10139 10140 10141 10142 10143 10144 10145 10146 10147 10148 10149 10150 10151 10152 10153 10154 10155 10156 10157 10158 10159 10160 10161 10162 10163 10164 10165 10166 10167 10168 10169 10170 10171 10172 10173 10174 10175 10176 10177 10178 10179 10180 10181 10182 10183 10184 10185 10186 10187 10188 10189 10190 10191 10192 10193 10194 10195 10196 10197 10198 10199 10200 10201
TEST_F(DBTest, DelayedWriteRate) {
  Options options;
  options.env = env_;
  env_->no_sleep_ = true;
  options = CurrentOptions(options);
  options.write_buffer_size = 100000;  // Small write buffer
  options.max_write_buffer_number = 256;
  options.disable_auto_compactions = true;
  options.level0_file_num_compaction_trigger = 3;
  options.level0_slowdown_writes_trigger = 3;
  options.level0_stop_writes_trigger = 999999;
  options.delayed_write_rate = 200000;  // About 200KB/s limited rate

  CreateAndReopenWithCF({"pikachu"}, options);

  for (int i = 0; i < 3; i++) {
    Put(Key(i), std::string(10000, 'x'));
    Flush();
  }

  // These writes will be slowed down to 1KB/s
  size_t estimated_total_size = 0;
  Random rnd(301);
  for (int i = 0; i < 3000; i++) {
    auto rand_num = rnd.Uniform(20);
    // Spread the size range to more.
    size_t entry_size = rand_num * rand_num * rand_num;
    WriteOptions wo;
    Put(Key(i), std::string(entry_size, 'x'), wo);
    estimated_total_size += entry_size + 20;
    // Ocassionally sleep a while
    if (rnd.Uniform(20) == 6) {
      env_->SleepForMicroseconds(2666);
    }
  }
  uint64_t estimated_sleep_time =
      estimated_total_size / options.delayed_write_rate * 1000000U;
  ASSERT_GT(env_->addon_time_.load(), estimated_sleep_time * 0.8);
  ASSERT_LT(env_->addon_time_.load(), estimated_sleep_time * 1.1);

  env_->no_sleep_ = false;
  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
}

TEST_F(DBTest, SoftLimit) {
  Options options;
  options.env = env_;
  options = CurrentOptions(options);
  options.write_buffer_size = 100000;  // Small write buffer
  options.max_write_buffer_number = 256;
  options.level0_file_num_compaction_trigger = 3;
  options.level0_slowdown_writes_trigger = 3;
  options.level0_stop_writes_trigger = 999999;
  options.delayed_write_rate = 200000;  // About 200KB/s limited rate
  options.soft_rate_limit = 1.1;
  options.target_file_size_base = 99999999;  // All into one file
  options.max_bytes_for_level_base = 50000;
  options.compression = kNoCompression;

  Reopen(options);
  Put(Key(0), "");

  // Only allow two compactions
  port::Mutex mut;
  port::CondVar cv(&mut);
  std::atomic<int> compaction_cnt(0);
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "VersionSet::LogAndApply:WriteManifest", [&](void* arg) {
        // Three flushes and the first compaction,
        // three flushes and the second compaction go through.
        MutexLock l(&mut);
        while (compaction_cnt.load() >= 8) {
          cv.Wait();
        }
        compaction_cnt.fetch_add(1);
      });

  std::atomic<int> sleep_count(0);
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::DelayWrite:Sleep", [&](void* arg) { sleep_count.fetch_add(1); });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  for (int i = 0; i < 3; i++) {
    Put(Key(i), std::string(5000, 'x'));
    Put(Key(100 - i), std::string(5000, 'x'));
    Flush();
  }
  while (compaction_cnt.load() < 4 || NumTableFilesAtLevel(0) > 0) {
    env_->SleepForMicroseconds(1000);
  }
  // Now there is one L1 file but doesn't trigger soft_rate_limit
  ASSERT_EQ(NumTableFilesAtLevel(1), 1);
  ASSERT_EQ(sleep_count.load(), 0);

  for (int i = 0; i < 3; i++) {
    Put(Key(10 + i), std::string(5000, 'x'));
    Put(Key(90 - i), std::string(5000, 'x'));
    Flush();
  }
  while (compaction_cnt.load() < 8 || NumTableFilesAtLevel(0) > 0) {
    env_->SleepForMicroseconds(1000);
  }
  ASSERT_EQ(NumTableFilesAtLevel(1), 1);
  ASSERT_EQ(sleep_count.load(), 0);

  // Slowdown is triggered now
  for (int i = 0; i < 10; i++) {
    Put(Key(i), std::string(100, 'x'));
  }
  ASSERT_GT(sleep_count.load(), 0);

  {
    MutexLock l(&mut);
    compaction_cnt.store(7);
    cv.SignalAll();
  }
  while (NumTableFilesAtLevel(1) > 0) {
    env_->SleepForMicroseconds(1000);
  }

  // Slowdown is not triggered any more.
  sleep_count.store(0);
  // Slowdown is not triggered now
  for (int i = 0; i < 10; i++) {
    Put(Key(i), std::string(100, 'x'));
  }
  ASSERT_EQ(sleep_count.load(), 0);

  // shrink level base so L2 will hit soft limit easier.
  ASSERT_OK(dbfull()->SetOptions({
      {"max_bytes_for_level_base", "5000"},
  }));
  compaction_cnt.store(7);
  Flush();

  while (NumTableFilesAtLevel(0) == 0) {
    env_->SleepForMicroseconds(1000);
  }

  // Slowdown is triggered now
  for (int i = 0; i < 10; i++) {
    Put(Key(i), std::string(100, 'x'));
  }
  ASSERT_GT(sleep_count.load(), 0);

  {
    MutexLock l(&mut);
    compaction_cnt.store(7);
    cv.SignalAll();
  }

  while (NumTableFilesAtLevel(2) != 0) {
    env_->SleepForMicroseconds(1000);
  }

  // Slowdown is not triggered anymore
  sleep_count.store(0);
  for (int i = 0; i < 10; i++) {
    Put(Key(i), std::string(100, 'x'));
  }
  ASSERT_EQ(sleep_count.load(), 0);
  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
}

10202 10203 10204 10205 10206 10207 10208 10209 10210 10211 10212 10213 10214 10215 10216 10217 10218 10219 10220 10221 10222 10223 10224 10225 10226 10227 10228 10229 10230 10231 10232 10233 10234 10235 10236 10237 10238 10239 10240 10241 10242 10243 10244 10245 10246 10247 10248 10249
TEST_F(DBTest, ForceBottommostLevelCompaction) {
  int32_t trivial_move = 0;
  int32_t non_trivial_move = 0;
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:TrivialMove",
      [&](void* arg) { trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:NonTrivial",
      [&](void* arg) { non_trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  Options options;
  options.write_buffer_size = 100000000;
  options = CurrentOptions(options);
  DestroyAndReopen(options);

  int32_t value_size = 10 * 1024;  // 10 KB

  Random rnd(301);
  std::vector<std::string> values;
  // File with keys [ 0 => 99 ]
  for (int i = 0; i < 100; i++) {
    values.push_back(RandomString(&rnd, value_size));
    ASSERT_OK(Put(Key(i), values[i]));
  }
  ASSERT_OK(Flush());

  ASSERT_EQ("1", FilesPerLevel(0));
  // Compaction will do L0=>L1 (trivial move) then move L1 files to L3
  CompactRangeOptions compact_options;
  compact_options.change_level = true;
  compact_options.target_level = 3;
  ASSERT_OK(db_->CompactRange(compact_options, nullptr, nullptr));
  ASSERT_EQ("0,0,0,1", FilesPerLevel(0));
  ASSERT_EQ(trivial_move, 1);
  ASSERT_EQ(non_trivial_move, 0);

  // File with keys [ 100 => 199 ]
  for (int i = 100; i < 200; i++) {
    values.push_back(RandomString(&rnd, value_size));
    ASSERT_OK(Put(Key(i), values[i]));
  }
  ASSERT_OK(Flush());

  ASSERT_EQ("1,0,0,1", FilesPerLevel(0));
  // Compaction will do L0=>L1 L1=>L2 L2=>L3 (3 trivial moves)
  // then compacte the bottommost level L3=>L3 (non trivial move)
  compact_options = CompactRangeOptions();
10250 10251
  compact_options.bottommost_level_compaction =
      BottommostLevelCompaction::kForce;
10252 10253 10254 10255 10256
  ASSERT_OK(db_->CompactRange(compact_options, nullptr, nullptr));
  ASSERT_EQ("0,0,0,1", FilesPerLevel(0));
  ASSERT_EQ(trivial_move, 4);
  ASSERT_EQ(non_trivial_move, 1);

10257 10258 10259 10260 10261 10262 10263 10264 10265 10266 10267 10268 10269 10270 10271 10272 10273 10274 10275 10276 10277
  // File with keys [ 200 => 299 ]
  for (int i = 200; i < 300; i++) {
    values.push_back(RandomString(&rnd, value_size));
    ASSERT_OK(Put(Key(i), values[i]));
  }
  ASSERT_OK(Flush());

  ASSERT_EQ("1,0,0,1", FilesPerLevel(0));
  trivial_move = 0;
  non_trivial_move = 0;
  compact_options = CompactRangeOptions();
  compact_options.bottommost_level_compaction =
      BottommostLevelCompaction::kSkip;
  // Compaction will do L0=>L1 L1=>L2 L2=>L3 (3 trivial moves)
  // and will skip bottommost level compaction
  ASSERT_OK(db_->CompactRange(compact_options, nullptr, nullptr));
  ASSERT_EQ("0,0,0,2", FilesPerLevel(0));
  ASSERT_EQ(trivial_move, 3);
  ASSERT_EQ(non_trivial_move, 0);

  for (int i = 0; i < 300; i++) {
10278 10279 10280 10281 10282 10283
    ASSERT_EQ(Get(Key(i)), values[i]);
  }

  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
}

10284 10285 10286 10287 10288 10289 10290 10291 10292 10293 10294 10295 10296 10297 10298 10299 10300 10301 10302 10303
TEST_F(DBTest, FailWhenCompressionNotSupportedTest) {
  CompressionType compressions[] = {kZlibCompression, kBZip2Compression,
                                    kLZ4Compression,  kLZ4HCCompression};
  for (int iter = 0; iter < 4; ++iter) {
    if (!CompressionTypeSupported(compressions[iter])) {
      // not supported, we should fail the Open()
      Options options = CurrentOptions();
      options.compression = compressions[iter];
      ASSERT_TRUE(!TryReopen(options).ok());
      // Try if CreateColumnFamily also fails
      options.compression = kNoCompression;
      ASSERT_OK(TryReopen(options));
      ColumnFamilyOptions cf_options(options);
      cf_options.compression = compressions[iter];
      ColumnFamilyHandle* handle;
      ASSERT_TRUE(!db_->CreateColumnFamily(cf_options, "name", &handle).ok());
    }
  }
}

10304 10305 10306 10307 10308 10309 10310 10311 10312 10313 10314 10315 10316 10317 10318 10319 10320 10321 10322
TEST_F(DBTest, RowCache) {
  Options options = CurrentOptions();
  options.statistics = rocksdb::CreateDBStatistics();
  options.row_cache = NewLRUCache(8192);
  DestroyAndReopen(options);

  ASSERT_OK(Put("foo", "bar"));
  ASSERT_OK(Flush());

  ASSERT_EQ(TestGetTickerCount(options, ROW_CACHE_HIT), 0);
  ASSERT_EQ(TestGetTickerCount(options, ROW_CACHE_MISS), 0);
  ASSERT_EQ(Get("foo"), "bar");
  ASSERT_EQ(TestGetTickerCount(options, ROW_CACHE_HIT), 0);
  ASSERT_EQ(TestGetTickerCount(options, ROW_CACHE_MISS), 1);
  ASSERT_EQ(Get("foo"), "bar");
  ASSERT_EQ(TestGetTickerCount(options, ROW_CACHE_HIT), 1);
  ASSERT_EQ(TestGetTickerCount(options, ROW_CACHE_MISS), 1);
}

10323 10324 10325
// TODO(3.13): fix the issue of Seek() + Prev() which might not necessary
//             return the biggest key which is smaller than the seek key.
TEST_F(DBTest, DISABLED_PrevAfterMerge) {
10326 10327 10328 10329 10330 10331 10332 10333 10334 10335 10336 10337 10338 10339 10340 10341 10342 10343 10344 10345 10346 10347
  Options options;
  options.create_if_missing = true;
  options.merge_operator = MergeOperators::CreatePutOperator();
  DestroyAndReopen(options);

  // write three entries with different keys using Merge()
  WriteOptions wopts;
  db_->Merge(wopts, "1", "data1");
  db_->Merge(wopts, "2", "data2");
  db_->Merge(wopts, "3", "data3");

  std::unique_ptr<Iterator> it(db_->NewIterator(ReadOptions()));

  it->Seek("2");
  ASSERT_TRUE(it->Valid());
  ASSERT_EQ("2", it->key().ToString());

  it->Prev();
  ASSERT_TRUE(it->Valid());
  ASSERT_EQ("1", it->key().ToString());
}

10348 10349 10350 10351 10352 10353 10354 10355 10356 10357 10358 10359 10360 10361 10362 10363 10364 10365 10366 10367 10368 10369 10370 10371 10372 10373 10374 10375 10376 10377 10378 10379 10380 10381
TEST_F(DBTest, DeletingOldWalAfterDrop) {
  rocksdb::SyncPoint::GetInstance()->LoadDependency(
      { { "Test:AllowFlushes", "DBImpl::BGWorkFlush" },
        { "DBImpl::BGWorkFlush:done", "Test:WaitForFlush"} });
  rocksdb::SyncPoint::GetInstance()->ClearTrace();

  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
  Options options = CurrentOptions();
  options.max_total_wal_size = 8192;
  options.compression = kNoCompression;
  options.write_buffer_size = 1 << 20;
  options.level0_file_num_compaction_trigger = (1<<30);
  options.level0_slowdown_writes_trigger = (1<<30);
  options.level0_stop_writes_trigger = (1<<30);
  options.disable_auto_compactions = true;
  DestroyAndReopen(options);
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  CreateColumnFamilies({"cf1", "cf2"}, options);
  ASSERT_OK(Put(0, "key1", DummyString(8192)));
  ASSERT_OK(Put(0, "key2", DummyString(8192)));
  // the oldest wal should now be getting_flushed
  ASSERT_OK(db_->DropColumnFamily(handles_[0]));
  // all flushes should now do nothing because their CF is dropped
  TEST_SYNC_POINT("Test:AllowFlushes");
  TEST_SYNC_POINT("Test:WaitForFlush");
  uint64_t lognum1 = dbfull()->TEST_LogfileNumber();
  ASSERT_OK(Put(1, "key3", DummyString(8192)));
  ASSERT_OK(Put(1, "key4", DummyString(8192)));
  // new wal should have been created
  uint64_t lognum2 = dbfull()->TEST_LogfileNumber();
  EXPECT_GT(lognum2, lognum1);
}

10382
}  // namespace rocksdb
J
jorlow@chromium.org 已提交
10383

D
Dmitri Smirnov 已提交
10384 10385
#endif

J
jorlow@chromium.org 已提交
10386
int main(int argc, char** argv) {
D
Dmitri Smirnov 已提交
10387
#if !(defined NDEBUG) || !defined(OS_WIN)
10388
  rocksdb::port::InstallStackTraceHandler();
I
Igor Sugak 已提交
10389 10390
  ::testing::InitGoogleTest(&argc, argv);
  return RUN_ALL_TESTS();
D
Dmitri Smirnov 已提交
10391 10392 10393
#else
  return 0;
#endif
J
jorlow@chromium.org 已提交
10394
}