Inside Bitcoin

501  bool DeleteAnSSTFile() {
502    std::vector<std::string> filenames;
503    ASSERT_OK(env_->GetChildren(dbname_, &filenames));
504    uint64_t number;
505    FileType type;
506    for (size_t i = 0; i < filenames.size(); i++) {
507      if (ParseFileName(filenames[i], &number, &type) && type == kTableFile) {
508        ASSERT_OK(env_->DeleteFile(TableFileName(dbname_, number)));
509        return true;
510      }
511    }
512    return false;
513  }
514
515  // Returns number of files renamed.
516  int RenameLDBToSST() {
517    std::vector<std::string> filenames;
518    ASSERT_OK(env_->GetChildren(dbname_, &filenames));
519    uint64_t number;
520    FileType type;
521    int files_renamed = 0;
522    for (size_t i = 0; i < filenames.size(); i++) {
523      if (ParseFileName(filenames[i], &number, &type) && type == kTableFile) {
524        const std::string from = TableFileName(dbname_, number);
525        const std::string to = SSTTableFileName(dbname_, number);
526        ASSERT_OK(env_->RenameFile(from, to));
527        files_renamed++;
528      }
529    }
530    return files_renamed;
531  }
532
533 private:
534  // Sequence of option configurations to try
535  enum OptionConfig { kDefault, kReuse, kFilter, kUncompressed, kEnd };
536
537  const FilterPolicy* filter_policy_;
538  int option_config_;
539};
540
541TEST(DBTest, Empty) {
542  do {
543    ASSERT_TRUE(db_ != nullptr);
544    ASSERT_EQ("NOT_FOUND", Get("foo"));
545  } while (ChangeOptions());
546}
547
548TEST(DBTest, EmptyKey) {
549  do {
550    ASSERT_OK(Put("", "v1"));
551    ASSERT_EQ("v1", Get(""));
552    ASSERT_OK(Put("", "v2"));
553    ASSERT_EQ("v2", Get(""));
554  } while (ChangeOptions());
555}
556
557TEST(DBTest, EmptyValue) {
558  do {
559    ASSERT_OK(Put("key", "v1"));
560    ASSERT_EQ("v1", Get("key"));
561    ASSERT_OK(Put("key", ""));
562    ASSERT_EQ("", Get("key"));
563    ASSERT_OK(Put("key", "v2"));
564    ASSERT_EQ("v2", Get("key"));
565  } while (ChangeOptions());
566}
567
568TEST(DBTest, ReadWrite) {
569  do {
570    ASSERT_OK(Put("foo", "v1"));
571    ASSERT_EQ("v1", Get("foo"));
572    ASSERT_OK(Put("bar", "v2"));
573    ASSERT_OK(Put("foo", "v3"));
574    ASSERT_EQ("v3", Get("foo"));
575    ASSERT_EQ("v2", Get("bar"));
576  } while (ChangeOptions());
577}
578
579TEST(DBTest, PutDeleteGet) {
580  do {
581    ASSERT_OK(db_->Put(WriteOptions(), "foo", "v1"));
582    ASSERT_EQ("v1", Get("foo"));
583    ASSERT_OK(db_->Put(WriteOptions(), "foo", "v2"));
584    ASSERT_EQ("v2", Get("foo"));
585    ASSERT_OK(db_->Delete(WriteOptions(), "foo"));
586    ASSERT_EQ("NOT_FOUND", Get("foo"));
587  } while (ChangeOptions());
588}
589
590TEST(DBTest, GetFromImmutableLayer) {
591  do {
592    Options options = CurrentOptions();
593    options.env = env_;
594    options.write_buffer_size = 100000;  // Small write buffer
595    Reopen(&options);
596
597    ASSERT_OK(Put("foo", "v1"));
598    ASSERT_EQ("v1", Get("foo"));
599
600    // Block sync calls.
601    env_->delay_data_sync_.store(true, std::memory_order_release);
602    Put("k1", std::string(100000, 'x'));  // Fill memtable.
603    Put("k2", std::string(100000, 'y'));  // Trigger compaction.
604    ASSERT_EQ("v1", Get("foo"));
605    // Release sync calls.
606    env_->delay_data_sync_.store(false, std::memory_order_release);
607  } while (ChangeOptions());
608}
609
610TEST(DBTest, GetFromVersions) {
611  do {
612    ASSERT_OK(Put("foo", "v1"));
613    dbfull()->TEST_CompactMemTable();
614    ASSERT_EQ("v1", Get("foo"));
615  } while (ChangeOptions());
616}
617
618TEST(DBTest, GetMemUsage) {
619  do {
620    ASSERT_OK(Put("foo", "v1"));
621    std::string val;
622    ASSERT_TRUE(db_->GetProperty("leveldb.approximate-memory-usage", &val));
623    int mem_usage = std::stoi(val);
624    ASSERT_GT(mem_usage, 0);
625    ASSERT_LT(mem_usage, 5 * 1024 * 1024);
626  } while (ChangeOptions());
627}
628
629TEST(DBTest, GetSnapshot) {
630  do {
631    // Try with both a short key and a long key
632    for (int i = 0; i < 2; i++) {
633      std::string key = (i == 0) ? std::string("foo") : std::string(200, 'x');
634      ASSERT_OK(Put(key, "v1"));
635      const Snapshot* s1 = db_->GetSnapshot();
636      ASSERT_OK(Put(key, "v2"));
637      ASSERT_EQ("v2", Get(key));
638      ASSERT_EQ("v1", Get(key, s1));
639      dbfull()->TEST_CompactMemTable();
640      ASSERT_EQ("v2", Get(key));
641      ASSERT_EQ("v1", Get(key, s1));
642      db_->ReleaseSnapshot(s1);
643    }
644  } while (ChangeOptions());
645}
646
647TEST(DBTest, GetIdenticalSnapshots) {
648  do {
649    // Try with both a short key and a long key
650    for (int i = 0; i < 2; i++) {
651      std::string key = (i == 0) ? std::string("foo") : std::string(200, 'x');
652      ASSERT_OK(Put(key, "v1"));
653      const Snapshot* s1 = db_->GetSnapshot();
654      const Snapshot* s2 = db_->GetSnapshot();
655      const Snapshot* s3 = db_->GetSnapshot();
656      ASSERT_OK(Put(key, "v2"));
657      ASSERT_EQ("v2", Get(key));
658      ASSERT_EQ("v1", Get(key, s1));
659      ASSERT_EQ("v1", Get(key, s2));
660      ASSERT_EQ("v1", Get(key, s3));
661      db_->ReleaseSnapshot(s1);
662      dbfull()->TEST_CompactMemTable();
663      ASSERT_EQ("v2", Get(key));
664      ASSERT_EQ("v1", Get(key, s2));
665      db_->ReleaseSnapshot(s2);
666      ASSERT_EQ("v1", Get(key, s3));
667      db_->ReleaseSnapshot(s3);
668    }
669  } while (ChangeOptions());
670}
671
672TEST(DBTest, IterateOverEmptySnapshot) {
673  do {
674    const Snapshot* snapshot = db_->GetSnapshot();
675    ReadOptions read_options;
676    read_options.snapshot = snapshot;
677    ASSERT_OK(Put("foo", "v1"));
678    ASSERT_OK(Put("foo", "v2"));
679
680    Iterator* iterator1 = db_->NewIterator(read_options);
681    iterator1->SeekToFirst();
682    ASSERT_TRUE(!iterator1->Valid());
683    delete iterator1;
684
685    dbfull()->TEST_CompactMemTable();
686
687    Iterator* iterator2 = db_->NewIterator(read_options);
688    iterator2->SeekToFirst();
689    ASSERT_TRUE(!iterator2->Valid());
690    delete iterator2;
691
692    db_->ReleaseSnapshot(snapshot);
693  } while (ChangeOptions());
694}
695
696TEST(DBTest, GetLevel0Ordering) {
697  do {
698    // Check that we process level-0 files in correct order.  The code
699    // below generates two level-0 files where the earlier one comes
700    // before the later one in the level-0 file list since the earlier
701    // one has a smaller "smallest" key.
702    ASSERT_OK(Put("bar", "b"));
703    ASSERT_OK(Put("foo", "v1"));
704    dbfull()->TEST_CompactMemTable();
705    ASSERT_OK(Put("foo", "v2"));
706    dbfull()->TEST_CompactMemTable();
707    ASSERT_EQ("v2", Get("foo"));
708  } while (ChangeOptions());
709}
710
711TEST(DBTest, GetOrderedByLevels) {
712  do {
713    ASSERT_OK(Put("foo", "v1"));
714    Compact("a", "z");
715    ASSERT_EQ("v1", Get("foo"));
716    ASSERT_OK(Put("foo", "v2"));
717    ASSERT_EQ("v2", Get("foo"));
718    dbfull()->TEST_CompactMemTable();
719    ASSERT_EQ("v2", Get("foo"));
720  } while (ChangeOptions());
721}
722
723TEST(DBTest, GetPicksCorrectFile) {
724  do {
725    // Arrange to have multiple files in a non-level-0 level.
726    ASSERT_OK(Put("a", "va"));
727    Compact("a", "b");
728    ASSERT_OK(Put("x", "vx"));
729    Compact("x", "y");
730    ASSERT_OK(Put("f", "vf"));
731    Compact("f", "g");
732    ASSERT_EQ("va", Get("a"));
733    ASSERT_EQ("vf", Get("f"));
734    ASSERT_EQ("vx", Get("x"));
735  } while (ChangeOptions());
736}
737
738TEST(DBTest, GetDoesNotTriggerSeekCompaction) {
739  do {
740    // Arrange for the following to happen:
741    //   * sstable A in level 0
742    //   * nothing in level 1
743    //   * sstable B in level 2
744    // Seek compaction is disabled in this fork, so repeated reads must
745    // not change the level layout. A manual compaction must still work.
746
747    // Step 1: First place sstables in levels 0 and 2
748    int compaction_count = 0;
749    while (NumTableFilesAtLevel(0) == 0 || NumTableFilesAtLevel(2) == 0) {
750      ASSERT_LE(compaction_count, 100) << "could not fill levels 0 and 2";