From 1da1e98a836fe47ccf7fc1cbc3224040db5c7624 Mon Sep 17 00:00:00 2001
From: Soumya Koduri <skoduri@redhat.com>
Date: Sun, 11 Jul 2021 19:23:32 +0530
Subject: [PATCH] rgw/dbstore: Add DBStore base class def to namespace
 rgw::store

Signed-off-by: Soumya Koduri <skoduri@redhat.com>
---
 src/rgw/rgw_sal.cc                           |   8 +-
 src/rgw/rgw_sal_dbstore.cc                   | 138 +++++++++----------
 src/rgw/rgw_sal_dbstore.h                    |  62 ++++-----
 src/rgw/store/dbstore/common/dbstore.cc      |  69 +++++-----
 src/rgw/store/dbstore/common/dbstore.h       |  18 ++-
 src/rgw/store/dbstore/dbstore_main.cc        |  17 ++-
 src/rgw/store/dbstore/dbstore_mgr.cc         |  40 +++---
 src/rgw/store/dbstore/dbstore_mgr.h          |  19 +--
 src/rgw/store/dbstore/sqlite/sqliteDB.cc     |  45 ------
 src/rgw/store/dbstore/sqlite/sqliteDB.h      |   7 +-
 src/rgw/store/dbstore/tests/dbstore_tests.cc |  67 ++++-----
 11 files changed, 231 insertions(+), 259 deletions(-)

diff --git a/src/rgw/rgw_sal.cc b/src/rgw/rgw_sal.cc
index bdd2adc3be5..5917280bca9 100644
--- a/src/rgw/rgw_sal.cc
+++ b/src/rgw/rgw_sal.cc
@@ -34,7 +34,7 @@
 extern "C" {
 extern rgw::sal::Store* newStore(void);
 #ifdef WITH_RADOSGW_DBSTORE
-extern rgw::sal::Store* newRGWDBStore(CephContext *cct);
+extern rgw::sal::Store* newDBStore(CephContext *cct);
 #endif
 }
 
@@ -78,10 +78,10 @@ rgw::sal::Store* StoreManager::init_storage_provider(const DoutPrefixProvider* d
 
   if (svc.compare("dbstore") == 0) {
 #ifdef WITH_RADOSGW_DBSTORE
-    rgw::sal::Store* store = newRGWDBStore(cct);
+    rgw::sal::Store* store = newDBStore(cct);
 
     /* Initialize the dbstore with cct & dpp */
-    DBStore *db = static_cast<rgw::sal::RGWDBStore *>(store)->getDBStore();
+    DB *db = static_cast<rgw::sal::DBStore *>(store)->getDB();
     db->set_context(cct);
     return store;
 #endif
@@ -113,7 +113,7 @@ rgw::sal::Store* StoreManager::init_raw_storage_provider(const DoutPrefixProvide
 
   if (svc.compare("dbstore") == 0) {
 #ifdef WITH_RADOSGW_DBSTORE
-    store = newRGWDBStore(cct);
+    store = newDBStore(cct);
 #else
     store = nullptr;
 #endif
diff --git a/src/rgw/rgw_sal_dbstore.cc b/src/rgw/rgw_sal_dbstore.cc
index fb2e668c0ab..f6a35068d8b 100644
--- a/src/rgw/rgw_sal_dbstore.cc
+++ b/src/rgw/rgw_sal_dbstore.cc
@@ -39,7 +39,7 @@ namespace rgw::sal {
     int ret;
 
     buckets.clear();
-    ret = store->getDBStore()->list_buckets(dpp, info.user_id, marker, end_marker, max,
+    ret = store->getDB()->list_buckets(dpp, info.user_id, marker, end_marker, max,
         need_stats, &ulist, &is_truncated);
     if (ret < 0)
       return ret;
@@ -61,7 +61,7 @@ namespace rgw::sal {
   int DBUser::read_attrs(const DoutPrefixProvider* dpp, optional_yield y)
   {
     int ret;
-    ret = store->getDBStore()->get_user(dpp, string("user_id"), "", info, &attrs,
+    ret = store->getDB()->get_user(dpp, string("user_id"), "", info, &attrs,
         &objv_tracker);
     return ret;
   }
@@ -101,7 +101,7 @@ namespace rgw::sal {
   {
     int ret = 0;
 
-    ret = store->getDBStore()->get_user(dpp, string("user_id"), "", info, &attrs,
+    ret = store->getDB()->get_user(dpp, string("user_id"), "", info, &attrs,
         &objv_tracker);
 
     return ret;
@@ -111,7 +111,7 @@ namespace rgw::sal {
   {
     int ret = 0;
 
-    ret = store->getDBStore()->store_user(dpp, info, exclusive, &attrs, &objv_tracker, old_info);
+    ret = store->getDB()->store_user(dpp, info, exclusive, &attrs, &objv_tracker, old_info);
 
     return ret;
   }
@@ -120,7 +120,7 @@ namespace rgw::sal {
   {
     int ret = 0;
 
-    ret = store->getDBStore()->remove_user(dpp, info, &objv_tracker);
+    ret = store->getDB()->remove_user(dpp, info, &objv_tracker);
 
     return ret;
   }
@@ -140,7 +140,7 @@ namespace rgw::sal {
 
     /* XXX: handle delete_children */
 
-    ret = store->getDBStore()->remove_bucket(dpp, info);
+    ret = store->getDB()->remove_bucket(dpp, info);
 
     return ret;
   }
@@ -149,7 +149,7 @@ namespace rgw::sal {
   {
     int ret = 0;
 
-    ret = store->getDBStore()->get_bucket_info(dpp, string("name"), "", info, &attrs,
+    ret = store->getDB()->get_bucket_info(dpp, string("name"), "", info, &attrs,
         &mtime, &bucket_version);
 
     return ret;
@@ -193,7 +193,7 @@ namespace rgw::sal {
   {
     int ret;
 
-    ret = store->getDBStore()->update_bucket(dpp, "owner", info, false, &(new_user->get_id()), nullptr, nullptr, nullptr);
+    ret = store->getDB()->update_bucket(dpp, "owner", info, false, &(new_user->get_id()), nullptr, nullptr, nullptr);
 
     /* XXX: Update policies of all the bucket->objects with new user */
     return ret;
@@ -203,7 +203,7 @@ namespace rgw::sal {
   {
     int ret;
 
-    ret = store->getDBStore()->update_bucket(dpp, "info", info, exclusive, nullptr, nullptr, &_mtime, &info.objv_tracker);
+    ret = store->getDB()->update_bucket(dpp, "info", info, exclusive, nullptr, nullptr, &_mtime, &info.objv_tracker);
 
     return ret;
 
@@ -214,7 +214,7 @@ namespace rgw::sal {
     /* XXX: same as DBBUcket::remove_bucket() but should return error if there are objects
      * in that bucket. */
 
-    int ret = store->getDBStore()->remove_bucket(dpp, info);
+    int ret = store->getDB()->remove_bucket(dpp, info);
 
     return ret;
   }
@@ -244,7 +244,7 @@ namespace rgw::sal {
 
     /* XXX: handle has_instance_obj like in set_bucket_instance_attrs() */
 
-    ret = store->getDBStore()->update_bucket(dpp, "attrs", info, false, nullptr, &attrs, nullptr, &get_info().objv_tracker);
+    ret = store->getDB()->update_bucket(dpp, "attrs", info, false, nullptr, &attrs, nullptr, &get_info().objv_tracker);
 
     return ret;
   }
@@ -253,7 +253,7 @@ namespace rgw::sal {
   {
     int ret = 0;
 
-    ret = store->getDBStore()->get_bucket_info(dpp, string("name"), "", info, &attrs,
+    ret = store->getDB()->get_bucket_info(dpp, string("name"), "", info, &attrs,
         pmtime, &bucket_version);
 
     return ret;
@@ -319,7 +319,7 @@ namespace rgw::sal {
     Attrs attrs = get_attrs();
     attrs[RGW_ATTR_ACL] = aclbl;
 
-    ret = store->getDBStore()->update_bucket(dpp, "attrs", info, false, &(acl.get_owner().get_id()), &attrs, nullptr, nullptr);
+    ret = store->getDB()->update_bucket(dpp, "attrs", info, false, &(acl.get_owner().get_id()), &attrs, nullptr, nullptr);
 
     return ret;
   }
@@ -335,7 +335,7 @@ namespace rgw::sal {
     return 0;
   }
 
-  void RGWDBStore::finalize(void)
+  void DBStore::finalize(void)
   {
     if (dbsm)
       dbsm->destroyAllHandles();
@@ -393,13 +393,13 @@ namespace rgw::sal {
     return current_period->get_id();
   }
 
-  std::unique_ptr<LuaScriptManager> RGWDBStore::get_lua_script_manager()
+  std::unique_ptr<LuaScriptManager> DBStore::get_lua_script_manager()
   {
     return std::unique_ptr<LuaScriptManager>(new DBLuaScriptManager(this));
   }
 
 
-  std::unique_ptr<RGWRole> RGWDBStore::get_role(std::string name,
+  std::unique_ptr<RGWRole> DBStore::get_role(std::string name,
       std::string tenant,
       std::string path,
       std::string trust_policy,
@@ -409,13 +409,13 @@ namespace rgw::sal {
     return std::unique_ptr<RGWRole>(p);
   }
 
-  std::unique_ptr<RGWRole> RGWDBStore::get_role(std::string id)
+  std::unique_ptr<RGWRole> DBStore::get_role(std::string id)
   {
     RGWRole* p = nullptr;
     return std::unique_ptr<RGWRole>(p);
   }
 
-  int RGWDBStore::get_roles(const DoutPrefixProvider *dpp,
+  int DBStore::get_roles(const DoutPrefixProvider *dpp,
       optional_yield y,
       const std::string& path_prefix,
       const std::string& tenant,
@@ -424,32 +424,32 @@ namespace rgw::sal {
     return 0;
   }
 
-  std::unique_ptr<RGWOIDCProvider> RGWDBStore::get_oidc_provider()
+  std::unique_ptr<RGWOIDCProvider> DBStore::get_oidc_provider()
   {
     RGWOIDCProvider* p = nullptr;
     return std::unique_ptr<RGWOIDCProvider>(p);
   }
 
-  int RGWDBStore::get_oidc_providers(const DoutPrefixProvider *dpp,
+  int DBStore::get_oidc_providers(const DoutPrefixProvider *dpp,
       const std::string& tenant,
       vector<std::unique_ptr<RGWOIDCProvider>>& providers)
   {
     return 0;
   }
 
-  std::unique_ptr<User> RGWDBStore::get_user(const rgw_user &u)
+  std::unique_ptr<User> DBStore::get_user(const rgw_user &u)
   {
     return std::unique_ptr<User>(new DBUser(this, u));
   }
 
-  int RGWDBStore::get_user_by_access_key(const DoutPrefixProvider *dpp, const std::string& key, optional_yield y, std::unique_ptr<User>* user)
+  int DBStore::get_user_by_access_key(const DoutPrefixProvider *dpp, const std::string& key, optional_yield y, std::unique_ptr<User>* user)
   {
     RGWUserInfo uinfo;
     User *u;
     int ret = 0;
     RGWObjVersionTracker objv_tracker;
 
-    ret = getDBStore()->get_user(dpp, string("access_key"), key, uinfo, nullptr,
+    ret = getDB()->get_user(dpp, string("access_key"), key, uinfo, nullptr,
         &objv_tracker);
 
     if (ret < 0)
@@ -466,14 +466,14 @@ namespace rgw::sal {
     return 0;
   }
 
-  int RGWDBStore::get_user_by_email(const DoutPrefixProvider *dpp, const std::string& email, optional_yield y, std::unique_ptr<User>* user)
+  int DBStore::get_user_by_email(const DoutPrefixProvider *dpp, const std::string& email, optional_yield y, std::unique_ptr<User>* user)
   {
     RGWUserInfo uinfo;
     User *u;
     int ret = 0;
     RGWObjVersionTracker objv_tracker;
 
-    ret = getDBStore()->get_user(dpp, string("email"), email, uinfo, nullptr,
+    ret = getDB()->get_user(dpp, string("email"), email, uinfo, nullptr,
         &objv_tracker);
 
     if (ret < 0)
@@ -490,19 +490,19 @@ namespace rgw::sal {
     return ret;
   }
 
-  int RGWDBStore::get_user_by_swift(const DoutPrefixProvider *dpp, const std::string& user_str, optional_yield y, std::unique_ptr<User>* user)
+  int DBStore::get_user_by_swift(const DoutPrefixProvider *dpp, const std::string& user_str, optional_yield y, std::unique_ptr<User>* user)
   {
     /* Swift keys and subusers are not supported for now */
     return 0;
   }
 
-  std::unique_ptr<Object> RGWDBStore::get_object(const rgw_obj_key& k)
+  std::unique_ptr<Object> DBStore::get_object(const rgw_obj_key& k)
   {
     return NULL;
   }
 
 
-  int RGWDBStore::get_bucket(const DoutPrefixProvider *dpp, User* u, const rgw_bucket& b, std::unique_ptr<Bucket>* bucket, optional_yield y)
+  int DBStore::get_bucket(const DoutPrefixProvider *dpp, User* u, const rgw_bucket& b, std::unique_ptr<Bucket>* bucket, optional_yield y)
   {
     int ret;
     Bucket* bp;
@@ -518,7 +518,7 @@ namespace rgw::sal {
     return 0;
   }
 
-  int RGWDBStore::get_bucket(User* u, const RGWBucketInfo& i, std::unique_ptr<Bucket>* bucket)
+  int DBStore::get_bucket(User* u, const RGWBucketInfo& i, std::unique_ptr<Bucket>* bucket)
   {
     Bucket* bp;
 
@@ -529,7 +529,7 @@ namespace rgw::sal {
     return 0;
   }
 
-  int RGWDBStore::get_bucket(const DoutPrefixProvider *dpp, User* u, const std::string& tenant, const std::string& name, std::unique_ptr<Bucket>* bucket, optional_yield y)
+  int DBStore::get_bucket(const DoutPrefixProvider *dpp, User* u, const std::string& tenant, const std::string& name, std::unique_ptr<Bucket>* bucket, optional_yield y)
   {
     rgw_bucket b;
 
@@ -539,7 +539,7 @@ namespace rgw::sal {
     return get_bucket(dpp, u, b, bucket, y);
   }
 
-  int RGWDBStore::create_bucket(const DoutPrefixProvider *dpp,
+  int DBStore::create_bucket(const DoutPrefixProvider *dpp,
       User* u, const rgw_bucket& b,
       const string& zonegroup_id,
       rgw_placement_rule& placement_rule,
@@ -618,7 +618,7 @@ namespace rgw::sal {
     } else {
 
       /* XXX: We may not need to send all these params. Cleanup the unused ones */
-      ret = getDBStore()->create_bucket(dpp, u->get_info(), bucket->get_key(),
+      ret = getDB()->create_bucket(dpp, u->get_info(), bucket->get_key(),
           zid, placement_rule, swift_ver_location, pquota_info,
           attrs, info, pobjv, &ep_objv, creation_time,
           pmaster_bucket, pmaster_num_shards, y, exclusive);
@@ -638,12 +638,12 @@ namespace rgw::sal {
     return ret;
   }
 
-  bool RGWDBStore::is_meta_master()
+  bool DBStore::is_meta_master()
   {
     return true;
   }
 
-  int RGWDBStore::forward_request_to_master(const DoutPrefixProvider *dpp, User* user, obj_version *objv,
+  int DBStore::forward_request_to_master(const DoutPrefixProvider *dpp, User* user, obj_version *objv,
       bufferlist& in_data,
       JSONParser *jp, req_info& info,
       optional_yield y)
@@ -651,98 +651,98 @@ namespace rgw::sal {
     return 0;
   }
 
-  int RGWDBStore::defer_gc(const DoutPrefixProvider *dpp, RGWObjectCtx *rctx, Bucket* bucket, Object* obj, optional_yield y)
+  int DBStore::defer_gc(const DoutPrefixProvider *dpp, RGWObjectCtx *rctx, Bucket* bucket, Object* obj, optional_yield y)
   {
     return 0;
   }
 
-  std::string RGWDBStore::zone_unique_id(uint64_t unique_num)
+  std::string DBStore::zone_unique_id(uint64_t unique_num)
   {
     return "";
   }
 
-  std::string RGWDBStore::zone_unique_trans_id(const uint64_t unique_num)
+  std::string DBStore::zone_unique_trans_id(const uint64_t unique_num)
   {
     return "";
   }
 
-  int RGWDBStore::cluster_stat(RGWClusterStat& stats)
+  int DBStore::cluster_stat(RGWClusterStat& stats)
   {
     return 0;
   }
 
-  std::unique_ptr<Lifecycle> RGWDBStore::get_lifecycle(void)
+  std::unique_ptr<Lifecycle> DBStore::get_lifecycle(void)
   {
     return 0;
   }
 
-  std::unique_ptr<Completions> RGWDBStore::get_completions(void)
+  std::unique_ptr<Completions> DBStore::get_completions(void)
   {
     return 0;
   }
 
-  std::unique_ptr<Notification> RGWDBStore::get_notification(rgw::sal::Object* obj,
+  std::unique_ptr<Notification> DBStore::get_notification(rgw::sal::Object* obj,
       struct req_state* s,
       rgw::notify::EventType event_type, const std::string* object_name)
   {
     return 0;
   }
 
-  std::unique_ptr<GCChain> RGWDBStore::get_gc_chain(rgw::sal::Object* obj)
+  std::unique_ptr<GCChain> DBStore::get_gc_chain(rgw::sal::Object* obj)
   {
     return 0;
   }
 
-  std::unique_ptr<Writer> RGWDBStore::get_writer(Aio *aio, rgw::sal::Bucket* bucket,
+  std::unique_ptr<Writer> DBStore::get_writer(Aio *aio, rgw::sal::Bucket* bucket,
       RGWObjectCtx& obj_ctx, std::unique_ptr<rgw::sal::Object> _head_obj,
       const DoutPrefixProvider *dpp, optional_yield y)
   {
     return 0;
   }
 
-  int RGWDBStore::delete_raw_obj(const DoutPrefixProvider *dpp, const rgw_raw_obj& obj)
+  int DBStore::delete_raw_obj(const DoutPrefixProvider *dpp, const rgw_raw_obj& obj)
   {
     return 0;
   }
 
-  int RGWDBStore::delete_raw_obj_aio(const DoutPrefixProvider *dpp, const rgw_raw_obj& obj, Completions* aio)
+  int DBStore::delete_raw_obj_aio(const DoutPrefixProvider *dpp, const rgw_raw_obj& obj, Completions* aio)
   {
     return 0;
   }
 
-  void RGWDBStore::get_raw_obj(const rgw_placement_rule& placement_rule, const rgw_obj& obj, rgw_raw_obj* raw_obj)
+  void DBStore::get_raw_obj(const rgw_placement_rule& placement_rule, const rgw_obj& obj, rgw_raw_obj* raw_obj)
   {
     return;
   }
 
-  int RGWDBStore::get_raw_chunk_size(const DoutPrefixProvider *dpp, const rgw_raw_obj& obj, uint64_t* chunk_size)
+  int DBStore::get_raw_chunk_size(const DoutPrefixProvider *dpp, const rgw_raw_obj& obj, uint64_t* chunk_size)
   {
     return 0;
   }
 
-  int RGWDBStore::log_usage(const DoutPrefixProvider *dpp, map<rgw_user_bucket, RGWUsageBatch>& usage_info)
+  int DBStore::log_usage(const DoutPrefixProvider *dpp, map<rgw_user_bucket, RGWUsageBatch>& usage_info)
   {
     return 0;
   }
 
-  int RGWDBStore::log_op(const DoutPrefixProvider *dpp, string& oid, bufferlist& bl)
+  int DBStore::log_op(const DoutPrefixProvider *dpp, string& oid, bufferlist& bl)
   {
     return 0;
   }
 
-  int RGWDBStore::register_to_service_map(const DoutPrefixProvider *dpp, const string& daemon_type,
+  int DBStore::register_to_service_map(const DoutPrefixProvider *dpp, const string& daemon_type,
       const map<string, string>& meta)
   {
     return 0;
   }
 
-  void RGWDBStore::get_quota(RGWQuotaInfo& bucket_quota, RGWQuotaInfo& user_quota)
+  void DBStore::get_quota(RGWQuotaInfo& bucket_quota, RGWQuotaInfo& user_quota)
   {
     // XXX: Not handled for the first pass 
     return;
   }
 
-  int RGWDBStore::set_buckets_enabled(const DoutPrefixProvider *dpp, vector<rgw_bucket>& buckets, bool enabled)
+  int DBStore::set_buckets_enabled(const DoutPrefixProvider *dpp, vector<rgw_bucket>& buckets, bool enabled)
   {
     int ret = 0;
 
@@ -758,7 +758,7 @@ namespace rgw::sal {
 
       RGWBucketInfo info;
       map<string, bufferlist> attrs;
-      int r = getDBStore()->get_bucket_info(dpp, string("name"), "", info, &attrs,
+      int r = getDB()->get_bucket_info(dpp, string("name"), "", info, &attrs,
           nullptr, nullptr);
       if (r < 0) {
         ldpp_dout(dpp, 0) << "NOTICE: get_bucket_info on bucket=" << bucket.name << " returned err=" << r << ", skipping bucket" << dendl;
@@ -771,7 +771,7 @@ namespace rgw::sal {
         info.flags |= BUCKET_SUSPENDED;
       }
 
-      r = getDBStore()->update_bucket(dpp, "info", info, false, nullptr, &attrs, nullptr, &info.objv_tracker);
+      r = getDB()->update_bucket(dpp, "info", info, false, nullptr, &attrs, nullptr, &info.objv_tracker);
       if (r < 0) {
         ldpp_dout(dpp, 0) << "NOTICE: put_bucket_info on bucket=" << bucket.name << " returned err=" << r << ", skipping bucket" << dendl;
         ret = r;
@@ -781,7 +781,7 @@ namespace rgw::sal {
     return ret;
   }
 
-  int RGWDBStore::get_sync_policy_handler(const DoutPrefixProvider *dpp,
+  int DBStore::get_sync_policy_handler(const DoutPrefixProvider *dpp,
       std::optional<rgw_zone_id> zone,
       std::optional<rgw_bucket> bucket,
       RGWBucketSyncPolicyHandlerRef *phandler,
@@ -790,12 +790,12 @@ namespace rgw::sal {
     return 0;
   }
 
-  RGWDataSyncStatusManager* RGWDBStore::get_data_sync_manager(const rgw_zone_id& source_zone)
+  RGWDataSyncStatusManager* DBStore::get_data_sync_manager(const rgw_zone_id& source_zone)
   {
     return 0;
   }
 
-  int RGWDBStore::read_all_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch, 
+  int DBStore::read_all_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch, 
       uint32_t max_entries, bool *is_truncated,
       RGWUsageIter& usage_iter,
       map<rgw_user_bucket, rgw_usage_log_entry>& usage)
@@ -803,37 +803,37 @@ namespace rgw::sal {
     return 0;
   }
 
-  int RGWDBStore::trim_all_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch)
+  int DBStore::trim_all_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch)
   {
     return 0;
   }
 
-  int RGWDBStore::get_config_key_val(string name, bufferlist *bl)
+  int DBStore::get_config_key_val(string name, bufferlist *bl)
   {
     return 0;
   }
 
-  int RGWDBStore::meta_list_keys_init(const DoutPrefixProvider *dpp, const string& section, const string& marker, void** phandle)
+  int DBStore::meta_list_keys_init(const DoutPrefixProvider *dpp, const string& section, const string& marker, void** phandle)
   {
     return 0;
   }
 
-  int RGWDBStore::meta_list_keys_next(const DoutPrefixProvider *dpp, void* handle, int max, list<string>& keys, bool* truncated)
+  int DBStore::meta_list_keys_next(const DoutPrefixProvider *dpp, void* handle, int max, list<string>& keys, bool* truncated)
   {
     return 0;
   }
 
-  void RGWDBStore::meta_list_keys_complete(void* handle)
+  void DBStore::meta_list_keys_complete(void* handle)
   {
     return;
   }
 
-  std::string RGWDBStore::meta_get_marker(void* handle)
+  std::string DBStore::meta_get_marker(void* handle)
   {
     return "";
   }
 
-  int RGWDBStore::meta_remove(const DoutPrefixProvider *dpp, string& metadata_key, optional_yield y)
+  int DBStore::meta_remove(const DoutPrefixProvider *dpp, string& metadata_key, optional_yield y)
   {
     return 0;
   }
@@ -842,9 +842,9 @@ namespace rgw::sal {
 
 extern "C" {
 
-  void *newRGWDBStore(CephContext *cct)
+  void *newDBStore(CephContext *cct)
   {
-    rgw::sal::RGWDBStore *store = new rgw::sal::RGWDBStore();
+    rgw::sal::DBStore *store = new rgw::sal::DBStore();
     if (store) {
       DBStoreManager *dbsm = new DBStoreManager(cct);
 
@@ -852,14 +852,14 @@ extern "C" {
         delete store; store = nullptr;
       }
 
-      DBStore *dbstore = dbsm->getDBStore();
-      if (!dbstore ) {
+      DB *db = dbsm->getDB();
+      if (!db) {
         delete dbsm;
         delete store; store = nullptr;
       }
 
       store->setDBStoreManager(dbsm);
-      store->setDBStore(dbstore);
+      store->setDB(db);
     }
 
     return store;
diff --git a/src/rgw/rgw_sal_dbstore.h b/src/rgw/rgw_sal_dbstore.h
index 8a68a4b26a5..6ab0af0b72a 100644
--- a/src/rgw/rgw_sal_dbstore.h
+++ b/src/rgw/rgw_sal_dbstore.h
@@ -24,16 +24,16 @@
 
 namespace rgw { namespace sal {
 
-  class RGWDBStore;
+  class DBStore;
 
   class DBUser : public User {
     private:
-      RGWDBStore *store;
+      DBStore *store;
 
     public:
-      DBUser(RGWDBStore *_st, const rgw_user& _u) : User(_u), store(_st) { }
-      DBUser(RGWDBStore *_st, const RGWUserInfo& _i) : User(_i), store(_st) { }
-      DBUser(RGWDBStore *_st) : store(_st) { }
+      DBUser(DBStore *_st, const rgw_user& _u) : User(_u), store(_st) { }
+      DBUser(DBStore *_st, const RGWUserInfo& _i) : User(_i), store(_st) { }
+      DBUser(DBStore *_st) : store(_st) { }
       DBUser(DBUser& _o) = default;
       DBUser() {}
 
@@ -65,52 +65,52 @@ namespace rgw { namespace sal {
 
   class DBBucket : public Bucket {
     private:
-      RGWDBStore *store;
+      DBStore *store;
       RGWAccessControlPolicy acls;
 
     public:
-      DBBucket(RGWDBStore *_st)
+      DBBucket(DBStore *_st)
         : store(_st),
         acls() {
         }
 
-      DBBucket(RGWDBStore *_st, User* _u)
+      DBBucket(DBStore *_st, User* _u)
         : Bucket(_u),
         store(_st),
         acls() {
         }
 
-      DBBucket(RGWDBStore *_st, const rgw_bucket& _b)
+      DBBucket(DBStore *_st, const rgw_bucket& _b)
         : Bucket(_b),
         store(_st),
         acls() {
         }
 
-      DBBucket(RGWDBStore *_st, const RGWBucketEnt& _e)
+      DBBucket(DBStore *_st, const RGWBucketEnt& _e)
         : Bucket(_e),
         store(_st),
         acls() {
         }
 
-      DBBucket(RGWDBStore *_st, const RGWBucketInfo& _i)
+      DBBucket(DBStore *_st, const RGWBucketInfo& _i)
         : Bucket(_i),
         store(_st),
         acls() {
         }
 
-      DBBucket(RGWDBStore *_st, const rgw_bucket& _b, User* _u)
+      DBBucket(DBStore *_st, const rgw_bucket& _b, User* _u)
         : Bucket(_b, _u),
         store(_st),
         acls() {
         }
 
-      DBBucket(RGWDBStore *_st, const RGWBucketEnt& _e, User* _u)
+      DBBucket(DBStore *_st, const RGWBucketEnt& _e, User* _u)
         : Bucket(_e, _u),
         store(_st),
         acls() {
         }
 
-      DBBucket(RGWDBStore *_st, const RGWBucketInfo& _i, User* _u)
+      DBBucket(DBStore *_st, const RGWBucketInfo& _i, User* _u)
         : Bucket(_i, _u),
         store(_st),
         acls() {
@@ -156,12 +156,12 @@ namespace rgw { namespace sal {
         return std::make_unique<DBBucket>(*this);
       }
 
-      friend class RGWDBStore;
+      friend class DBStore;
   };
 
   class DBZone : public Zone {
     protected:
-      RGWDBStore* store;
+      DBStore* store;
       RGWRealm *realm{nullptr};
       RGWZoneGroup *zonegroup{nullptr};
       RGWZone *zone_public_config{nullptr}; /* external zone params, e.g., entrypoints, log flags, etc. */  
@@ -170,7 +170,7 @@ namespace rgw { namespace sal {
       rgw_zone_id cur_zone_id;
 
     public:
-      DBZone(RGWDBStore* _store) : store(_store) {
+      DBZone(DBStore* _store) : store(_store) {
         realm = new RGWRealm();
         zonegroup = new RGWZoneGroup();
         zone_public_config = new RGWZone();
@@ -200,10 +200,10 @@ namespace rgw { namespace sal {
   };
 
   class DBLuaScriptManager : public LuaScriptManager {
-    RGWDBStore* store;
+    DBStore* store;
 
     public:
-    DBLuaScriptManager(RGWDBStore* _s) : store(_s)
+    DBLuaScriptManager(DBStore* _s) : store(_s)
     {
     }
     virtual ~DBLuaScriptManager() = default;
@@ -214,9 +214,9 @@ namespace rgw { namespace sal {
   };
 
   class DBOIDCProvider : public RGWOIDCProvider {
-    RGWDBStore* store;
+    DBStore* store;
     public:
-    DBOIDCProvider(RGWDBStore* _store) : store(_store) {}
+    DBOIDCProvider(DBStore* _store) : store(_store) {}
     ~DBOIDCProvider() = default;
 
     virtual int store_url(const DoutPrefixProvider *dpp, const std::string& url, bool exclusive, optional_yield y) override { return 0; }
@@ -231,23 +231,23 @@ namespace rgw { namespace sal {
     }
   };
 
-  class RGWDBStore : public Store {
+  class DBStore : public Store {
     private:
       /* DBStoreManager is used in case multiple
        * connections are needed one for each tenant.
        */
       DBStoreManager *dbsm;
-      /* default dbstore (single connection). If needed
+      /* default db (single connection). If needed
        * multiple db handles (for eg., one for each tenant),
-       * use dbsm->getDBStore(tenant) */
-      DBStore *dbstore;
+       * use dbsm->getDB(tenant) */
+      DB *db;
       string luarocks_path;
       DBZone zone;
       RGWSyncModuleInstanceRef sync_module;
 
     public:
-      RGWDBStore(): dbsm(nullptr), zone(this) {}
-      ~RGWDBStore() { delete dbsm; }
+      DBStore(): dbsm(nullptr), zone(this) {}
+      ~DBStore() { delete dbsm; }
 
       virtual std::unique_ptr<User> get_user(const rgw_user& u) override;
       virtual int get_user_by_access_key(const DoutPrefixProvider *dpp, const std::string& key, optional_yield y, std::unique_ptr<User>* user) override;
@@ -350,7 +350,7 @@ namespace rgw { namespace sal {
       virtual void finalize(void) override;
 
       virtual CephContext *ctx(void) override {
-        return dbstore->ctx();
+        return db->ctx();
       }
 
       virtual const std::string& get_luarocks_path() const override {
@@ -365,10 +365,10 @@ namespace rgw { namespace sal {
       void setDBStoreManager(DBStoreManager *stm) { dbsm = stm; }
       DBStoreManager *getDBStoreManager(void) { return dbsm; }
 
-      void setDBStore(DBStore * st) { dbstore = st; }
-      DBStore *getDBStore(void) { return dbstore; }
+      void setDB(DB * st) { db = st; }
+      DB *getDB(void) { return db; }
 
-      DBStore *getDBStore(string tenant) { return dbsm->getDBStore(tenant, false); }
+      DB *getDB(string tenant) { return dbsm->getDB(tenant, false); }
   };
 
 } } // namespace rgw::sal
diff --git a/src/rgw/store/dbstore/common/dbstore.cc b/src/rgw/store/dbstore/common/dbstore.cc
index 230c9ca75be..ae2fcbdf9c1 100644
--- a/src/rgw/store/dbstore/common/dbstore.cc
+++ b/src/rgw/store/dbstore/common/dbstore.cc
@@ -5,13 +5,15 @@
 
 using namespace std;
 
-map<string, class ObjectOp*> DBStore::objectmap = {};
+namespace rgw { namespace store {
 
-map<string, class ObjectOp*> DBStore::getObjectMap() {
-  return DBStore::objectmap;
+map<string, class ObjectOp*> DB::objectmap = {};
+
+map<string, class ObjectOp*> DB::getObjectMap() {
+  return DB::objectmap;
 }
 
-int DBStore::Initialize(string logfile, int loglevel)
+int DB::Initialize(string logfile, int loglevel)
 {
   int ret = -1;
   const DoutPrefixProvider *dpp = get_def_dpp();
@@ -56,13 +58,13 @@ int DBStore::Initialize(string logfile, int loglevel)
     return ret;
   }
 
-  ldpp_dout(dpp, 0) << "DBStore successfully initialized - name:" \
+  ldpp_dout(dpp, 0) << "DB successfully initialized - name:" \
     << db_name << "" << dendl;
 
   return ret;
 }
 
-int DBStore::Destroy(const DoutPrefixProvider *dpp)
+int DB::Destroy(const DoutPrefixProvider *dpp)
 {
   if (!db)
     return 0;
@@ -73,13 +75,13 @@ int DBStore::Destroy(const DoutPrefixProvider *dpp)
 
   FreeDBOps(dpp);
 
-  ldpp_dout(dpp, 20)<<"DBStore successfully destroyed - name:" \
+  ldpp_dout(dpp, 20)<<"DB successfully destroyed - name:" \
     <<db_name << dendl;
 
   return 0;
 }
 
-int DBStore::LockInit(const DoutPrefixProvider *dpp) {
+int DB::LockInit(const DoutPrefixProvider *dpp) {
   int ret;
 
   ret = pthread_mutex_init(&mutex, NULL);
@@ -90,7 +92,7 @@ int DBStore::LockInit(const DoutPrefixProvider *dpp) {
   return ret;
 }
 
-int DBStore::LockDestroy(const DoutPrefixProvider *dpp) {
+int DB::LockDestroy(const DoutPrefixProvider *dpp) {
   int ret;
 
   ret = pthread_mutex_destroy(&mutex);
@@ -101,7 +103,7 @@ int DBStore::LockDestroy(const DoutPrefixProvider *dpp) {
   return ret;
 }
 
-int DBStore::Lock(const DoutPrefixProvider *dpp) {
+int DB::Lock(const DoutPrefixProvider *dpp) {
   int ret;
 
   ret = pthread_mutex_lock(&mutex);
@@ -112,7 +114,7 @@ int DBStore::Lock(const DoutPrefixProvider *dpp) {
   return ret;
 }
 
-int DBStore::Unlock(const DoutPrefixProvider *dpp) {
+int DB::Unlock(const DoutPrefixProvider *dpp) {
   int ret;
 
   ret = pthread_mutex_unlock(&mutex);
@@ -123,7 +125,7 @@ int DBStore::Unlock(const DoutPrefixProvider *dpp) {
   return ret;
 }
 
-DBOp *DBStore::getDBOp(const DoutPrefixProvider *dpp, string Op, struct DBOpParams *params)
+DBOp *DB::getDBOp(const DoutPrefixProvider *dpp, string Op, struct DBOpParams *params)
 {
   if (!Op.compare("InsertUser"))
     return dbops.InsertUser;
@@ -146,9 +148,9 @@ DBOp *DBStore::getDBOp(const DoutPrefixProvider *dpp, string Op, struct DBOpPara
   map<string, class ObjectOp*>::iterator iter;
   class ObjectOp* Ob;
 
-  iter = DBStore::objectmap.find(params->op.bucket.info.bucket.name);
+  iter = DB::objectmap.find(params->op.bucket.info.bucket.name);
 
-  if (iter == DBStore::objectmap.end()) {
+  if (iter == DB::objectmap.end()) {
     ldpp_dout(dpp, 30)<<"No objectmap found for bucket: " \
       <<params->op.bucket.info.bucket.name << dendl;
     /* not found */
@@ -173,14 +175,14 @@ DBOp *DBStore::getDBOp(const DoutPrefixProvider *dpp, string Op, struct DBOpPara
   return NULL;
 }
 
-int DBStore::objectmapInsert(const DoutPrefixProvider *dpp, string bucket, void *ptr)
+int DB::objectmapInsert(const DoutPrefixProvider *dpp, string bucket, void *ptr)
 {
   map<string, class ObjectOp*>::iterator iter;
   class ObjectOp *Ob;
 
-  iter = DBStore::objectmap.find(bucket);
+  iter = DB::objectmap.find(bucket);
 
-  if (iter != DBStore::objectmap.end()) {
+  if (iter != DB::objectmap.end()) {
     // entry already exists
     // return success or replace it or
     // return error ?
@@ -193,19 +195,19 @@ int DBStore::objectmapInsert(const DoutPrefixProvider *dpp, string bucket, void
   Ob = (class ObjectOp*) ptr;
   Ob->InitializeObjectOps(dpp);
 
-  DBStore::objectmap.insert(pair<string, class ObjectOp*>(bucket, Ob));
+  DB::objectmap.insert(pair<string, class ObjectOp*>(bucket, Ob));
 
   return 0;
 }
 
-int DBStore::objectmapDelete(const DoutPrefixProvider *dpp, string bucket)
+int DB::objectmapDelete(const DoutPrefixProvider *dpp, string bucket)
 {
   map<string, class ObjectOp*>::iterator iter;
   class ObjectOp *Ob;
 
-  iter = DBStore::objectmap.find(bucket);
+  iter = DB::objectmap.find(bucket);
 
-  if (iter == DBStore::objectmap.end()) {
+  if (iter == DB::objectmap.end()) {
     // entry doesn't exist
     // return success or return error ?
     // return success for now
@@ -217,12 +219,12 @@ int DBStore::objectmapDelete(const DoutPrefixProvider *dpp, string bucket)
   Ob = (class ObjectOp*) (iter->second);
   Ob->FreeObjectOps(dpp);
 
-  DBStore::objectmap.erase(iter);
+  DB::objectmap.erase(iter);
 
   return 0;
 }
 
-int DBStore::InitializeParams(const DoutPrefixProvider *dpp, string Op, DBOpParams *params)
+int DB::InitializeParams(const DoutPrefixProvider *dpp, string Op, DBOpParams *params)
 {
   int ret = -1;
 
@@ -240,7 +242,7 @@ out:
   return ret;
 }
 
-int DBStore::ProcessOp(const DoutPrefixProvider *dpp, string Op, struct DBOpParams *params) {
+int DB::ProcessOp(const DoutPrefixProvider *dpp, string Op, struct DBOpParams *params) {
   int ret = -1;
   class DBOp *db_op;
 
@@ -266,7 +268,7 @@ int DBStore::ProcessOp(const DoutPrefixProvider *dpp, string Op, struct DBOpPara
   return ret;
 }
 
-int DBStore::get_user(const DoutPrefixProvider *dpp,
+int DB::get_user(const DoutPrefixProvider *dpp,
     const std::string& query_str, const std::string& query_str_val,
     RGWUserInfo& uinfo, map<string, bufferlist> *pattrs,
     RGWObjVersionTracker *pobjv_tracker) {
@@ -319,7 +321,7 @@ out:
   return ret;
 }
 
-int DBStore::store_user(const DoutPrefixProvider *dpp,
+int DB::store_user(const DoutPrefixProvider *dpp,
     RGWUserInfo& uinfo, bool exclusive, map<string, bufferlist> *pattrs,
     RGWObjVersionTracker *pobjv, RGWUserInfo* pold_info)
 {
@@ -382,7 +384,7 @@ out:
   return ret;
 }
 
-int DBStore::remove_user(const DoutPrefixProvider *dpp,
+int DB::remove_user(const DoutPrefixProvider *dpp,
     RGWUserInfo& uinfo, RGWObjVersionTracker *pobjv)
 {
   DBOpParams params = {};
@@ -419,7 +421,7 @@ out:
   return ret;
 }
 
-int DBStore::get_bucket_info(const DoutPrefixProvider *dpp, const std::string& query_str,
+int DB::get_bucket_info(const DoutPrefixProvider *dpp, const std::string& query_str,
     const std::string& query_str_val,
     RGWBucketInfo& info,
     rgw::sal::Attrs* pattrs, ceph::real_time* pmtime,
@@ -470,7 +472,7 @@ out:
   return ret;
 }
 
-int DBStore::create_bucket(const DoutPrefixProvider *dpp,
+int DB::create_bucket(const DoutPrefixProvider *dpp,
     const RGWUserInfo& owner, rgw_bucket& bucket,
     const string& zonegroup_id,
     const rgw_placement_rule& placement_rule,
@@ -559,7 +561,7 @@ out:
   return ret;
 }
 
-int DBStore::remove_bucket(const DoutPrefixProvider *dpp, const RGWBucketInfo info) {
+int DB::remove_bucket(const DoutPrefixProvider *dpp, const RGWBucketInfo info) {
   int ret = 0;
 
   DBOpParams params = {};
@@ -578,7 +580,7 @@ out:
   return ret;
 }
 
-int DBStore::list_buckets(const DoutPrefixProvider *dpp, const rgw_user& user,
+int DB::list_buckets(const DoutPrefixProvider *dpp, const rgw_user& user,
     const string& marker,
     const string& end_marker,
     uint64_t max,
@@ -621,7 +623,7 @@ out:
   return ret;
 }
 
-int DBStore::update_bucket(const DoutPrefixProvider *dpp, const std::string& query_str,
+int DB::update_bucket(const DoutPrefixProvider *dpp, const std::string& query_str,
     RGWBucketInfo& info,
     bool exclusive,
     const rgw_user* powner_id,
@@ -714,3 +716,6 @@ int DBStore::update_bucket(const DoutPrefixProvider *dpp, const std::string& que
 out:
   return ret;
 }
+
+} } // namespace rgw::store
+
diff --git a/src/rgw/store/dbstore/common/dbstore.h b/src/rgw/store/dbstore/common/dbstore.h
index 3c4d8279190..7b32afcc977 100644
--- a/src/rgw/store/dbstore/common/dbstore.h
+++ b/src/rgw/store/dbstore/common/dbstore.h
@@ -17,6 +17,7 @@
 #include <map>
 #include "dbstore_log.h"
 #include "rgw/rgw_sal.h"
+#include "rgw/rgw_common.h"
 #include "rgw/rgw_bucket.h"
 #include "global/global_context.h"
 #include "global/global_init.h"
@@ -24,7 +25,9 @@
 
 using namespace std;
 
-class DBStore;
+namespace rgw { namespace store {
+
+class DB;
 
 struct DBOpUserInfo {
   RGWUserInfo uinfo = {};
@@ -747,7 +750,7 @@ class DeleteObjectDataOp: public DBOp {
     }
 };
 
-class DBStore {
+class DB {
   private:
     const string db_name;
     const string user_table;
@@ -768,23 +771,23 @@ class DBStore {
     uint64_t max_bucket_id = 0;
 
   public:	
-    DBStore(string db_name, CephContext *_cct) : db_name(db_name),
+    DB(string db_name, CephContext *_cct) : db_name(db_name),
     user_table(db_name+".user.table"),
     bucket_table(db_name+".bucket.table"),
     quota_table(db_name+".quota.table"),
     cct(_cct),
     dp(_cct, dout_subsys, "rgw DBStore backend: ")
   {}
-    /*	DBStore() {}*/
+    /*	DB() {}*/
 
-    DBStore(CephContext *_cct) : db_name("default_db"),
+    DB(CephContext *_cct) : db_name("default_db"),
     user_table("user.table"),
     bucket_table("bucket.table"),
     quota_table("quota.table"),
     cct(_cct),
     dp(_cct, dout_subsys, "rgw DBStore backend: ")
   {}
-    virtual	~DBStore() {}
+    virtual	~DB() {}
 
     const string getDBname() { return db_name + ".db"; }
     const string getUserTable() { return user_table; }
@@ -870,4 +873,7 @@ class DBStore {
         const rgw_user* powner_id, map<std::string, bufferlist>* pattrs,
         ceph::real_time* pmtime, RGWObjVersionTracker* pobjv);
 };
+
+} } // namespace rgw::store
+
 #endif
diff --git a/src/rgw/store/dbstore/dbstore_main.cc b/src/rgw/store/dbstore/dbstore_main.cc
index ad6bab7eecd..0055191908b 100644
--- a/src/rgw/store/dbstore/dbstore_main.cc
+++ b/src/rgw/store/dbstore/dbstore_main.cc
@@ -8,8 +8,11 @@
 #include <dbstore.h>
 #include <dbstore_log.h>
 
+using namespace rgw::store;
+using DB = rgw::store::DB;
+
 struct thr_args {
-  class DBStore *dbs;
+  DB *dbs;
   int thr_id;
 };
 
@@ -17,7 +20,7 @@ void* process(void *arg)
 {
   struct thr_args *t_args = (struct thr_args*)arg;
 
-  class DBStore *db = t_args->dbs;
+  DB *db = t_args->dbs;
   int thr_id = t_args->thr_id;
   int ret = -1;
 
@@ -36,7 +39,7 @@ void* process(void *arg)
   string objectc1 = "rhhi";
   string objectc2 = "cns";
 
-  struct DBOpParams params = {};
+  DBOpParams params = {};
   const DoutPrefixProvider *dpp = db->get_def_dpp();
 
   db->InitializeParams(dpp, "InsertUser", &params);
@@ -58,7 +61,7 @@ void* process(void *arg)
   ret = db->ProcessOp(dpp, "InsertUser", &params);
   cout << "InsertUser return value: " <<  ret << "\n";
 
-  struct DBOpParams params2 = {};
+  DBOpParams params2 = {};
   params.op.user.uinfo.user_id.tenant = "tenant2";
 
   db->InitializeParams(dpp, "GetUser", &params2);
@@ -123,8 +126,8 @@ int main(int argc, char *argv[])
   string logfile = "rgw_dbstore_bin.log";
   int loglevel = 20;
 
-  class DBStoreManager *dbsm;
-  class DBStore *dbs;
+  DBStoreManager *dbsm;
+  DB *dbs;
   int rc = 0, tnum = 0;
   void *res;
 
@@ -143,7 +146,7 @@ int main(int argc, char *argv[])
   }
 
   dbsm = new DBStoreManager(logfile, loglevel);
-  dbs = dbsm->getDBStore(tenant, true);
+  dbs = dbsm->getDB(tenant, true);
 
   cout<<"No. of threads being created = "<<num_thr<<"\n";
 
diff --git a/src/rgw/store/dbstore/dbstore_mgr.cc b/src/rgw/store/dbstore/dbstore_mgr.cc
index f033035611b..2869c542210 100644
--- a/src/rgw/store/dbstore/dbstore_mgr.cc
+++ b/src/rgw/store/dbstore/dbstore_mgr.cc
@@ -7,14 +7,14 @@
  * If not found and 'create' set to true, create one
  * and return
  */
-DBStore* DBStoreManager::getDBStore (string tenant, bool create)
+DB *DBStoreManager::getDB (string tenant, bool create)
 {
-  map<string, DBStore*>::iterator iter;
-  DBStore *dbs = nullptr;
-  pair<map<string, DBStore*>::iterator,bool> ret;
+  map<string, DB*>::iterator iter;
+  DB *dbs = nullptr;
+  pair<map<string, DB*>::iterator,bool> ret;
 
   if (tenant.empty())
-    return default_dbstore;
+    return default_db;
 
   if (DBStoreHandles.empty())
     goto not_found;
@@ -28,30 +28,30 @@ not_found:
   if (!create)
     return NULL;
 
-  dbs = createDBStore(tenant);
+  dbs = createDB(tenant);
 
   return dbs;
 }
 
 /* Create DBStore instance */
-DBStore* DBStoreManager::createDBStore(string tenant) {
-  DBStore *dbs = nullptr;
-  pair<map<string, DBStore*>::iterator,bool> ret;
+DB *DBStoreManager::createDB(string tenant) {
+  DB *dbs = nullptr;
+  pair<map<string, DB*>::iterator,bool> ret;
 
   /* Create the handle */
 #ifdef SQLITE_ENABLED
   dbs = new SQLiteDB(tenant, cct);
 #else
-  dbs = new DBStore(tenant, cct);
+  dbs = new DB(tenant, cct);
 #endif
 
-  /* API is DBStore::Initialize(string logfile, int loglevel);
+  /* API is DB::Initialize(string logfile, int loglevel);
    * If none provided, by default write in to dbstore.log file
    * created in current working directory with loglevel L_EVENT.
    * XXX: need to align these logs to ceph location
    */
   if (dbs->Initialize("", -1) < 0) {
-    cout<<"^^^^^^^^^^^^DB initialization failed for tenant("<<tenant<<")^^^^^^^^^^^^^^^^^^^^^^^^^^ \n";
+    ldout(cct, 0) << "DB initialization failed for tenant("<<tenant<<")" << dendl;
 
     delete dbs;
     return NULL;
@@ -59,7 +59,7 @@ DBStore* DBStoreManager::createDBStore(string tenant) {
 
   /* XXX: Do we need lock to protect this map?
   */
-  ret = DBStoreHandles.insert(pair<string, DBStore*>(tenant, dbs));
+  ret = DBStoreHandles.insert(pair<string, DB*>(tenant, dbs));
 
   /*
    * Its safe to check for already existing entry (just
@@ -75,9 +75,9 @@ DBStore* DBStoreManager::createDBStore(string tenant) {
   return dbs;
 }
 
-void DBStoreManager::deleteDBStore(string tenant) {
-  map<string, DBStore*>::iterator iter;
-  DBStore *dbs = nullptr;
+void DBStoreManager::deleteDB(string tenant) {
+  map<string, DB*>::iterator iter;
+  DB *dbs = nullptr;
 
   if (tenant.empty() || DBStoreHandles.empty())
     return;
@@ -97,17 +97,17 @@ void DBStoreManager::deleteDBStore(string tenant) {
   return;
 }
 
-void DBStoreManager::deleteDBStore(DBStore *dbs) {
+void DBStoreManager::deleteDB(DB *dbs) {
   if (!dbs)
     return;
 
-  (void)deleteDBStore(dbs->getDBname());
+  (void)deleteDB(dbs->getDBname());
 }
 
 
 void DBStoreManager::destroyAllHandles(){
-  map<string, DBStore*>::iterator iter;
-  DBStore *dbs = nullptr;
+  map<string, DB*>::iterator iter;
+  DB *dbs = nullptr;
 
   if (DBStoreHandles.empty())
     return;
diff --git a/src/rgw/store/dbstore/dbstore_mgr.h b/src/rgw/store/dbstore/dbstore_mgr.h
index 9744b4f0239..77037552f6f 100644
--- a/src/rgw/store/dbstore/dbstore_mgr.h
+++ b/src/rgw/store/dbstore/dbstore_mgr.h
@@ -14,23 +14,24 @@
 #include "sqlite/sqliteDB.h"
 
 using namespace std;
+using namespace rgw::store;
+using DB = rgw::store::DB;
 
 /* XXX: Should be a dbstore config option */
 const static string default_tenant = "default_ns";
 
 using namespace std;
-class DBStore;
 
 class DBStoreManager {
 private:
-  map<string, DBStore*> DBStoreHandles;
-  DBStore *default_dbstore = NULL;
+  map<string, DB*> DBStoreHandles;
+  DB *default_db = NULL;
   CephContext *cct;
 
 public:
   DBStoreManager(CephContext *_cct): DBStoreHandles() {
     cct = _cct;
-	default_dbstore = createDBStore(default_tenant);
+	default_db = createDB(default_tenant);
   };
   DBStoreManager(string logfile, int loglevel): DBStoreHandles() {
     /* No ceph context. Create one with log args provided */
@@ -48,10 +49,10 @@ public:
    * 2) Refcount of each DBStore to protect from
    * being deleted while using it.
    */
-  DBStore* getDBStore () { return default_dbstore; };
-  DBStore* getDBStore (string tenant, bool create);
-  DBStore* createDBStore (string tenant);
-  void deleteDBStore (string tenant);
-  void deleteDBStore (DBStore* db);
+  DB* getDB () { return default_db; };
+  DB* getDB (string tenant, bool create);
+  DB* createDB (string tenant);
+  void deleteDB (string tenant);
+  void deleteDB (DB* db);
   void destroyAllHandles();
 };
diff --git a/src/rgw/store/dbstore/sqlite/sqliteDB.cc b/src/rgw/store/dbstore/sqlite/sqliteDB.cc
index 5ed710b1da2..fdd53290ec5 100644
--- a/src/rgw/store/dbstore/sqlite/sqliteDB.cc
+++ b/src/rgw/store/dbstore/sqlite/sqliteDB.cc
@@ -144,7 +144,6 @@ static int list_callback(void *None, int argc, char **argv, char **aname)
   int i;
   for(i=0; i<argc; i++) {
     string arg = argv[i] ? argv[i] : "NULL";
-   // cout<<aname[i]<<" = "<<arg<<"\n";
   }
   return 0;
 }
@@ -216,35 +215,6 @@ static int list_user(const DoutPrefixProvider *dpp, DBOpInfo &op, sqlite3_stmt *
   if (!stmt)
     return -1;
 
-  //cout<<sqlite3_column_text(stmt, 0) << dendl;
-  /* Ensure the column names match with the user table defined in dbstore.h                     
-     UserID TEXT ,		\ - 0
-     Tenant TEXT ,		\ - 1
-     NS TEXT ,		\ - 2
-     DisplayName TEXT , \ - 3
-     UserEmail TEXT ,	\ - 4
-     AccessKeysID TEXT ,	\ - 5
-     AccessKeysSecret TEXT ,	\ - 6
-     AccessKeys BLOB ,	\ - 7
-     SwiftKeys BLOB ,	\ - 8
-     SubUsers BLOB ,		\ - 9
-     Suspended INTEGER ,	\ - 10
-     MaxBuckets INTEGER ,	\ - 11
-     OpMask	INTEGER ,	\ - 12
-     UserCaps BLOB ,		\ - 13
-     Admin	INTEGER ,	\ - 14
-     System INTEGER , 	\ - 15
-     PlacementName TEXT , 	\ - 16
-     PlacementStorageClass TEXT , 	\ - 17
-     PlacementTags BLOB ,	\ - 18
-     BucketQuota BLOB ,	\ - 19
-     TempURLKeys BLOB ,	\ - 20
-     UserQuota BLOB ,	\ - 21
-     TYPE INTEGER ,		\ - 22
-     MfaIDs INTEGER ,	\ - 23
-     AssumedRoleARN TEXT \n);"; - 24
-     */
-
   op.user.uinfo.user_id.tenant = (const char*)sqlite3_column_text(stmt, Tenant);
   op.user.uinfo.user_id.id = (const char*)sqlite3_column_text(stmt, UserID);
   op.user.uinfo.user_id.ns = (const char*)sqlite3_column_text(stmt, NS);
@@ -291,9 +261,6 @@ static int list_bucket(const DoutPrefixProvider *dpp, DBOpInfo &op, sqlite3_stmt
   if (!stmt)
     return -1;
 
- // cout<<sqlite3_column_text(stmt, 0)<<", ";
- // cout<<sqlite3_column_text(stmt, 1) << dendl;
-
   op.bucket.ent.bucket.name = (const char*)sqlite3_column_text(stmt, BucketName);
   op.bucket.ent.bucket.tenant = (const char*)sqlite3_column_text(stmt, Bucket_Tenant);
   op.bucket.ent.bucket.marker = (const char*)sqlite3_column_text(stmt, Marker);
@@ -351,9 +318,6 @@ static int list_object(const DoutPrefixProvider *dpp, DBOpInfo &op, sqlite3_stmt
   if (!stmt)
     return -1;
 
- // cout<<sqlite3_column_text(stmt, 0)<<", ";
- // cout<<sqlite3_column_text(stmt, 1) << dendl;
-
   return 0;
 }
 
@@ -367,15 +331,10 @@ static int get_objectdata(const DoutPrefixProvider *dpp, DBOpInfo &op, sqlite3_s
   blob = sqlite3_column_blob(stmt, 3);
   datalen = sqlite3_column_bytes(stmt, 3);
 
- /* cout<<sqlite3_column_text(stmt, 0)<<", ";
-  cout<<sqlite3_column_text(stmt, 1)<<",";
-  cout<<sqlite3_column_int(stmt, 2)<<",";*/
   char data[datalen+1] = {};
   if (blob)
     strncpy(data, (const char *)blob, datalen);
 
-//  cout<<data<<","<<datalen << dendl;
-
   return 0;
 }
 
@@ -695,7 +654,6 @@ int SQLiteDB::ListAllUsers(const DoutPrefixProvider *dpp, DBOpParams *params)
   string schema;
 
   schema = ListTableSchema(params->user_table);
- // cout<<"########### Listing all Users #############" << dendl;
   ret = exec(dpp, schema.c_str(), &list_callback);
   if (ret)
     ldpp_dout(dpp, 0)<<"GetUsertable failed " << dendl;
@@ -712,7 +670,6 @@ int SQLiteDB::ListAllBuckets(const DoutPrefixProvider *dpp, DBOpParams *params)
 
   schema = ListTableSchema(params->bucket_table);
 
-//  cout<<"########### Listing all Buckets #############" << dendl;
   ret = exec(dpp, schema.c_str(), &list_callback);
   if (ret)
     ldpp_dout(dpp, 0)<<"Listbuckettable failed " << dendl;
@@ -730,8 +687,6 @@ int SQLiteDB::ListAllObjects(const DoutPrefixProvider *dpp, DBOpParams *params)
   map<string, class ObjectOp*> objectmap;
   string bucket;
 
-  //cout<<"########### Listing all Objects #############" << dendl;
-
   objectmap = getObjectMap();
 
   if (objectmap.empty())
diff --git a/src/rgw/store/dbstore/sqlite/sqliteDB.h b/src/rgw/store/dbstore/sqlite/sqliteDB.h
index 27d6523723e..bbab2c3cac4 100644
--- a/src/rgw/store/dbstore/sqlite/sqliteDB.h
+++ b/src/rgw/store/dbstore/sqlite/sqliteDB.h
@@ -11,8 +11,9 @@
 #include "rgw/store/dbstore/common/dbstore.h"
 
 using namespace std;
+using namespace rgw::store;
 
-class SQLiteDB : public DBStore, public DBOp{
+class SQLiteDB : public DB, public DBOp{
   private:
     sqlite3_mutex *mutex = NULL;
 
@@ -23,10 +24,10 @@ class SQLiteDB : public DBStore, public DBOp{
     sqlite3_stmt *stmt = NULL;
     DBOpPrepareParams PrepareParams;
 
-    SQLiteDB(string db_name, CephContext *_cct) : DBStore(db_name, _cct), cct(_cct) {
+    SQLiteDB(string db_name, CephContext *_cct) : DB(db_name, _cct), cct(_cct) {
       InitPrepareParams(get_def_dpp(), PrepareParams);
     }
-    SQLiteDB(sqlite3 *dbi, CephContext *_cct) : DBStore(_cct), cct(_cct) {
+    SQLiteDB(sqlite3 *dbi, CephContext *_cct) : DB(_cct), cct(_cct) {
       db = (void*)dbi;
       InitPrepareParams(get_def_dpp(), PrepareParams);
     }
diff --git a/src/rgw/store/dbstore/tests/dbstore_tests.cc b/src/rgw/store/dbstore/tests/dbstore_tests.cc
index 1cb0657d912..d049935aedf 100644
--- a/src/rgw/store/dbstore/tests/dbstore_tests.cc
+++ b/src/rgw/store/dbstore/tests/dbstore_tests.cc
@@ -9,6 +9,7 @@
 #include "rgw_common.h"
 
 using namespace std;
+using DB = rgw::store::DB;
 
 vector<const char*> args;
 
@@ -45,7 +46,7 @@ namespace gtest {
       }
 
       string tenant;
-      class DBStore *db;
+      DB *db;
       string db_type;
       int ret;
       string logfile = "rgw_dbstore_tests.log";
@@ -59,10 +60,10 @@ string marker1;
 
 namespace {
 
-  class DBStoreBaseTest : public ::testing::Test {
+  class DBStoreTest : public ::testing::Test {
     protected:
       int ret;
-      DBStore *db = nullptr;
+      DB *db = nullptr;
       string user1 = "user1";
       string user_id1 = "user_id1";
       string bucket1 = "bucket1";
@@ -71,7 +72,7 @@ namespace {
       DBOpParams GlobalParams = {};
       const DoutPrefixProvider *dpp;
 
-      DBStoreBaseTest() {}
+      DBStoreTest() {}
       void SetUp() {
         db = gtest::env->db;
         ASSERT_TRUE(db != nullptr);
@@ -99,7 +100,7 @@ namespace {
   };
 }
 
-TEST_F(DBStoreBaseTest, InsertUser) {
+TEST_F(DBStoreTest, InsertUser) {
   struct DBOpParams params = GlobalParams;
   int ret = -1;
 
@@ -120,7 +121,7 @@ TEST_F(DBStoreBaseTest, InsertUser) {
   ASSERT_EQ(ret, 0);
 }
 
-TEST_F(DBStoreBaseTest, GetUser) {
+TEST_F(DBStoreTest, GetUser) {
   struct DBOpParams params = GlobalParams;
   int ret = -1;
 
@@ -145,7 +146,7 @@ TEST_F(DBStoreBaseTest, GetUser) {
 
 }
 
-TEST_F(DBStoreBaseTest, GetUserQuery) {
+TEST_F(DBStoreTest, GetUserQuery) {
   struct DBOpParams params = GlobalParams;
   int ret = -1;
 
@@ -173,7 +174,7 @@ TEST_F(DBStoreBaseTest, GetUserQuery) {
 
 }
 
-TEST_F(DBStoreBaseTest, GetUserQueryByEmail) {
+TEST_F(DBStoreTest, GetUserQueryByEmail) {
   int ret = -1;
   RGWUserInfo uinfo;
   string email = "user1@dbstore.com";
@@ -201,7 +202,7 @@ TEST_F(DBStoreBaseTest, GetUserQueryByEmail) {
   ASSERT_EQ(objv.read_version.ver, 1);
 }
 
-TEST_F(DBStoreBaseTest, GetUserQueryByAccessKey) {
+TEST_F(DBStoreTest, GetUserQueryByAccessKey) {
   int ret = -1;
   RGWUserInfo uinfo;
   string key = "id1";
@@ -226,7 +227,7 @@ TEST_F(DBStoreBaseTest, GetUserQueryByAccessKey) {
   ASSERT_EQ(k.key, "key2");
 }
 
-TEST_F(DBStoreBaseTest, StoreUser) {
+TEST_F(DBStoreTest, StoreUser) {
   struct DBOpParams params = GlobalParams;
   int ret = -1;
   RGWUserInfo uinfo, old_uinfo;
@@ -280,7 +281,7 @@ TEST_F(DBStoreBaseTest, StoreUser) {
   ASSERT_EQ(objv_tracker.read_version.tag, "UserTAG");
 }
 
-TEST_F(DBStoreBaseTest, GetUserQueryByUserID) {
+TEST_F(DBStoreTest, GetUserQueryByUserID) {
   int ret = -1;
   RGWUserInfo uinfo;
   map<std::string, bufferlist> attrs;
@@ -322,7 +323,7 @@ TEST_F(DBStoreBaseTest, GetUserQueryByUserID) {
   ASSERT_EQ(attr, "attrs2");
 }
 
-TEST_F(DBStoreBaseTest, ListAllUsers) {
+TEST_F(DBStoreTest, ListAllUsers) {
   struct DBOpParams params = GlobalParams;
   int ret = -1;
 
@@ -330,7 +331,7 @@ TEST_F(DBStoreBaseTest, ListAllUsers) {
   ASSERT_EQ(ret, 0);
 }
 
-TEST_F(DBStoreBaseTest, InsertBucket) {
+TEST_F(DBStoreTest, InsertBucket) {
   struct DBOpParams params = GlobalParams;
   int ret = -1;
 
@@ -350,7 +351,7 @@ TEST_F(DBStoreBaseTest, InsertBucket) {
   ASSERT_EQ(ret, 0);
 }
 
-TEST_F(DBStoreBaseTest, UpdateBucketAttrs) {
+TEST_F(DBStoreTest, UpdateBucketAttrs) {
   int ret = -1;
   RGWBucketInfo info;
   map<std::string, bufferlist> attrs;
@@ -376,7 +377,7 @@ TEST_F(DBStoreBaseTest, UpdateBucketAttrs) {
   ASSERT_EQ(objv.read_version.ver, 2);
 }
 
-TEST_F(DBStoreBaseTest, BucketChown) {
+TEST_F(DBStoreTest, BucketChown) {
   int ret = -1;
   RGWBucketInfo info;
   rgw_user user;
@@ -389,7 +390,7 @@ TEST_F(DBStoreBaseTest, BucketChown) {
   ASSERT_EQ(info.objv_tracker.read_version.ver, 3);
 }
 
-TEST_F(DBStoreBaseTest, UpdateBucketInfo) {
+TEST_F(DBStoreTest, UpdateBucketInfo) {
   struct DBOpParams params = GlobalParams;
   int ret = -1;
   RGWBucketInfo info;
@@ -407,7 +408,7 @@ TEST_F(DBStoreBaseTest, UpdateBucketInfo) {
   ASSERT_EQ(info.objv_tracker.read_version.ver, 4);
 }
 
-TEST_F(DBStoreBaseTest, GetBucket) {
+TEST_F(DBStoreTest, GetBucket) {
   struct DBOpParams params = GlobalParams;
   int ret = -1;
 
@@ -436,7 +437,7 @@ TEST_F(DBStoreBaseTest, GetBucket) {
   ASSERT_EQ(acl, "attrs2");
 }
 
-TEST_F(DBStoreBaseTest, RemoveBucketAPI) {
+TEST_F(DBStoreTest, RemoveBucketAPI) {
   int ret = -1;
   RGWBucketInfo info;
 
@@ -446,7 +447,7 @@ TEST_F(DBStoreBaseTest, RemoveBucketAPI) {
   ASSERT_EQ(ret, 0);
 }
 
-TEST_F(DBStoreBaseTest, RemoveUserAPI) {
+TEST_F(DBStoreTest, RemoveUserAPI) {
   int ret = -1;
   RGWUserInfo uinfo;
   RGWObjVersionTracker objv;
@@ -465,7 +466,7 @@ TEST_F(DBStoreBaseTest, RemoveUserAPI) {
   ASSERT_EQ(ret, 0);
 }
 
-TEST_F(DBStoreBaseTest, CreateBucket) {
+TEST_F(DBStoreTest, CreateBucket) {
   struct DBOpParams params = GlobalParams;
   int ret = -1;
   RGWBucketInfo info;
@@ -511,7 +512,7 @@ TEST_F(DBStoreBaseTest, CreateBucket) {
   ASSERT_EQ(ret, 0);
 }
 
-TEST_F(DBStoreBaseTest, GetBucketQueryByName) {
+TEST_F(DBStoreTest, GetBucketQueryByName) {
   int ret = -1;
   RGWBucketInfo binfo;
   binfo.bucket.name = "bucket2";
@@ -536,7 +537,7 @@ TEST_F(DBStoreBaseTest, GetBucketQueryByName) {
   marker1 = binfo.bucket.marker;
 }
 
-TEST_F(DBStoreBaseTest, ListUserBuckets) {
+TEST_F(DBStoreTest, ListUserBuckets) {
   struct DBOpParams params = GlobalParams;
   int ret = -1;
   rgw_user owner;
@@ -572,7 +573,7 @@ TEST_F(DBStoreBaseTest, ListUserBuckets) {
   } while(is_truncated);
 }
 
-TEST_F(DBStoreBaseTest, ListAllBuckets) {
+TEST_F(DBStoreTest, ListAllBuckets) {
   struct DBOpParams params = GlobalParams;
   int ret = -1;
 
@@ -580,7 +581,7 @@ TEST_F(DBStoreBaseTest, ListAllBuckets) {
   ASSERT_EQ(ret, 0);
 }
 
-TEST_F(DBStoreBaseTest, InsertObject) {
+TEST_F(DBStoreTest, InsertObject) {
   struct DBOpParams params = GlobalParams;
   int ret = -1;
 
@@ -588,7 +589,7 @@ TEST_F(DBStoreBaseTest, InsertObject) {
   ASSERT_EQ(ret, 0);
 }
 
-TEST_F(DBStoreBaseTest, ListObject) {
+TEST_F(DBStoreTest, ListObject) {
   struct DBOpParams params = GlobalParams;
   int ret = -1;
 
@@ -596,7 +597,7 @@ TEST_F(DBStoreBaseTest, ListObject) {
   ASSERT_EQ(ret, 0);
 }
 
-TEST_F(DBStoreBaseTest, ListAllObjects) {
+TEST_F(DBStoreTest, ListAllObjects) {
   struct DBOpParams params = GlobalParams;
   int ret = -1;
 
@@ -604,7 +605,7 @@ TEST_F(DBStoreBaseTest, ListAllObjects) {
   ASSERT_EQ(ret, 0);
 }
 
-TEST_F(DBStoreBaseTest, PutObjectData) {
+TEST_F(DBStoreTest, PutObjectData) {
   struct DBOpParams params = GlobalParams;
   int ret = -1;
 
@@ -612,7 +613,7 @@ TEST_F(DBStoreBaseTest, PutObjectData) {
   ASSERT_EQ(ret, 0);
 }
 
-TEST_F(DBStoreBaseTest, GetObjectData) {
+TEST_F(DBStoreTest, GetObjectData) {
   struct DBOpParams params = GlobalParams;
   int ret = -1;
 
@@ -620,7 +621,7 @@ TEST_F(DBStoreBaseTest, GetObjectData) {
   ASSERT_EQ(ret, 0);
 }
 
-TEST_F(DBStoreBaseTest, DeleteObjectData) {
+TEST_F(DBStoreTest, DeleteObjectData) {
   struct DBOpParams params = GlobalParams;
   int ret = -1;
 
@@ -628,7 +629,7 @@ TEST_F(DBStoreBaseTest, DeleteObjectData) {
   ASSERT_EQ(ret, 0);
 }
 
-TEST_F(DBStoreBaseTest, RemoveObject) {
+TEST_F(DBStoreTest, RemoveObject) {
   struct DBOpParams params = GlobalParams;
   int ret = -1;
 
@@ -636,7 +637,7 @@ TEST_F(DBStoreBaseTest, RemoveObject) {
   ASSERT_EQ(ret, 0);
 }
 
-TEST_F(DBStoreBaseTest, RemoveBucket) {
+TEST_F(DBStoreTest, RemoveBucket) {
   struct DBOpParams params = GlobalParams;
   int ret = -1;
 
@@ -644,7 +645,7 @@ TEST_F(DBStoreBaseTest, RemoveBucket) {
   ASSERT_EQ(ret, 0);
 }
 
-TEST_F(DBStoreBaseTest, RemoveUser) {
+TEST_F(DBStoreTest, RemoveUser) {
   struct DBOpParams params = GlobalParams;
   int ret = -1;
 
@@ -652,7 +653,7 @@ TEST_F(DBStoreBaseTest, RemoveUser) {
   ASSERT_EQ(ret, 0);
 }
 
-TEST_F(DBStoreBaseTest, InsertTestIDUser) {
+TEST_F(DBStoreTest, InsertTestIDUser) {
   struct DBOpParams params = GlobalParams;
   int ret = -1;
 
-- 
2.39.5