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

   1 // Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
   2 // Copyright (c) 2011 The LevelDB Authors. All rights reserved.
   3 // Use of this source code is governed by a BSD-style license that can be
   4 // found in the LICENSE file. See the AUTHORS file for names of contributors.
   5
   6 #pragma once
   7 #include <map>
   8 #include <memory>
   9 #include <string>
  10 #include "rocksdb/db.h"
  11
  12 #ifdef _WIN32
  13 // Windows API macro interference
  14 #undef DeleteFile
  15 #endif
  16
  17 namespace ROCKSDB_NAMESPACE {
  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() { return db_; }
  41
  42   virtual DB* GetRootDB() override { return db_->GetRootDB(); }
  43
  44   virtual Status CreateColumnFamily(const ColumnFamilyOptions& options,
  45                                     const std::string& column_family_name,
  46                                     ColumnFamilyHandle** handle) override {
  47     return db_->CreateColumnFamily(options, column_family_name, handle);
  48   }
  49
  50   virtual Status CreateColumnFamilies(
  51       const ColumnFamilyOptions& options,
  52       const std::vector<std::string>& column_family_names,
  53       std::vector<ColumnFamilyHandle*>* handles) override {
  54     return db_->CreateColumnFamilies(options, column_family_names, handles);
  55   }
  56
  57   virtual Status CreateColumnFamilies(
  58       const std::vector<ColumnFamilyDescriptor>& column_families,
  59       std::vector<ColumnFamilyHandle*>* handles) override {
  60     return db_->CreateColumnFamilies(column_families, handles);
  61   }
  62
  63   virtual Status DropColumnFamily(ColumnFamilyHandle* column_family) override {
  64     return db_->DropColumnFamily(column_family);
  65   }
  66
  67   virtual Status DropColumnFamilies(
  68       const std::vector<ColumnFamilyHandle*>& column_families) override {
  69     return db_->DropColumnFamilies(column_families);
  70   }
  71
  72   virtual Status DestroyColumnFamilyHandle(
  73       ColumnFamilyHandle* column_family) override {
  74     return db_->DestroyColumnFamilyHandle(column_family);
  75   }
  76
  77   using DB::Put;
  78   virtual Status Put(const WriteOptions& options,
  79                      ColumnFamilyHandle* column_family, const Slice& key,
  80                      const Slice& val) override {
  81     return db_->Put(options, column_family, key, val);
  82   }
  83
  84   using DB::Get;
  85   virtual Status Get(const ReadOptions& options,
  86                      ColumnFamilyHandle* column_family, const Slice& key,
  87                      PinnableSlice* value) override {
  88     return db_->Get(options, column_family, key, value);
  89   }
  90
  91   using DB::GetMergeOperands;
  92   virtual Status GetMergeOperands(
  93       const ReadOptions& options, ColumnFamilyHandle* column_family,
  94       const Slice& key, PinnableSlice* slice,
  95       GetMergeOperandsOptions* get_merge_operands_options,
  96       int* number_of_operands) override {
  97     return db_->GetMergeOperands(options, column_family, key, slice,
  98                                  get_merge_operands_options,
  99                                  number_of_operands);
 100   }
 101
 102   using DB::MultiGet;
 103   virtual std::vector<Status> MultiGet(
 104       const ReadOptions& options,
 105       const std::vector<ColumnFamilyHandle*>& column_family,
 106       const std::vector<Slice>& keys,
 107       std::vector<std::string>* values) override {
 108     return db_->MultiGet(options, column_family, keys, values);
 109   }
 110
 111   virtual void MultiGet(const ReadOptions& options,
 112                         ColumnFamilyHandle* column_family,
 113                         const size_t num_keys, const Slice* keys,
 114                         PinnableSlice* values, Status* statuses,
 115                         const bool sorted_input = false) override {
 116     return db_->MultiGet(options, column_family, num_keys, keys,
 117                          values, statuses, sorted_input);
 118   }
 119
 120   using DB::IngestExternalFile;
 121   virtual Status IngestExternalFile(
 122       ColumnFamilyHandle* column_family,
 123       const std::vector<std::string>& external_files,
 124       const IngestExternalFileOptions& options) override {
 125     return db_->IngestExternalFile(column_family, external_files, options);
 126   }
 127
 128   using DB::IngestExternalFiles;
 129   virtual Status IngestExternalFiles(
 130       const std::vector<IngestExternalFileArg>& args) override {
 131     return db_->IngestExternalFiles(args);
 132   }
 133
 134   using DB::CreateColumnFamilyWithImport;
 135   virtual Status CreateColumnFamilyWithImport(
 136       const ColumnFamilyOptions& options, const std::string& column_family_name,
 137       const ImportColumnFamilyOptions& import_options,
 138       const ExportImportFilesMetaData& metadata,
 139       ColumnFamilyHandle** handle) override {
 140     return db_->CreateColumnFamilyWithImport(options, column_family_name,
 141                                              import_options, metadata, handle);
 142   }
 143
 144   using DB::VerifyFileChecksums;
 145   Status VerifyFileChecksums(const ReadOptions& read_opts) override {
 146     return db_->VerifyFileChecksums(read_opts);
 147   }
 148
 149   virtual Status VerifyChecksum() override { return db_->VerifyChecksum(); }
 150
 151   virtual Status VerifyChecksum(const ReadOptions& options) override {
 152     return db_->VerifyChecksum(options);
 153   }
 154
 155   using DB::KeyMayExist;
 156   virtual bool KeyMayExist(const ReadOptions& options,
 157                            ColumnFamilyHandle* column_family, const Slice& key,
 158                            std::string* value,
 159                            bool* value_found = nullptr) override {
 160     return db_->KeyMayExist(options, column_family, key, value, value_found);
 161   }
 162
 163   using DB::Delete;
 164   virtual Status Delete(const WriteOptions& wopts,
 165                         ColumnFamilyHandle* column_family,
 166                         const Slice& key) override {
 167     return db_->Delete(wopts, column_family, key);
 168   }
 169
 170   using DB::SingleDelete;
 171   virtual Status SingleDelete(const WriteOptions& wopts,
 172                               ColumnFamilyHandle* column_family,
 173                               const Slice& key) override {
 174     return db_->SingleDelete(wopts, column_family, key);
 175   }
 176
 177   using DB::Merge;
 178   virtual Status Merge(const WriteOptions& options,
 179                        ColumnFamilyHandle* column_family, const Slice& key,
 180                        const Slice& value) override {
 181     return db_->Merge(options, column_family, key, value);
 182   }
 183
 184   virtual Status Write(const WriteOptions& opts, WriteBatch* updates) override {
 185     return db_->Write(opts, updates);
 186   }
 187
 188   using DB::NewIterator;
 189   virtual Iterator* NewIterator(const ReadOptions& opts,
 190                                 ColumnFamilyHandle* column_family) override {
 191     return db_->NewIterator(opts, column_family);
 192   }
 193
 194   virtual Status NewIterators(
 195       const ReadOptions& options,
 196       const std::vector<ColumnFamilyHandle*>& column_families,
 197       std::vector<Iterator*>* iterators) override {
 198     return db_->NewIterators(options, column_families, iterators);
 199   }
 200
 201   virtual const Snapshot* GetSnapshot() override { return db_->GetSnapshot(); }
 202
 203   virtual void ReleaseSnapshot(const Snapshot* snapshot) override {
 204     return db_->ReleaseSnapshot(snapshot);
 205   }
 206
 207   using DB::GetMapProperty;
 208   using DB::GetProperty;
 209   virtual bool GetProperty(ColumnFamilyHandle* column_family,
 210                            const Slice& property, std::string* value) override {
 211     return db_->GetProperty(column_family, property, value);
 212   }
 213   virtual bool GetMapProperty(
 214       ColumnFamilyHandle* column_family, const Slice& property,
 215       std::map<std::string, std::string>* value) override {
 216     return db_->GetMapProperty(column_family, property, value);
 217   }
 218
 219   using DB::GetIntProperty;
 220   virtual bool GetIntProperty(ColumnFamilyHandle* column_family,
 221                               const Slice& property, uint64_t* value) override {
 222     return db_->GetIntProperty(column_family, property, value);
 223   }
 224
 225   using DB::GetAggregatedIntProperty;
 226   virtual bool GetAggregatedIntProperty(const Slice& property,
 227                                         uint64_t* value) override {
 228     return db_->GetAggregatedIntProperty(property, value);
 229   }
 230
 231   using DB::GetApproximateSizes;
 232   virtual Status GetApproximateSizes(const SizeApproximationOptions& options,
 233                                      ColumnFamilyHandle* column_family,
 234                                      const Range* r, int n,
 235                                      uint64_t* sizes) override {
 236     return db_->GetApproximateSizes(options, column_family, r, n, sizes);
 237   }
 238
 239   using DB::GetApproximateMemTableStats;
 240   virtual void GetApproximateMemTableStats(ColumnFamilyHandle* column_family,
 241                                            const Range& range,
 242                                            uint64_t* const count,
 243                                            uint64_t* const size) override {
 244     return db_->GetApproximateMemTableStats(column_family, range, count, size);
 245   }
 246
 247   using DB::CompactRange;
 248   virtual Status CompactRange(const CompactRangeOptions& options,
 249                               ColumnFamilyHandle* column_family,
 250                               const Slice* begin, const Slice* end) override {
 251     return db_->CompactRange(options, column_family, begin, end);
 252   }
 253
 254   using DB::CompactFiles;
 255   virtual Status CompactFiles(
 256       const CompactionOptions& compact_options,
 257       ColumnFamilyHandle* column_family,
 258       const std::vector<std::string>& input_file_names, const int output_level,
 259       const int output_path_id = -1,
 260       std::vector<std::string>* const output_file_names = nullptr,
 261       CompactionJobInfo* compaction_job_info = nullptr) override {
 262     return db_->CompactFiles(compact_options, column_family, input_file_names,
 263                              output_level, output_path_id, output_file_names,
 264                              compaction_job_info);
 265   }
 266
 267   virtual Status PauseBackgroundWork() override {
 268     return db_->PauseBackgroundWork();
 269   }
 270   virtual Status ContinueBackgroundWork() override {
 271     return db_->ContinueBackgroundWork();
 272   }
 273
 274   virtual Status EnableAutoCompaction(
 275       const std::vector<ColumnFamilyHandle*>& column_family_handles) override {
 276     return db_->EnableAutoCompaction(column_family_handles);
 277   }
 278
 279   virtual void EnableManualCompaction() override {
 280     return db_->EnableManualCompaction();
 281   }
 282   virtual void DisableManualCompaction() override {
 283     return db_->DisableManualCompaction();
 284   }
 285
 286   using DB::NumberLevels;
 287   virtual int NumberLevels(ColumnFamilyHandle* column_family) override {
 288     return db_->NumberLevels(column_family);
 289   }
 290
 291   using DB::MaxMemCompactionLevel;
 292   virtual int MaxMemCompactionLevel(
 293       ColumnFamilyHandle* column_family) override {
 294     return db_->MaxMemCompactionLevel(column_family);
 295   }
 296
 297   using DB::Level0StopWriteTrigger;
 298   virtual int Level0StopWriteTrigger(
 299       ColumnFamilyHandle* column_family) override {
 300     return db_->Level0StopWriteTrigger(column_family);
 301   }
 302
 303   virtual const std::string& GetName() const override { return db_->GetName(); }
 304
 305   virtual Env* GetEnv() const override { return db_->GetEnv(); }
 306
 307   virtual FileSystem* GetFileSystem() const override {
 308     return db_->GetFileSystem();
 309   }
 310
 311   using DB::GetOptions;
 312   virtual Options GetOptions(ColumnFamilyHandle* column_family) const override {
 313     return db_->GetOptions(column_family);
 314   }
 315
 316   using DB::GetDBOptions;
 317   virtual DBOptions GetDBOptions() const override {
 318     return db_->GetDBOptions();
 319   }
 320
 321   using DB::Flush;
 322   virtual Status Flush(const FlushOptions& fopts,
 323                        ColumnFamilyHandle* column_family) override {
 324     return db_->Flush(fopts, column_family);
 325   }
 326   virtual Status Flush(
 327       const FlushOptions& fopts,
 328       const std::vector<ColumnFamilyHandle*>& column_families) override {
 329     return db_->Flush(fopts, column_families);
 330   }
 331
 332   virtual Status SyncWAL() override { return db_->SyncWAL(); }
 333
 334   virtual Status FlushWAL(bool sync) override { return db_->FlushWAL(sync); }
 335
 336   virtual Status LockWAL() override { return db_->LockWAL(); }
 337
 338   virtual Status UnlockWAL() override { return db_->UnlockWAL(); }
 339
 340 #ifndef ROCKSDB_LITE
 341
 342   virtual Status DisableFileDeletions() override {
 343     return db_->DisableFileDeletions();
 344   }
 345
 346   virtual Status EnableFileDeletions(bool force) override {
 347     return db_->EnableFileDeletions(force);
 348   }
 349
 350   virtual void GetLiveFilesMetaData(
 351       std::vector<LiveFileMetaData>* metadata) override {
 352     db_->GetLiveFilesMetaData(metadata);
 353   }
 354
 355   virtual Status GetLiveFilesChecksumInfo(
 356       FileChecksumList* checksum_list) override {
 357     return db_->GetLiveFilesChecksumInfo(checksum_list);
 358   }
 359
 360   virtual void GetColumnFamilyMetaData(ColumnFamilyHandle* column_family,
 361                                        ColumnFamilyMetaData* cf_meta) override {
 362     db_->GetColumnFamilyMetaData(column_family, cf_meta);
 363   }
 364
 365   using DB::StartBlockCacheTrace;
 366   Status StartBlockCacheTrace(
 367       const TraceOptions& options,
 368       std::unique_ptr<TraceWriter>&& trace_writer) override {
 369     return db_->StartBlockCacheTrace(options, std::move(trace_writer));
 370   }
 371
 372   using DB::EndBlockCacheTrace;
 373   Status EndBlockCacheTrace() override { return db_->EndBlockCacheTrace(); }
 374
 375   using DB::StartIOTrace;
 376   Status StartIOTrace(Env* env, const TraceOptions& options,
 377                       std::unique_ptr<TraceWriter>&& trace_writer) override {
 378     return db_->StartIOTrace(env, options, std::move(trace_writer));
 379   }
 380
 381   using DB::EndIOTrace;
 382   Status EndIOTrace() override { return db_->EndIOTrace(); }
 383
 384   using DB::StartTrace;
 385   Status StartTrace(const TraceOptions& options,
 386                     std::unique_ptr<TraceWriter>&& trace_writer) override {
 387     return db_->StartTrace(options, std::move(trace_writer));
 388   }
 389
 390   using DB::EndTrace;
 391   Status EndTrace() override { return db_->EndTrace(); }
 392
 393 #endif  // ROCKSDB_LITE
 394
 395   virtual Status GetLiveFiles(std::vector<std::string>& vec, uint64_t* mfs,
 396                               bool flush_memtable = true) override {
 397     return db_->GetLiveFiles(vec, mfs, flush_memtable);
 398   }
 399
 400   virtual SequenceNumber GetLatestSequenceNumber() const override {
 401     return db_->GetLatestSequenceNumber();
 402   }
 403
 404   virtual bool SetPreserveDeletesSequenceNumber(
 405       SequenceNumber seqnum) override {
 406     return db_->SetPreserveDeletesSequenceNumber(seqnum);
 407   }
 408
 409   virtual Status GetSortedWalFiles(VectorLogPtr& files) override {
 410     return db_->GetSortedWalFiles(files);
 411   }
 412
 413   virtual Status GetCurrentWalFile(
 414       std::unique_ptr<LogFile>* current_log_file) override {
 415     return db_->GetCurrentWalFile(current_log_file);
 416   }
 417
 418   virtual Status GetCreationTimeOfOldestFile(
 419       uint64_t* creation_time) override {
 420     return db_->GetCreationTimeOfOldestFile(creation_time);
 421   }
 422
 423   // WARNING: This API is planned for removal in RocksDB 7.0 since it does not
 424   // operate at the proper level of abstraction for a key-value store, and its
 425   // contract/restrictions are poorly documented. For example, it returns non-OK
 426   // `Status` for non-bottommost files and files undergoing compaction. Since we
 427   // do not plan to maintain it, the contract will likely remain underspecified
 428   // until its removal. Any user is encouraged to read the implementation
 429   // carefully and migrate away from it when possible.
 430   virtual Status DeleteFile(std::string name) override {
 431     return db_->DeleteFile(name);
 432   }
 433
 434   virtual Status GetDbIdentity(std::string& identity) const override {
 435     return db_->GetDbIdentity(identity);
 436   }
 437
 438   virtual Status GetDbSessionId(std::string& session_id) const override {
 439     return db_->GetDbSessionId(session_id);
 440   }
 441
 442   using DB::SetOptions;
 443   virtual Status SetOptions(ColumnFamilyHandle* column_family_handle,
 444                             const std::unordered_map<std::string, std::string>&
 445                                 new_options) override {
 446     return db_->SetOptions(column_family_handle, new_options);
 447   }
 448
 449   virtual Status SetDBOptions(
 450       const std::unordered_map<std::string, std::string>& new_options)
 451       override {
 452     return db_->SetDBOptions(new_options);
 453   }
 454
 455   using DB::ResetStats;
 456   virtual Status ResetStats() override { return db_->ResetStats(); }
 457
 458   using DB::GetPropertiesOfAllTables;
 459   virtual Status GetPropertiesOfAllTables(
 460       ColumnFamilyHandle* column_family,
 461       TablePropertiesCollection* props) override {
 462     return db_->GetPropertiesOfAllTables(column_family, props);
 463   }
 464
 465   using DB::GetPropertiesOfTablesInRange;
 466   virtual Status GetPropertiesOfTablesInRange(
 467       ColumnFamilyHandle* column_family, const Range* range, std::size_t n,
 468       TablePropertiesCollection* props) override {
 469     return db_->GetPropertiesOfTablesInRange(column_family, range, n, props);
 470   }
 471
 472   virtual Status GetUpdatesSince(
 473       SequenceNumber seq_number, std::unique_ptr<TransactionLogIterator>* iter,
 474       const TransactionLogIterator::ReadOptions& read_options) override {
 475     return db_->GetUpdatesSince(seq_number, iter, read_options);
 476   }
 477
 478   virtual Status SuggestCompactRange(ColumnFamilyHandle* column_family,
 479                                      const Slice* begin,
 480                                      const Slice* end) override {
 481     return db_->SuggestCompactRange(column_family, begin, end);
 482   }
 483
 484   virtual Status PromoteL0(ColumnFamilyHandle* column_family,
 485                            int target_level) override {
 486     return db_->PromoteL0(column_family, target_level);
 487   }
 488
 489   virtual ColumnFamilyHandle* DefaultColumnFamily() const override {
 490     return db_->DefaultColumnFamily();
 491   }
 492
 493 #ifndef ROCKSDB_LITE
 494   Status TryCatchUpWithPrimary() override {
 495     return db_->TryCatchUpWithPrimary();
 496   }
 497 #endif  // ROCKSDB_LITE
 498
 499  protected:
 500   DB* db_;
 501   std::shared_ptr<DB> shared_db_ptr_;
 502 };
 503
 504 }  // namespace ROCKSDB_NAMESPACE