git / moonbite-core / src/leveldb/db/db_impl.h · raw

// 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.#ifndef STORAGE_LEVELDB_DB_DB_IMPL_H_#define STORAGE_LEVELDB_DB_DB_IMPL_H_#include <atomic>#include <deque>#include <set>#include <string>#include "db/dbformat.h"#include "db/log_writer.h"#include "db/snapshot.h"#include "leveldb/db.h"#include "leveldb/env.h"#include "port/port.h"#include "port/thread_annotations.h"namespace leveldb {class MemTable;class TableCache;class Version;class VersionEdit;class VersionSet;class DBImpl : public DB { public:  DBImpl(const Options& options, const std::string& dbname);  DBImpl(const DBImpl&) = delete;  DBImpl& operator=(const DBImpl&) = delete;  ~DBImpl() override;  // Implementations of the DB interface  Status Put(const WriteOptions&, const Slice& key,             const Slice& value) override;  Status Delete(const WriteOptions&, const Slice& key) override;  Status Write(const WriteOptions& options, WriteBatch* updates) override;  Status Get(const ReadOptions& options, const Slice& key,             std::string* value) override;  Iterator* NewIterator(const ReadOptions&) override;  const Snapshot* GetSnapshot() override;  void ReleaseSnapshot(const Snapshot* snapshot) override;  bool GetProperty(const Slice& property, std::string* value) override;  void GetApproximateSizes(const Range* range, int n, uint64_t* sizes) override;  void CompactRange(const Slice* begin, const Slice* end) override;  // Extra methods (for testing) that are not in the public DB interface  // Compact any files in the named level that overlap [*begin,*end]  void TEST_CompactRange(int level, const Slice* begin, const Slice* end);  // Force current memtable contents to be compacted.  Status TEST_CompactMemTable();  // Return an internal iterator over the current state of the database.  // The keys of this iterator are internal keys (see format.h).  // The returned iterator should be deleted when no longer needed.  Iterator* TEST_NewInternalIterator();  // Return the maximum overlapping data (in bytes) at next level for any  // file at a level >= 1.  int64_t TEST_MaxNextLevelOverlappingBytes();  // Record a sample of bytes read at the specified internal key.  // Samples are taken approximately once every config::kReadBytesPeriod  // bytes.  void RecordReadSample(Slice key); private:  friend class DB;  struct CompactionState;  struct Writer;  // Information for a manual compaction  struct ManualCompaction {    int level;    bool done;    const InternalKey* begin;  // null means beginning of key range    const InternalKey* end;    // null means end of key range    InternalKey tmp_storage;   // Used to keep track of compaction progress  };  // Per level compaction stats.  stats_[level] stores the stats for  // compactions that produced data for the specified "level".  struct CompactionStats {    CompactionStats() : micros(0), bytes_read(0), bytes_written(0) {}    void Add(const CompactionStats& c) {      this->micros += c.micros;      this->bytes_read += c.bytes_read;      this->bytes_written += c.bytes_written;    }    int64_t micros;    int64_t bytes_read;    int64_t bytes_written;  };  Iterator* NewInternalIterator(const ReadOptions&,                                SequenceNumber* latest_snapshot,                                uint32_t* seed);  Status NewDB();  // Recover the descriptor from persistent storage.  May do a significant  // amount of work to recover recently logged updates.  Any changes to  // be made to the descriptor are added to *edit.  Status Recover(VersionEdit* edit, bool* save_manifest)      EXCLUSIVE_LOCKS_REQUIRED(mutex_);  void MaybeIgnoreError(Status* s) const;  // Delete any unneeded files and stale in-memory entries.  void DeleteObsoleteFiles() EXCLUSIVE_LOCKS_REQUIRED(mutex_);  // Compact the in-memory write buffer to disk.  Switches to a new  // log-file/memtable and writes a new descriptor iff successful.  // Errors are recorded in bg_error_.  void CompactMemTable() EXCLUSIVE_LOCKS_REQUIRED(mutex_);  Status RecoverLogFile(uint64_t log_number, bool last_log, bool* save_manifest,                        VersionEdit* edit, SequenceNumber* max_sequence)      EXCLUSIVE_LOCKS_REQUIRED(mutex_);  Status WriteLevel0Table(MemTable* mem, VersionEdit* edit, Version* base)      EXCLUSIVE_LOCKS_REQUIRED(mutex_);  Status MakeRoomForWrite(bool force /* compact even if there is room? */)      EXCLUSIVE_LOCKS_REQUIRED(mutex_);  WriteBatch* BuildBatchGroup(Writer** last_writer)      EXCLUSIVE_LOCKS_REQUIRED(mutex_);  void RecordBackgroundError(const Status& s);  void MaybeScheduleCompaction() EXCLUSIVE_LOCKS_REQUIRED(mutex_);  static void BGWork(void* db);  void BackgroundCall();  void BackgroundCompaction() EXCLUSIVE_LOCKS_REQUIRED(mutex_);  void CleanupCompaction(CompactionState* compact)      EXCLUSIVE_LOCKS_REQUIRED(mutex_);  Status DoCompactionWork(CompactionState* compact)      EXCLUSIVE_LOCKS_REQUIRED(mutex_);  Status OpenCompactionOutputFile(CompactionState* compact);  Status FinishCompactionOutputFile(CompactionState* compact, Iterator* input);  Status InstallCompactionResults(CompactionState* compact)      EXCLUSIVE_LOCKS_REQUIRED(mutex_);  const Comparator* user_comparator() const {    return internal_comparator_.user_comparator();  }  // Constant after construction  Env* const env_;  const InternalKeyComparator internal_comparator_;  const InternalFilterPolicy internal_filter_policy_;  const Options options_;  // options_.comparator == &internal_comparator_  const bool owns_info_log_;  const bool owns_cache_;  const std::string dbname_;  // table_cache_ provides its own synchronization  TableCache* const table_cache_;  // Lock over the persistent DB state.  Non-null iff successfully acquired.  FileLock* db_lock_;  // State below is protected by mutex_  port::Mutex mutex_;  std::atomic<bool> shutting_down_;  port::CondVar background_work_finished_signal_ GUARDED_BY(mutex_);  MemTable* mem_;  MemTable* imm_ GUARDED_BY(mutex_);  // Memtable being compacted  std::atomic<bool> has_imm_;         // So bg thread can detect non-null imm_  WritableFile* logfile_;  uint64_t logfile_number_ GUARDED_BY(mutex_);  log::Writer* log_;  uint32_t seed_ GUARDED_BY(mutex_);  // For sampling.  // Queue of writers.  std::deque<Writer*> writers_ GUARDED_BY(mutex_);  WriteBatch* tmp_batch_ GUARDED_BY(mutex_);  SnapshotList snapshots_ GUARDED_BY(mutex_);  // Set of table files to protect from deletion because they are  // part of ongoing compactions.  std::set<uint64_t> pending_outputs_ GUARDED_BY(mutex_);  // Has a background compaction been scheduled or is running?  bool background_compaction_scheduled_ GUARDED_BY(mutex_);  ManualCompaction* manual_compaction_ GUARDED_BY(mutex_);  VersionSet* const versions_ GUARDED_BY(mutex_);  // Have we encountered a background error in paranoid mode?  Status bg_error_ GUARDED_BY(mutex_);  CompactionStats stats_[config::kNumLevels] GUARDED_BY(mutex_);};// Sanitize db options.  The caller should delete result.info_log if// it is not equal to src.info_log.Options SanitizeOptions(const std::string& db,                        const InternalKeyComparator* icmp,                        const InternalFilterPolicy* ipolicy,                        const Options& src);}  // namespace leveldb#endif  // STORAGE_LEVELDB_DB_DB_IMPL_H_