Inside Bitcoin

251    delete env_;
252    delete filter_policy_;
253  }
254
255  // Switch to a fresh database with the next option configuration to
256  // test.  Return false if there are no more configurations to test.
257  bool ChangeOptions() {
258    option_config_++;
259    if (option_config_ >= kEnd) {
260      return false;
261    } else {
262      DestroyAndReopen();
263      return true;
264    }
265  }
266
267  // Return the current option configuration.
268  Options CurrentOptions() {
269    Options options;
270    options.reuse_logs = false;
271    switch (option_config_) {
272      case kReuse:
273        options.reuse_logs = true;
274        break;
275      case kFilter:
276        options.filter_policy = filter_policy_;
277        break;
278      case kUncompressed:
279        options.compression = kNoCompression;
280        break;
281      default:
282        break;
283    }
284    return options;
285  }
286
287  DBImpl* dbfull() { return reinterpret_cast<DBImpl*>(db_); }
288
289  void Reopen(Options* options = nullptr) { ASSERT_OK(TryReopen(options)); }
290
291  void Close() {
292    delete db_;
293    db_ = nullptr;
294  }
295
296  void DestroyAndReopen(Options* options = nullptr) {
297    delete db_;
298    db_ = nullptr;
299    DestroyDB(dbname_, Options());
300    ASSERT_OK(TryReopen(options));
301  }
302
303  Status TryReopen(Options* options) {
304    delete db_;
305    db_ = nullptr;
306    Options opts;
307    if (options != nullptr) {
308      opts = *options;
309    } else {
310      opts = CurrentOptions();
311      opts.create_if_missing = true;
312    }
313    last_options_ = opts;
314
315    return DB::Open(opts, dbname_, &db_);
316  }
317
318  Status Put(const std::string& k, const std::string& v) {
319    return db_->Put(WriteOptions(), k, v);
320  }
321
322  Status Delete(const std::string& k) { return db_->Delete(WriteOptions(), k); }
323
324  std::string Get(const std::string& k, const Snapshot* snapshot = nullptr) {
325    ReadOptions options;
326    options.snapshot = snapshot;
327    std::string result;
328    Status s = db_->Get(options, k, &result);
329    if (s.IsNotFound()) {
330      result = "NOT_FOUND";
331    } else if (!s.ok()) {
332      result = s.ToString();
333    }
334    return result;
335  }
336
337  // Return a string that contains all key,value pairs in order,
338  // formatted like "(k1->v1)(k2->v2)".
339  std::string Contents() {
340    std::vector<std::string> forward;
341    std::string result;
342    Iterator* iter = db_->NewIterator(ReadOptions());
343    for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
344      std::string s = IterStatus(iter);
345      result.push_back('(');
346      result.append(s);
347      result.push_back(')');
348      forward.push_back(s);
349    }
350
351    // Check reverse iteration results are the reverse of forward results
352    size_t matched = 0;
353    for (iter->SeekToLast(); iter->Valid(); iter->Prev()) {
354      ASSERT_LT(matched, forward.size());
355      ASSERT_EQ(IterStatus(iter), forward[forward.size() - matched - 1]);
356      matched++;
357    }
358    ASSERT_EQ(matched, forward.size());
359
360    delete iter;
361    return result;
362  }
363
364  std::string AllEntriesFor(const Slice& user_key) {
365    Iterator* iter = dbfull()->TEST_NewInternalIterator();
366    InternalKey target(user_key, kMaxSequenceNumber, kTypeValue);
367    iter->Seek(target.Encode());
368    std::string result;
369    if (!iter->status().ok()) {
370      result = iter->status().ToString();
371    } else {
372      result = "[ ";
373      bool first = true;
374      while (iter->Valid()) {
375        ParsedInternalKey ikey;
376        if (!ParseInternalKey(iter->key(), &ikey)) {
377          result += "CORRUPTED";
378        } else {
379          if (last_options_.comparator->Compare(ikey.user_key, user_key) != 0) {
380            break;
381          }
382          if (!first) {
383            result += ", ";
384          }
385          first = false;
386          switch (ikey.type) {
387            case kTypeValue:
388              result += iter->value().ToString();
389              break;
390            case kTypeDeletion:
391              result += "DEL";
392              break;
393          }
394        }
395        iter->Next();
396      }
397      if (!first) {
398        result += " ";
399      }
400      result += "]";
401    }
402    delete iter;
403    return result;
404  }
405
406  int NumTableFilesAtLevel(int level) {
407    std::string property;
408    ASSERT_TRUE(db_->GetProperty(
409        "leveldb.num-files-at-level" + NumberToString(level), &property));
410    return std::stoi(property);
411  }
412
413  int TotalTableFiles() {
414    int result = 0;
415    for (int level = 0; level < config::kNumLevels; level++) {
416      result += NumTableFilesAtLevel(level);
417    }
418    return result;
419  }
420
421  // Return spread of files per level
422  std::string FilesPerLevel() {
423    std::string result;
424    int last_non_zero_offset = 0;
425    for (int level = 0; level < config::kNumLevels; level++) {
426      int f = NumTableFilesAtLevel(level);
427      char buf[100];
428      snprintf(buf, sizeof(buf), "%s%d", (level ? "," : ""), f);
429      result += buf;
430      if (f > 0) {
431        last_non_zero_offset = result.size();
432      }
433    }
434    result.resize(last_non_zero_offset);
435    return result;
436  }
437
438  int CountFiles() {
439    std::vector<std::string> files;
440    env_->GetChildren(dbname_, &files);
441    return static_cast<int>(files.size());
442  }
443
444  uint64_t Size(const Slice& start, const Slice& limit) {
445    Range r(start, limit);
446    uint64_t size;
447    db_->GetApproximateSizes(&r, 1, &size);
448    return size;
449  }
450
451  void Compact(const Slice& start, const Slice& limit) {
452    db_->CompactRange(&start, &limit);
453  }
454
455  // Do n memtable compactions, each of which produces an sstable
456  // covering the range [small_key,large_key].
457  void MakeTables(int n, const std::string& small_key,
458                  const std::string& large_key) {
459    for (int i = 0; i < n; i++) {
460      Put(small_key, "begin");
461      Put(large_key, "end");
462      dbfull()->TEST_CompactMemTable();
463    }
464  }
465
466  // Prevent pushing of new sstables into deeper levels by adding
467  // tables that cover a specified range to all levels.
468  void FillLevels(const std::string& smallest, const std::string& largest) {
469    MakeTables(config::kNumLevels, smallest, largest);
470  }
471
472  void DumpFileCounts(const char* label) {
473    fprintf(stderr, "---\n%s:\n", label);
474    fprintf(
475        stderr, "maxoverlap: %lld\n",
476        static_cast<long long>(dbfull()->TEST_MaxNextLevelOverlappingBytes()));
477    for (int level = 0; level < config::kNumLevels; level++) {
478      int num = NumTableFilesAtLevel(level);
479      if (num > 0) {
480        fprintf(stderr, "  level %3d : %d files\n", level, num);
481      }
482    }
483  }
484
485  std::string DumpSSTableList() {
486    std::string property;
487    db_->GetProperty("leveldb.sstables", &property);
488    return property;
489  }
490
491  std::string IterStatus(Iterator* iter) {
492    std::string result;
493    if (iter->Valid()) {
494      result = iter->key().ToString() + "->" + iter->value().ToString();
495    } else {
496      result = "(invalid)";
497    }
498    return result;
499  }
500