building_data_management_systems.Xuanzhou.2024Fall.DaSE
/
leveldb.project


								// 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 Put(const WriteOptions& options, const Slice& key, const Slice& value,

								             uint64_t ttl) 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;

								  void AppendTS(const Slice& val, std::string* val_with_ts,uint64_t ttl);

								  static uint64_t GetTS(std::string* val);

								  // 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);

								//  Status Write(const WriteOptions& options, WriteBatch* updates,

								//               uint64_t ttl) override;


								 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 RemoveObsoleteFiles() 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_);

								  Status CheckIsExpire(std::string* value);

								};


								// 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_