ceph/src/rocksdb/include/rocksdb/utilities/stackable_db.h

   1 // Copyright (c) 2011 The LevelDB Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file. See the AUTHORS file for names of contributors.
   4
   5 #pragma once
   6 #include <map>
   7 #include <string>
   8 #include "rocksdb/db.h"
   9
  10 #ifdef _WIN32
  11 // Windows API macro interference
  12 #undef DeleteFile
  13 #endif
  14
  15
  16 namespace rocksdb {
  17
  18 // This class contains APIs to stack rocksdb wrappers.Eg. Stack TTL over base d
  19 class StackableDB : public DB {
  20  public:
  21   // StackableDB is the owner of db now!
  22   explicit StackableDB(DB* db) : db_(db) {}
  23
  24   ~StackableDB() {
  25     delete db_;
  26   }
  27
  28   virtual DB* GetBaseDB() {
  29     return db_;
  30   }
  31
  32   virtual DB* GetRootDB() override { return db_->GetRootDB(); }
  33
  34   virtual Status CreateColumnFamily(const ColumnFamilyOptions& options,
  35                                     const std::string& column_family_name,
  36                                     ColumnFamilyHandle** handle) override {
  37     return db_->CreateColumnFamily(options, column_family_name, handle);
  38   }
  39
  40   virtual Status DropColumnFamily(ColumnFamilyHandle* column_family) override {
  41     return db_->DropColumnFamily(column_family);
  42   }
  43
  44   virtual Status DestroyColumnFamilyHandle(
  45       ColumnFamilyHandle* column_family) override {
  46     return db_->DestroyColumnFamilyHandle(column_family);
  47   }
  48
  49   using DB::Put;
  50   virtual Status Put(const WriteOptions& options,
  51                      ColumnFamilyHandle* column_family, const Slice& key,
  52                      const Slice& val) override {
  53     return db_->Put(options, column_family, key, val);
  54   }
  55
  56   using DB::Get;
  57   virtual Status Get(const ReadOptions& options,
  58                      ColumnFamilyHandle* column_family, const Slice& key,
  59                      PinnableSlice* value) override {
  60     return db_->Get(options, column_family, key, value);
  61   }
  62
  63   using DB::MultiGet;
  64   virtual std::vector<Status> MultiGet(
  65       const ReadOptions& options,
  66       const std::vector<ColumnFamilyHandle*>& column_family,
  67       const std::vector<Slice>& keys,
  68       std::vector<std::string>* values) override {
  69     return db_->MultiGet(options, column_family, keys, values);
  70   }
  71
  72   using DB::IngestExternalFile;
  73   virtual Status IngestExternalFile(
  74       ColumnFamilyHandle* column_family,
  75       const std::vector<std::string>& external_files,
  76       const IngestExternalFileOptions& options) override {
  77     return db_->IngestExternalFile(column_family, external_files, options);
  78   }
  79
  80   using DB::KeyMayExist;
  81   virtual bool KeyMayExist(const ReadOptions& options,
  82                            ColumnFamilyHandle* column_family, const Slice& key,
  83                            std::string* value,
  84                            bool* value_found = nullptr) override {
  85     return db_->KeyMayExist(options, column_family, key, value, value_found);
  86   }
  87
  88   using DB::Delete;
  89   virtual Status Delete(const WriteOptions& wopts,
  90                         ColumnFamilyHandle* column_family,
  91                         const Slice& key) override {
  92     return db_->Delete(wopts, column_family, key);
  93   }
  94
  95   using DB::SingleDelete;
  96   virtual Status SingleDelete(const WriteOptions& wopts,
  97                               ColumnFamilyHandle* column_family,
  98                               const Slice& key) override {
  99     return db_->SingleDelete(wopts, column_family, key);
 100   }
 101
 102   using DB::Merge;
 103   virtual Status Merge(const WriteOptions& options,
 104                        ColumnFamilyHandle* column_family, const Slice& key,
 105                        const Slice& value) override {
 106     return db_->Merge(options, column_family, key, value);
 107   }
 108
 109
 110   virtual Status Write(const WriteOptions& opts, WriteBatch* updates)
 111     override {
 112       return db_->Write(opts, updates);
 113   }
 114
 115   using DB::NewIterator;
 116   virtual Iterator* NewIterator(const ReadOptions& opts,
 117                                 ColumnFamilyHandle* column_family) override {
 118     return db_->NewIterator(opts, column_family);
 119   }
 120
 121   virtual Status NewIterators(
 122       const ReadOptions& options,
 123       const std::vector<ColumnFamilyHandle*>& column_families,
 124       std::vector<Iterator*>* iterators) override {
 125     return db_->NewIterators(options, column_families, iterators);
 126   }
 127
 128
 129   virtual const Snapshot* GetSnapshot() override {
 130     return db_->GetSnapshot();
 131   }
 132
 133   virtual void ReleaseSnapshot(const Snapshot* snapshot) override {
 134     return db_->ReleaseSnapshot(snapshot);
 135   }
 136
 137   using DB::GetMapProperty;
 138   using DB::GetProperty;
 139   virtual bool GetProperty(ColumnFamilyHandle* column_family,
 140                            const Slice& property, std::string* value) override {
 141     return db_->GetProperty(column_family, property, value);
 142   }
 143   virtual bool GetMapProperty(ColumnFamilyHandle* column_family,
 144                               const Slice& property,
 145                               std::map<std::string, double>* value) override {
 146     return db_->GetMapProperty(column_family, property, value);
 147   }
 148
 149   using DB::GetIntProperty;
 150   virtual bool GetIntProperty(ColumnFamilyHandle* column_family,
 151                               const Slice& property, uint64_t* value) override {
 152     return db_->GetIntProperty(column_family, property, value);
 153   }
 154
 155   using DB::GetAggregatedIntProperty;
 156   virtual bool GetAggregatedIntProperty(const Slice& property,
 157                                         uint64_t* value) override {
 158     return db_->GetAggregatedIntProperty(property, value);
 159   }
 160
 161   using DB::GetApproximateSizes;
 162   virtual void GetApproximateSizes(ColumnFamilyHandle* column_family,
 163                                    const Range* r, int n, uint64_t* sizes,
 164                                    uint8_t include_flags
 165                                    = INCLUDE_FILES) override {
 166     return db_->GetApproximateSizes(column_family, r, n, sizes,
 167                                     include_flags);
 168   }
 169
 170   using DB::GetApproximateMemTableStats;
 171   virtual void GetApproximateMemTableStats(ColumnFamilyHandle* column_family,
 172                                            const Range& range,
 173                                            uint64_t* const count,
 174                                            uint64_t* const size) override {
 175     return db_->GetApproximateMemTableStats(column_family, range, count, size);
 176   }
 177
 178   using DB::CompactRange;
 179   virtual Status CompactRange(const CompactRangeOptions& options,
 180                               ColumnFamilyHandle* column_family,
 181                               const Slice* begin, const Slice* end) override {
 182     return db_->CompactRange(options, column_family, begin, end);
 183   }
 184
 185   using DB::CompactFiles;
 186   virtual Status CompactFiles(
 187       const CompactionOptions& compact_options,
 188       ColumnFamilyHandle* column_family,
 189       const std::vector<std::string>& input_file_names,
 190       const int output_level, const int output_path_id = -1) override {
 191     return db_->CompactFiles(
 192         compact_options, column_family, input_file_names,
 193         output_level, output_path_id);
 194   }
 195
 196   virtual Status PauseBackgroundWork() override {
 197     return db_->PauseBackgroundWork();
 198   }
 199   virtual Status ContinueBackgroundWork() override {
 200     return db_->ContinueBackgroundWork();
 201   }
 202
 203   virtual Status EnableAutoCompaction(
 204       const std::vector<ColumnFamilyHandle*>& column_family_handles) override {
 205     return db_->EnableAutoCompaction(column_family_handles);
 206   }
 207
 208   using DB::NumberLevels;
 209   virtual int NumberLevels(ColumnFamilyHandle* column_family) override {
 210     return db_->NumberLevels(column_family);
 211   }
 212
 213   using DB::MaxMemCompactionLevel;
 214   virtual int MaxMemCompactionLevel(ColumnFamilyHandle* column_family)
 215       override {
 216     return db_->MaxMemCompactionLevel(column_family);
 217   }
 218
 219   using DB::Level0StopWriteTrigger;
 220   virtual int Level0StopWriteTrigger(ColumnFamilyHandle* column_family)
 221       override {
 222     return db_->Level0StopWriteTrigger(column_family);
 223   }
 224
 225   virtual const std::string& GetName() const override {
 226     return db_->GetName();
 227   }
 228
 229   virtual Env* GetEnv() const override {
 230     return db_->GetEnv();
 231   }
 232
 233   using DB::GetOptions;
 234   virtual Options GetOptions(ColumnFamilyHandle* column_family) const override {
 235     return db_->GetOptions(column_family);
 236   }
 237
 238   using DB::GetDBOptions;
 239   virtual DBOptions GetDBOptions() const override {
 240     return db_->GetDBOptions();
 241   }
 242
 243   using DB::Flush;
 244   virtual Status Flush(const FlushOptions& fopts,
 245                        ColumnFamilyHandle* column_family) override {
 246     return db_->Flush(fopts, column_family);
 247   }
 248
 249   virtual Status SyncWAL() override {
 250     return db_->SyncWAL();
 251   }
 252
 253 #ifndef ROCKSDB_LITE
 254
 255   virtual Status DisableFileDeletions() override {
 256     return db_->DisableFileDeletions();
 257   }
 258
 259   virtual Status EnableFileDeletions(bool force) override {
 260     return db_->EnableFileDeletions(force);
 261   }
 262
 263   virtual void GetLiveFilesMetaData(
 264       std::vector<LiveFileMetaData>* metadata) override {
 265     db_->GetLiveFilesMetaData(metadata);
 266   }
 267
 268   virtual void GetColumnFamilyMetaData(
 269       ColumnFamilyHandle *column_family,
 270       ColumnFamilyMetaData* cf_meta) override {
 271     db_->GetColumnFamilyMetaData(column_family, cf_meta);
 272   }
 273
 274 #endif  // ROCKSDB_LITE
 275
 276   virtual Status GetLiveFiles(std::vector<std::string>& vec, uint64_t* mfs,
 277                               bool flush_memtable = true) override {
 278       return db_->GetLiveFiles(vec, mfs, flush_memtable);
 279   }
 280
 281   virtual SequenceNumber GetLatestSequenceNumber() const override {
 282     return db_->GetLatestSequenceNumber();
 283   }
 284
 285   virtual Status GetSortedWalFiles(VectorLogPtr& files) override {
 286     return db_->GetSortedWalFiles(files);
 287   }
 288
 289   virtual Status DeleteFile(std::string name) override {
 290     return db_->DeleteFile(name);
 291   }
 292
 293   virtual Status GetDbIdentity(std::string& identity) const override {
 294     return db_->GetDbIdentity(identity);
 295   }
 296
 297   using DB::SetOptions;
 298   virtual Status SetOptions(ColumnFamilyHandle* column_family_handle,
 299                             const std::unordered_map<std::string, std::string>&
 300                                 new_options) override {
 301     return db_->SetOptions(column_family_handle, new_options);
 302   }
 303
 304   virtual Status SetDBOptions(
 305       const std::unordered_map<std::string, std::string>& new_options)
 306       override {
 307     return db_->SetDBOptions(new_options);
 308   }
 309
 310   using DB::ResetStats;
 311   virtual Status ResetStats() override { return db_->ResetStats(); }
 312
 313   using DB::GetPropertiesOfAllTables;
 314   virtual Status GetPropertiesOfAllTables(
 315       ColumnFamilyHandle* column_family,
 316       TablePropertiesCollection* props) override {
 317     return db_->GetPropertiesOfAllTables(column_family, props);
 318   }
 319
 320   using DB::GetPropertiesOfTablesInRange;
 321   virtual Status GetPropertiesOfTablesInRange(
 322       ColumnFamilyHandle* column_family, const Range* range, std::size_t n,
 323       TablePropertiesCollection* props) override {
 324     return db_->GetPropertiesOfTablesInRange(column_family, range, n, props);
 325   }
 326
 327   virtual Status GetUpdatesSince(
 328       SequenceNumber seq_number, unique_ptr<TransactionLogIterator>* iter,
 329       const TransactionLogIterator::ReadOptions& read_options) override {
 330     return db_->GetUpdatesSince(seq_number, iter, read_options);
 331   }
 332
 333   virtual ColumnFamilyHandle* DefaultColumnFamily() const override {
 334     return db_->DefaultColumnFamily();
 335   }
 336
 337  protected:
 338   DB* db_;
 339 };
 340
 341 } //  namespace rocksdb