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 <memory>
   8 #include <string>
   9 #include "rocksdb/db.h"
  10
  11 #ifdef _WIN32
  12 // Windows API macro interference
  13 #undef DeleteFile
  14 #endif
  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 take sole ownership of the underlying db.
  22   explicit StackableDB(DB* db) : db_(db) {}
  23
  24   // StackableDB take shared ownership of the underlying db.
  25   explicit StackableDB(std::shared_ptr<DB> db)
  26       : db_(db.get()), shared_db_ptr_(db) {}
  27
  28   ~StackableDB() {
  29     if (shared_db_ptr_ == nullptr) {
  30       delete db_;
  31     } else {
  32       assert(shared_db_ptr_.get() == db_);
  33     }
  34     db_ = nullptr;
  35   }
  36
  37   virtual Status Close() override { return db_->Close(); }
  38
  39   virtual DB* GetBaseDB() { return db_; }
  40
  41   virtual DB* GetRootDB() override { return db_->GetRootDB(); }
  42
  43   virtual Status CreateColumnFamily(const ColumnFamilyOptions& options,
  44                                     const std::string& column_family_name,
  45                                     ColumnFamilyHandle** handle) override {
  46     return db_->CreateColumnFamily(options, column_family_name, handle);
  47   }
  48
  49   virtual Status CreateColumnFamilies(
  50       const ColumnFamilyOptions& options,
  51       const std::vector<std::string>& column_family_names,
  52       std::vector<ColumnFamilyHandle*>* handles) override {
  53     return db_->CreateColumnFamilies(options, column_family_names, handles);
  54   }
  55
  56   virtual Status CreateColumnFamilies(
  57       const std::vector<ColumnFamilyDescriptor>& column_families,
  58       std::vector<ColumnFamilyHandle*>* handles) override {
  59     return db_->CreateColumnFamilies(column_families, handles);
  60   }
  61
  62   virtual Status DropColumnFamily(ColumnFamilyHandle* column_family) override {
  63     return db_->DropColumnFamily(column_family);
  64   }
  65
  66   virtual Status DropColumnFamilies(
  67       const std::vector<ColumnFamilyHandle*>& column_families) override {
  68     return db_->DropColumnFamilies(column_families);
  69   }
  70
  71   virtual Status DestroyColumnFamilyHandle(
  72       ColumnFamilyHandle* column_family) override {
  73     return db_->DestroyColumnFamilyHandle(column_family);
  74   }
  75
  76   using DB::Put;
  77   virtual Status Put(const WriteOptions& options,
  78                      ColumnFamilyHandle* column_family, const Slice& key,
  79                      const Slice& val) override {
  80     return db_->Put(options, column_family, key, val);
  81   }
  82
  83   using DB::Get;
  84   virtual Status Get(const ReadOptions& options,
  85                      ColumnFamilyHandle* column_family, const Slice& key,
  86                      PinnableSlice* value) override {
  87     return db_->Get(options, column_family, key, value);
  88   }
  89
  90   using DB::MultiGet;
  91   virtual std::vector<Status> MultiGet(
  92       const ReadOptions& options,
  93       const std::vector<ColumnFamilyHandle*>& column_family,
  94       const std::vector<Slice>& keys,
  95       std::vector<std::string>* values) override {
  96     return db_->MultiGet(options, column_family, keys, values);
  97   }
  98
  99   using DB::IngestExternalFile;
 100   virtual Status IngestExternalFile(
 101       ColumnFamilyHandle* column_family,
 102       const std::vector<std::string>& external_files,
 103       const IngestExternalFileOptions& options) override {
 104     return db_->IngestExternalFile(column_family, external_files, options);
 105   }
 106
 107   using DB::IngestExternalFiles;
 108   virtual Status IngestExternalFiles(
 109       const std::vector<IngestExternalFileArg>& args) override {
 110     return db_->IngestExternalFiles(args);
 111   }
 112
 113   virtual Status VerifyChecksum() override { return db_->VerifyChecksum(); }
 114
 115   using DB::KeyMayExist;
 116   virtual bool KeyMayExist(const ReadOptions& options,
 117                            ColumnFamilyHandle* column_family, const Slice& key,
 118                            std::string* value,
 119                            bool* value_found = nullptr) override {
 120     return db_->KeyMayExist(options, column_family, key, value, value_found);
 121   }
 122
 123   using DB::Delete;
 124   virtual Status Delete(const WriteOptions& wopts,
 125                         ColumnFamilyHandle* column_family,
 126                         const Slice& key) override {
 127     return db_->Delete(wopts, column_family, key);
 128   }
 129
 130   using DB::SingleDelete;
 131   virtual Status SingleDelete(const WriteOptions& wopts,
 132                               ColumnFamilyHandle* column_family,
 133                               const Slice& key) override {
 134     return db_->SingleDelete(wopts, column_family, key);
 135   }
 136
 137   using DB::Merge;
 138   virtual Status Merge(const WriteOptions& options,
 139                        ColumnFamilyHandle* column_family, const Slice& key,
 140                        const Slice& value) override {
 141     return db_->Merge(options, column_family, key, value);
 142   }
 143
 144   virtual Status Write(const WriteOptions& opts, WriteBatch* updates) override {
 145     return db_->Write(opts, updates);
 146   }
 147
 148   using DB::NewIterator;
 149   virtual Iterator* NewIterator(const ReadOptions& opts,
 150                                 ColumnFamilyHandle* column_family) override {
 151     return db_->NewIterator(opts, column_family);
 152   }
 153
 154   virtual Status NewIterators(
 155       const ReadOptions& options,
 156       const std::vector<ColumnFamilyHandle*>& column_families,
 157       std::vector<Iterator*>* iterators) override {
 158     return db_->NewIterators(options, column_families, iterators);
 159   }
 160
 161   virtual const Snapshot* GetSnapshot() override { return db_->GetSnapshot(); }
 162
 163   virtual void ReleaseSnapshot(const Snapshot* snapshot) override {
 164     return db_->ReleaseSnapshot(snapshot);
 165   }
 166
 167   using DB::GetMapProperty;
 168   using DB::GetProperty;
 169   virtual bool GetProperty(ColumnFamilyHandle* column_family,
 170                            const Slice& property, std::string* value) override {
 171     return db_->GetProperty(column_family, property, value);
 172   }
 173   virtual bool GetMapProperty(
 174       ColumnFamilyHandle* column_family, const Slice& property,
 175       std::map<std::string, std::string>* value) override {
 176     return db_->GetMapProperty(column_family, property, value);
 177   }
 178
 179   using DB::GetIntProperty;
 180   virtual bool GetIntProperty(ColumnFamilyHandle* column_family,
 181                               const Slice& property, uint64_t* value) override {
 182     return db_->GetIntProperty(column_family, property, value);
 183   }
 184
 185   using DB::GetAggregatedIntProperty;
 186   virtual bool GetAggregatedIntProperty(const Slice& property,
 187                                         uint64_t* value) override {
 188     return db_->GetAggregatedIntProperty(property, value);
 189   }
 190
 191   using DB::GetApproximateSizes;
 192   virtual void GetApproximateSizes(
 193       ColumnFamilyHandle* column_family, const Range* r, int n, uint64_t* sizes,
 194       uint8_t include_flags = INCLUDE_FILES) override {
 195     return db_->GetApproximateSizes(column_family, r, n, sizes, include_flags);
 196   }
 197
 198   using DB::GetApproximateMemTableStats;
 199   virtual void GetApproximateMemTableStats(ColumnFamilyHandle* column_family,
 200                                            const Range& range,
 201                                            uint64_t* const count,
 202                                            uint64_t* const size) override {
 203     return db_->GetApproximateMemTableStats(column_family, range, count, size);
 204   }
 205
 206   using DB::CompactRange;
 207   virtual Status CompactRange(const CompactRangeOptions& options,
 208                               ColumnFamilyHandle* column_family,
 209                               const Slice* begin, const Slice* end) override {
 210     return db_->CompactRange(options, column_family, begin, end);
 211   }
 212
 213   using DB::CompactFiles;
 214   virtual Status CompactFiles(
 215       const CompactionOptions& compact_options,
 216       ColumnFamilyHandle* column_family,
 217       const std::vector<std::string>& input_file_names, const int output_level,
 218       const int output_path_id = -1,
 219       std::vector<std::string>* const output_file_names = nullptr,
 220       CompactionJobInfo* compaction_job_info = nullptr) override {
 221     return db_->CompactFiles(compact_options, column_family, input_file_names,
 222                              output_level, output_path_id, output_file_names,
 223                              compaction_job_info);
 224   }
 225
 226   virtual Status PauseBackgroundWork() override {
 227     return db_->PauseBackgroundWork();
 228   }
 229   virtual Status ContinueBackgroundWork() override {
 230     return db_->ContinueBackgroundWork();
 231   }
 232
 233   virtual Status EnableAutoCompaction(
 234       const std::vector<ColumnFamilyHandle*>& column_family_handles) override {
 235     return db_->EnableAutoCompaction(column_family_handles);
 236   }
 237
 238   using DB::NumberLevels;
 239   virtual int NumberLevels(ColumnFamilyHandle* column_family) override {
 240     return db_->NumberLevels(column_family);
 241   }
 242
 243   using DB::MaxMemCompactionLevel;
 244   virtual int MaxMemCompactionLevel(
 245       ColumnFamilyHandle* column_family) override {
 246     return db_->MaxMemCompactionLevel(column_family);
 247   }
 248
 249   using DB::Level0StopWriteTrigger;
 250   virtual int Level0StopWriteTrigger(
 251       ColumnFamilyHandle* column_family) override {
 252     return db_->Level0StopWriteTrigger(column_family);
 253   }
 254
 255   virtual const std::string& GetName() const override { return db_->GetName(); }
 256
 257   virtual Env* GetEnv() const override { return db_->GetEnv(); }
 258
 259   using DB::GetOptions;
 260   virtual Options GetOptions(ColumnFamilyHandle* column_family) const override {
 261     return db_->GetOptions(column_family);
 262   }
 263
 264   using DB::GetDBOptions;
 265   virtual DBOptions GetDBOptions() const override {
 266     return db_->GetDBOptions();
 267   }
 268
 269   using DB::Flush;
 270   virtual Status Flush(const FlushOptions& fopts,
 271                        ColumnFamilyHandle* column_family) override {
 272     return db_->Flush(fopts, column_family);
 273   }
 274   virtual Status Flush(
 275       const FlushOptions& fopts,
 276       const std::vector<ColumnFamilyHandle*>& column_families) override {
 277     return db_->Flush(fopts, column_families);
 278   }
 279
 280   virtual Status SyncWAL() override { return db_->SyncWAL(); }
 281
 282   virtual Status FlushWAL(bool sync) override { return db_->FlushWAL(sync); }
 283
 284   virtual Status LockWAL() override { return db_->LockWAL(); }
 285
 286   virtual Status UnlockWAL() override { return db_->UnlockWAL(); }
 287
 288 #ifndef ROCKSDB_LITE
 289
 290   virtual Status DisableFileDeletions() override {
 291     return db_->DisableFileDeletions();
 292   }
 293
 294   virtual Status EnableFileDeletions(bool force) override {
 295     return db_->EnableFileDeletions(force);
 296   }
 297
 298   virtual void GetLiveFilesMetaData(
 299       std::vector<LiveFileMetaData>* metadata) override {
 300     db_->GetLiveFilesMetaData(metadata);
 301   }
 302
 303   virtual void GetColumnFamilyMetaData(ColumnFamilyHandle* column_family,
 304                                        ColumnFamilyMetaData* cf_meta) override {
 305     db_->GetColumnFamilyMetaData(column_family, cf_meta);
 306   }
 307
 308 #endif  // ROCKSDB_LITE
 309
 310   virtual Status GetLiveFiles(std::vector<std::string>& vec, uint64_t* mfs,
 311                               bool flush_memtable = true) override {
 312     return db_->GetLiveFiles(vec, mfs, flush_memtable);
 313   }
 314
 315   virtual SequenceNumber GetLatestSequenceNumber() const override {
 316     return db_->GetLatestSequenceNumber();
 317   }
 318
 319   virtual bool SetPreserveDeletesSequenceNumber(
 320       SequenceNumber seqnum) override {
 321     return db_->SetPreserveDeletesSequenceNumber(seqnum);
 322   }
 323
 324   virtual Status GetSortedWalFiles(VectorLogPtr& files) override {
 325     return db_->GetSortedWalFiles(files);
 326   }
 327
 328   virtual Status DeleteFile(std::string name) override {
 329     return db_->DeleteFile(name);
 330   }
 331
 332   virtual Status GetDbIdentity(std::string& identity) const override {
 333     return db_->GetDbIdentity(identity);
 334   }
 335
 336   using DB::SetOptions;
 337   virtual Status SetOptions(ColumnFamilyHandle* column_family_handle,
 338                             const std::unordered_map<std::string, std::string>&
 339                                 new_options) override {
 340     return db_->SetOptions(column_family_handle, new_options);
 341   }
 342
 343   virtual Status SetDBOptions(
 344       const std::unordered_map<std::string, std::string>& new_options)
 345       override {
 346     return db_->SetDBOptions(new_options);
 347   }
 348
 349   using DB::ResetStats;
 350   virtual Status ResetStats() override { return db_->ResetStats(); }
 351
 352   using DB::GetPropertiesOfAllTables;
 353   virtual Status GetPropertiesOfAllTables(
 354       ColumnFamilyHandle* column_family,
 355       TablePropertiesCollection* props) override {
 356     return db_->GetPropertiesOfAllTables(column_family, props);
 357   }
 358
 359   using DB::GetPropertiesOfTablesInRange;
 360   virtual Status GetPropertiesOfTablesInRange(
 361       ColumnFamilyHandle* column_family, const Range* range, std::size_t n,
 362       TablePropertiesCollection* props) override {
 363     return db_->GetPropertiesOfTablesInRange(column_family, range, n, props);
 364   }
 365
 366   virtual Status GetUpdatesSince(
 367       SequenceNumber seq_number, std::unique_ptr<TransactionLogIterator>* iter,
 368       const TransactionLogIterator::ReadOptions& read_options) override {
 369     return db_->GetUpdatesSince(seq_number, iter, read_options);
 370   }
 371
 372   virtual Status SuggestCompactRange(ColumnFamilyHandle* column_family,
 373                                      const Slice* begin,
 374                                      const Slice* end) override {
 375     return db_->SuggestCompactRange(column_family, begin, end);
 376   }
 377
 378   virtual Status PromoteL0(ColumnFamilyHandle* column_family,
 379                            int target_level) override {
 380     return db_->PromoteL0(column_family, target_level);
 381   }
 382
 383   virtual ColumnFamilyHandle* DefaultColumnFamily() const override {
 384     return db_->DefaultColumnFamily();
 385   }
 386
 387  protected:
 388   DB* db_;
 389   std::shared_ptr<DB> shared_db_ptr_;
 390 };
 391
 392 }  //  namespace rocksdb