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
  17 namespace rocksdb {
  18
  19 // This class contains APIs to stack rocksdb wrappers.Eg. Stack TTL over base d
  20 class StackableDB : public DB {
  21  public:
  22   // StackableDB take sole ownership of the underlying db.
  23   explicit StackableDB(DB* db) : db_(db) {}
  24
  25   // StackableDB take shared ownership of the underlying db.
  26   explicit StackableDB(std::shared_ptr<DB> db)
  27       : db_(db.get()), shared_db_ptr_(db) {}
  28
  29   ~StackableDB() {
  30     if (shared_db_ptr_ == nullptr) {
  31       delete db_;
  32     } else {
  33       assert(shared_db_ptr_.get() == db_);
  34     }
  35     db_ = nullptr;
  36   }
  37
  38   virtual Status Close() override { return db_->Close(); }
  39
  40   virtual DB* GetBaseDB() {
  41     return db_;
  42   }
  43
  44   virtual DB* GetRootDB() override { return db_->GetRootDB(); }
  45
  46   virtual Status CreateColumnFamily(const ColumnFamilyOptions& options,
  47                                     const std::string& column_family_name,
  48                                     ColumnFamilyHandle** handle) override {
  49     return db_->CreateColumnFamily(options, column_family_name, handle);
  50   }
  51
  52   virtual Status CreateColumnFamilies(
  53       const ColumnFamilyOptions& options,
  54       const std::vector<std::string>& column_family_names,
  55       std::vector<ColumnFamilyHandle*>* handles) override {
  56     return db_->CreateColumnFamilies(options, column_family_names, handles);
  57   }
  58
  59   virtual Status CreateColumnFamilies(
  60       const std::vector<ColumnFamilyDescriptor>& column_families,
  61       std::vector<ColumnFamilyHandle*>* handles) override {
  62     return db_->CreateColumnFamilies(column_families, handles);
  63   }
  64
  65   virtual Status DropColumnFamily(ColumnFamilyHandle* column_family) override {
  66     return db_->DropColumnFamily(column_family);
  67   }
  68
  69   virtual Status DropColumnFamilies(
  70       const std::vector<ColumnFamilyHandle*>& column_families) override {
  71     return db_->DropColumnFamilies(column_families);
  72   }
  73
  74   virtual Status DestroyColumnFamilyHandle(
  75       ColumnFamilyHandle* column_family) override {
  76     return db_->DestroyColumnFamilyHandle(column_family);
  77   }
  78
  79   using DB::Put;
  80   virtual Status Put(const WriteOptions& options,
  81                      ColumnFamilyHandle* column_family, const Slice& key,
  82                      const Slice& val) override {
  83     return db_->Put(options, column_family, key, val);
  84   }
  85
  86   using DB::Get;
  87   virtual Status Get(const ReadOptions& options,
  88                      ColumnFamilyHandle* column_family, const Slice& key,
  89                      PinnableSlice* value) override {
  90     return db_->Get(options, column_family, key, value);
  91   }
  92
  93   using DB::MultiGet;
  94   virtual std::vector<Status> MultiGet(
  95       const ReadOptions& options,
  96       const std::vector<ColumnFamilyHandle*>& column_family,
  97       const std::vector<Slice>& keys,
  98       std::vector<std::string>* values) override {
  99     return db_->MultiGet(options, column_family, keys, values);
 100   }
 101
 102   using DB::IngestExternalFile;
 103   virtual Status IngestExternalFile(
 104       ColumnFamilyHandle* column_family,
 105       const std::vector<std::string>& external_files,
 106       const IngestExternalFileOptions& options) override {
 107     return db_->IngestExternalFile(column_family, external_files, options);
 108   }
 109
 110   virtual Status VerifyChecksum() override { return db_->VerifyChecksum(); }
 111
 112   using DB::KeyMayExist;
 113   virtual bool KeyMayExist(const ReadOptions& options,
 114                            ColumnFamilyHandle* column_family, const Slice& key,
 115                            std::string* value,
 116                            bool* value_found = nullptr) override {
 117     return db_->KeyMayExist(options, column_family, key, value, value_found);
 118   }
 119
 120   using DB::Delete;
 121   virtual Status Delete(const WriteOptions& wopts,
 122                         ColumnFamilyHandle* column_family,
 123                         const Slice& key) override {
 124     return db_->Delete(wopts, column_family, key);
 125   }
 126
 127   using DB::SingleDelete;
 128   virtual Status SingleDelete(const WriteOptions& wopts,
 129                               ColumnFamilyHandle* column_family,
 130                               const Slice& key) override {
 131     return db_->SingleDelete(wopts, column_family, key);
 132   }
 133
 134   using DB::Merge;
 135   virtual Status Merge(const WriteOptions& options,
 136                        ColumnFamilyHandle* column_family, const Slice& key,
 137                        const Slice& value) override {
 138     return db_->Merge(options, column_family, key, value);
 139   }
 140
 141
 142   virtual Status Write(const WriteOptions& opts, WriteBatch* updates)
 143     override {
 144       return db_->Write(opts, updates);
 145   }
 146
 147   using DB::NewIterator;
 148   virtual Iterator* NewIterator(const ReadOptions& opts,
 149                                 ColumnFamilyHandle* column_family) override {
 150     return db_->NewIterator(opts, column_family);
 151   }
 152
 153   virtual Status NewIterators(
 154       const ReadOptions& options,
 155       const std::vector<ColumnFamilyHandle*>& column_families,
 156       std::vector<Iterator*>* iterators) override {
 157     return db_->NewIterators(options, column_families, iterators);
 158   }
 159
 160
 161   virtual const Snapshot* GetSnapshot() override {
 162     return db_->GetSnapshot();
 163   }
 164
 165   virtual void ReleaseSnapshot(const Snapshot* snapshot) override {
 166     return db_->ReleaseSnapshot(snapshot);
 167   }
 168
 169   using DB::GetMapProperty;
 170   using DB::GetProperty;
 171   virtual bool GetProperty(ColumnFamilyHandle* column_family,
 172                            const Slice& property, std::string* value) override {
 173     return db_->GetProperty(column_family, property, value);
 174   }
 175   virtual bool GetMapProperty(
 176       ColumnFamilyHandle* column_family, const Slice& property,
 177       std::map<std::string, std::string>* value) override {
 178     return db_->GetMapProperty(column_family, property, value);
 179   }
 180
 181   using DB::GetIntProperty;
 182   virtual bool GetIntProperty(ColumnFamilyHandle* column_family,
 183                               const Slice& property, uint64_t* value) override {
 184     return db_->GetIntProperty(column_family, property, value);
 185   }
 186
 187   using DB::GetAggregatedIntProperty;
 188   virtual bool GetAggregatedIntProperty(const Slice& property,
 189                                         uint64_t* value) override {
 190     return db_->GetAggregatedIntProperty(property, value);
 191   }
 192
 193   using DB::GetApproximateSizes;
 194   virtual void GetApproximateSizes(ColumnFamilyHandle* column_family,
 195                                    const Range* r, int n, uint64_t* sizes,
 196                                    uint8_t include_flags
 197                                    = INCLUDE_FILES) override {
 198     return db_->GetApproximateSizes(column_family, r, n, sizes,
 199                                     include_flags);
 200   }
 201
 202   using DB::GetApproximateMemTableStats;
 203   virtual void GetApproximateMemTableStats(ColumnFamilyHandle* column_family,
 204                                            const Range& range,
 205                                            uint64_t* const count,
 206                                            uint64_t* const size) override {
 207     return db_->GetApproximateMemTableStats(column_family, range, count, size);
 208   }
 209
 210   using DB::CompactRange;
 211   virtual Status CompactRange(const CompactRangeOptions& options,
 212                               ColumnFamilyHandle* column_family,
 213                               const Slice* begin, const Slice* end) override {
 214     return db_->CompactRange(options, column_family, begin, end);
 215   }
 216
 217   using DB::CompactFiles;
 218   virtual Status CompactFiles(
 219       const CompactionOptions& compact_options,
 220       ColumnFamilyHandle* column_family,
 221       const std::vector<std::string>& input_file_names,
 222       const int output_level, const int output_path_id = -1,
 223       std::vector<std::string>* const output_file_names = nullptr) override {
 224     return db_->CompactFiles(
 225         compact_options, column_family, input_file_names,
 226         output_level, output_path_id, output_file_names);
 227   }
 228
 229   virtual Status PauseBackgroundWork() override {
 230     return db_->PauseBackgroundWork();
 231   }
 232   virtual Status ContinueBackgroundWork() override {
 233     return db_->ContinueBackgroundWork();
 234   }
 235
 236   virtual Status EnableAutoCompaction(
 237       const std::vector<ColumnFamilyHandle*>& column_family_handles) override {
 238     return db_->EnableAutoCompaction(column_family_handles);
 239   }
 240
 241   using DB::NumberLevels;
 242   virtual int NumberLevels(ColumnFamilyHandle* column_family) override {
 243     return db_->NumberLevels(column_family);
 244   }
 245
 246   using DB::MaxMemCompactionLevel;
 247   virtual int MaxMemCompactionLevel(ColumnFamilyHandle* column_family)
 248       override {
 249     return db_->MaxMemCompactionLevel(column_family);
 250   }
 251
 252   using DB::Level0StopWriteTrigger;
 253   virtual int Level0StopWriteTrigger(ColumnFamilyHandle* column_family)
 254       override {
 255     return db_->Level0StopWriteTrigger(column_family);
 256   }
 257
 258   virtual const std::string& GetName() const override {
 259     return db_->GetName();
 260   }
 261
 262   virtual Env* GetEnv() const override {
 263     return db_->GetEnv();
 264   }
 265
 266   using DB::GetOptions;
 267   virtual Options GetOptions(ColumnFamilyHandle* column_family) const override {
 268     return db_->GetOptions(column_family);
 269   }
 270
 271   using DB::GetDBOptions;
 272   virtual DBOptions GetDBOptions() const override {
 273     return db_->GetDBOptions();
 274   }
 275
 276   using DB::Flush;
 277   virtual Status Flush(const FlushOptions& fopts,
 278                        ColumnFamilyHandle* column_family) override {
 279     return db_->Flush(fopts, column_family);
 280   }
 281
 282   virtual Status SyncWAL() override {
 283     return db_->SyncWAL();
 284   }
 285
 286   virtual Status FlushWAL(bool sync) override { return db_->FlushWAL(sync); }
 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(
 304       ColumnFamilyHandle *column_family,
 305       ColumnFamilyMetaData* cf_meta) override {
 306     db_->GetColumnFamilyMetaData(column_family, cf_meta);
 307   }
 308
 309 #endif  // ROCKSDB_LITE
 310
 311   virtual Status GetLiveFiles(std::vector<std::string>& vec, uint64_t* mfs,
 312                               bool flush_memtable = true) override {
 313       return db_->GetLiveFiles(vec, mfs, flush_memtable);
 314   }
 315
 316   virtual SequenceNumber GetLatestSequenceNumber() const override {
 317     return db_->GetLatestSequenceNumber();
 318   }
 319
 320   virtual bool SetPreserveDeletesSequenceNumber(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, 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