[RocksDB] Interface changes required for BackupableDB

Summary: This is part of https://reviews.facebook.net/D14295 -- smaller diff that is easier to review

Test Plan: make asan_check

Reviewers: dhruba, haobo, emayanke

Reviewed By: emayanke

CC: leveldb, kailiu, reconnect.grayhat

Differential Revision: https://reviews.facebook.net/D14301

db/db_impl.cc

@@ -3131,6 +3131,10 @@ Status DBImpl::MakeRoomForWrite(bool force) {
   return s;
 }
 
+Env* DBImpl::GetEnv() const {
+  return env_;
+}
+
 bool DBImpl::GetProperty(const Slice& property, std::string* value) {
   value->clear();
 

db/db_impl.h

@@ -67,6 +67,7 @@ class DBImpl : public DB {
   virtual int NumberLevels();
   virtual int MaxMemCompactionLevel();
   virtual int Level0StopWriteTrigger();
+  virtual Env* GetEnv() const;
   virtual Status Flush(const FlushOptions& options);
   virtual Status DisableFileDeletions();
   virtual Status EnableFileDeletions();

db/db_test.cc

@@ -4462,6 +4462,10 @@ class ModelDB: public DB {
   return -1;
   }
 
+  virtual Env* GetEnv() const {
+    return nullptr;
+  }
+
   virtual Status Flush(const rocksdb::FlushOptions& options) {
     Status ret;
     return ret;

include/rocksdb/db.h

@@ -228,6 +228,9 @@ class DB {
   // Number of files in level-0 that would stop writes.
   virtual int Level0StopWriteTrigger() = 0;
 
+  // Get Env object from the DB
+  virtual Env* GetEnv() const = 0;
+
   // Flush all mem-table data.
   virtual Status Flush(const FlushOptions& options) = 0;
 

include/utilities/stackable_db.h

@@ -10,152 +10,140 @@ namespace rocksdb {
 // This class contains APIs to stack rocksdb wrappers.Eg. Stack TTL over base d
 class StackableDB : public DB {
  public:
-  explicit StackableDB(StackableDB* sdb) : sdb_(sdb) {}
+  // StackableDB is the owner of db now!
+  explicit StackableDB(DB* db) : db_(db) {}
 
-  // Returns the DB object that is the lowermost component in the stack of DBs
+  ~StackableDB() {
-  virtual DB* GetRawDB() {
+    delete db_;
-    return sdb_->GetRawDB();
   }
 
-  // convert a DB to StackableDB
+  virtual DB* GetBaseDB() {
-  // TODO: This function does not work yet. Passing nullptr to StackableDB in
+    return db_;
-  //       NewStackableDB's constructor will cause segfault on object's usage
-  static StackableDB* DBToStackableDB(DB* db) {
-    class NewStackableDB : public StackableDB {
-     public:
-      NewStackableDB(DB* db)
-        : StackableDB(nullptr),
-          db_(db) {}
-
-      DB* GetRawDB() {
-        return db_;
-      }
-
-     private:
-      DB* db_;
-    };
-    return new NewStackableDB(db);
   }
 
   virtual Status Put(const WriteOptions& options,
                      const Slice& key,
                      const Slice& val) override {
-    return sdb_->Put(options, key, val);
+    return db_->Put(options, key, val);
   }
 
   virtual Status Get(const ReadOptions& options,
                      const Slice& key,
                      std::string* value) override {
-    return sdb_->Get(options, key, value);
+    return db_->Get(options, key, value);
   }
 
   virtual std::vector<Status> MultiGet(const ReadOptions& options,
                                        const std::vector<Slice>& keys,
                                        std::vector<std::string>* values)
     override {
-      return sdb_->MultiGet(options, keys, values);
+      return db_->MultiGet(options, keys, values);
   }
 
   virtual bool KeyMayExist(const ReadOptions& options,
                            const Slice& key,
                            std::string* value,
                            bool* value_found = nullptr) override {
-    return sdb_->KeyMayExist(options, key, value, value_found);
+    return db_->KeyMayExist(options, key, value, value_found);
   }
 
   virtual Status Delete(const WriteOptions& wopts, const Slice& key) override {
-    return sdb_->Delete(wopts, key);
+    return db_->Delete(wopts, key);
   }
 
   virtual Status Merge(const WriteOptions& options,
                        const Slice& key,
                        const Slice& value) override {
-    return sdb_->Merge(options, key, value);
+    return db_->Merge(options, key, value);
   }
 
 
   virtual Status Write(const WriteOptions& opts, WriteBatch* updates)
     override {
-      return sdb_->Write(opts, updates);
+      return db_->Write(opts, updates);
   }
 
   virtual Iterator* NewIterator(const ReadOptions& opts) override {
-    return sdb_->NewIterator(opts);
+    return db_->NewIterator(opts);
   }
 
   virtual const Snapshot* GetSnapshot() override {
-    return sdb_->GetSnapshot();
+    return db_->GetSnapshot();
   }
 
   virtual void ReleaseSnapshot(const Snapshot* snapshot) override {
-    return sdb_->ReleaseSnapshot(snapshot);
+    return db_->ReleaseSnapshot(snapshot);
   }
 
   virtual bool GetProperty(const Slice& property, std::string* value)
     override {
-      return sdb_->GetProperty(property, value);
+      return db_->GetProperty(property, value);
   }
 
   virtual void GetApproximateSizes(const Range* r, int n, uint64_t* sizes)
     override {
-      return sdb_->GetApproximateSizes(r, n, sizes);
+      return db_->GetApproximateSizes(r, n, sizes);
   }
 
   virtual void CompactRange(const Slice* begin, const Slice* end,
                             bool reduce_level = false,
                             int target_level = -1) override {
-    return sdb_->CompactRange(begin, end, reduce_level, target_level);
+    return db_->CompactRange(begin, end, reduce_level, target_level);
   }
 
   virtual int NumberLevels() override {
-    return sdb_->NumberLevels();
+    return db_->NumberLevels();
   }
 
   virtual int MaxMemCompactionLevel() override {
-    return sdb_->MaxMemCompactionLevel();
+    return db_->MaxMemCompactionLevel();
   }
 
   virtual int Level0StopWriteTrigger() override {
-    return sdb_->Level0StopWriteTrigger();
+    return db_->Level0StopWriteTrigger();
+  }
+
+  virtual Env* GetEnv() const override {
+    return db_->GetEnv();
   }
 
   virtual Status Flush(const FlushOptions& fopts) override {
-    return sdb_->Flush(fopts);
+    return db_->Flush(fopts);
   }
 
   virtual Status DisableFileDeletions() override {
-    return sdb_->DisableFileDeletions();
+    return db_->DisableFileDeletions();
   }
 
   virtual Status EnableFileDeletions() override {
-    return sdb_->EnableFileDeletions();
+    return db_->EnableFileDeletions();
   }
 
   virtual Status GetLiveFiles(std::vector<std::string>& vec, uint64_t* mfs,
                               bool flush_memtable = true) override {
-      return sdb_->GetLiveFiles(vec, mfs, flush_memtable);
+      return db_->GetLiveFiles(vec, mfs, flush_memtable);
   }
 
   virtual SequenceNumber GetLatestSequenceNumber() const override {
-    return sdb_->GetLatestSequenceNumber();
+    return db_->GetLatestSequenceNumber();
   }
 
   virtual Status GetSortedWalFiles(VectorLogPtr& files) override {
-    return sdb_->GetSortedWalFiles(files);
+    return db_->GetSortedWalFiles(files);
   }
 
   virtual Status DeleteFile(std::string name) override {
-    return sdb_->DeleteFile(name);
+    return db_->DeleteFile(name);
   }
 
   virtual Status GetUpdatesSince(SequenceNumber seq_number,
                                  unique_ptr<TransactionLogIterator>* iter)
     override {
-      return sdb_->GetUpdatesSince(seq_number, iter);
+      return db_->GetUpdatesSince(seq_number, iter);
   }
 
  protected:
-  StackableDB* sdb_;
+  DB* db_;
 };
 
 } //  namespace rocksdb

utilities/ttl/db_ttl.cc

@@ -254,6 +254,10 @@ int DBWithTTL::Level0StopWriteTrigger() {
   return db_->Level0StopWriteTrigger();
 }
 
+Env* DBWithTTL::GetEnv() const {
+  return db_->GetEnv();
+}
+
 Status DBWithTTL::Flush(const FlushOptions& fopts) {
   return db_->Flush(fopts);
 }

utilities/ttl/db_ttl.h

@@ -67,6 +67,8 @@ class DBWithTTL : public StackableDB {
 
   virtual int Level0StopWriteTrigger();
 
+  virtual Env* GetEnv() const;
+
   virtual Status Flush(const FlushOptions& fopts);
 
   virtual Status DisableFileDeletions();
@@ -88,7 +90,7 @@ class DBWithTTL : public StackableDB {
   // Simulate a db crash, no elegant closing of database.
   void TEST_Destroy_DBWithTtl();
 
-  virtual DB* GetRawDB() {
+  virtual DB* GetBaseDB() {
     return db_;
   }