SERVER-62918 Change DBLock to use DatabaseName

53 files changed, 411 insertions, 247 deletions

diff --git a/src/mongo/db/auth/authz_manager_external_state_local.cpp b/src/mongo/db/auth/authz_manager_external_state_local.cpp
index 0228897aad8..7020dfd5ef6 100644
--- a/src/mongo/db/auth/authz_manager_external_state_local.cpp
+++ b/src/mongo/db/auth/authz_manager_external_state_local.cpp
@@ -280,8 +280,8 @@ AuthzManagerExternalStateLocal::RolesLocks::RolesLocks(OperationContext* opCtx,
     if (!storageGlobalParams.disableLockFreeReads) {
         _readLockFree = std::make_unique<AutoReadLockFree>(opCtx);
     } else {
-        _adminLock =
-            std::make_unique<Lock::DBLock>(opCtx, NamespaceString::kAdminDb, LockMode::MODE_IS);
+        _adminLock = std::make_unique<Lock::DBLock>(
+            opCtx, DatabaseName(boost::none, NamespaceString::kAdminDb), LockMode::MODE_IS);
         _rolesLock = std::make_unique<Lock::CollectionLock>(
             opCtx, getRolesCollection(tenant), LockMode::MODE_S);
     }
diff --git a/src/mongo/db/catalog/collection_catalog.cpp b/src/mongo/db/catalog/collection_catalog.cpp
index 4c02fb5a1a5..428b174ef18 100644
--- a/src/mongo/db/catalog/collection_catalog.cpp
+++ b/src/mongo/db/catalog/collection_catalog.cpp
@@ -1172,8 +1172,7 @@ void CollectionCatalog::registerCollection(OperationContext* opCtx,
 
     invariant(static_cast<size_t>(_stats.internal + _stats.userCollections) == _collections.size());
 
-    // TODO SERVER-62918 create ResourceId for db with DatabaseName.
-    auto dbRid = ResourceId(RESOURCE_DATABASE, nss.dbName().toString());
+    auto dbRid = ResourceId(RESOURCE_DATABASE, nss.dbName().toStringWithTenantId());
     addResource(dbRid, nss.dbName().toString());
 
     auto collRid = ResourceId(RESOURCE_COLLECTION, nss.ns());
diff --git a/src/mongo/db/catalog/collection_catalog.h b/src/mongo/db/catalog/collection_catalog.h
index dbf3db5956a..83d6abb47fe 100644
--- a/src/mongo/db/catalog/collection_catalog.h
+++ b/src/mongo/db/catalog/collection_catalog.h
@@ -523,11 +523,17 @@ public:
 
     /**
      * Removes an existing ResourceId 'rid' with namespace 'entry' from the map.
+     *
+     * TODO SERVER-67442 Create versions of removeResource that take in NamespaceString and
+     * DatabaseName and make the method that takes in a string private.
      */
     void removeResource(const ResourceId& rid, const std::string& entry);
 
     /**
      * Inserts a new ResourceId 'rid' into the map with namespace 'entry'.
+     *
+     * TODO SERVER-67442 Create versions of addResource that take in NamespaceString and
+     * DatabaseName and make the method that takes in a string private.
      */
     void addResource(const ResourceId& rid, const std::string& entry);
 
diff --git a/src/mongo/db/catalog/collection_catalog_test.cpp b/src/mongo/db/catalog/collection_catalog_test.cpp
index e876ab41de9..d18d4a24962 100644
--- a/src/mongo/db/catalog/collection_catalog_test.cpp
+++ b/src/mongo/db/catalog/collection_catalog_test.cpp
@@ -625,8 +625,8 @@ TEST_F(CollectionCatalogTest, GetAllCollectionNamesAndGetAllDbNames) {
 
     std::vector<NamespaceString> dCollList = {d1Coll, d2Coll, d3Coll};
 
-    Lock::DBLock dbLock(opCtx.get(), "dbD", MODE_S);
-    auto res = catalog.getAllCollectionNamesFromDb(opCtx.get(), DatabaseName(boost::none, "dbD"));
+    Lock::DBLock dbLock(opCtx.get(), d1Coll.dbName(), MODE_S);
+    auto res = catalog.getAllCollectionNamesFromDb(opCtx.get(), d1Coll.dbName());
     std::sort(res.begin(), res.end());
     ASSERT(res == dCollList);
 
@@ -684,7 +684,7 @@ TEST_F(CollectionCatalogTest, GetAllCollectionNamesAndGetAllDbNamesWithUncommitt
         const_cast<Collection*>(catalog.lookupCollectionByNamespace(opCtx.get(), aColl).get());
     invisibleCollA->setCommitted(false);
 
-    Lock::DBLock dbLock(opCtx.get(), "dbA", MODE_S);
+    Lock::DBLock dbLock(opCtx.get(), aColl.dbName(), MODE_S);
     auto res = catalog.getAllCollectionNamesFromDb(opCtx.get(), DatabaseName(boost::none, "dbA"));
     ASSERT(res.empty());
 
@@ -708,7 +708,7 @@ TEST_F(CollectionCatalogTest, GetAllCollectionNamesAndGetAllDbNamesWithUncommitt
             const_cast<Collection*>(catalog.lookupCollectionByNamespace(opCtx.get(), nss).get());
         invisibleCollD->setCommitted(false);
 
-        Lock::DBLock dbLock(opCtx.get(), "dbD", MODE_S);
+        Lock::DBLock dbLock(opCtx.get(), d1Coll.dbName(), MODE_S);
         res = catalog.getAllCollectionNamesFromDb(opCtx.get(), DatabaseName(boost::none, "dbD"));
         std::sort(res.begin(), res.end());
         ASSERT(res == dCollList);
@@ -758,9 +758,9 @@ TEST_F(ForEachCollectionFromDbTest, ForEachCollectionFromDb) {
     auto opCtx = operationContext();
 
     {
-        auto dbLock = std::make_unique<Lock::DBLock>(opCtx, "db", MODE_IX);
-        int numCollectionsTraversed = 0;
         const DatabaseName dbName(boost::none, "db");
+        auto dbLock = std::make_unique<Lock::DBLock>(opCtx, dbName, MODE_IX);
+        int numCollectionsTraversed = 0;
         catalog::forEachCollectionFromDb(
             opCtx, dbName, MODE_X, [&](const CollectionPtr& collection) {
                 ASSERT_TRUE(
@@ -773,9 +773,9 @@ TEST_F(ForEachCollectionFromDbTest, ForEachCollectionFromDb) {
     }
 
     {
-        auto dbLock = std::make_unique<Lock::DBLock>(opCtx, "db2", MODE_IX);
-        int numCollectionsTraversed = 0;
         const DatabaseName dbName(boost::none, "db2");
+        auto dbLock = std::make_unique<Lock::DBLock>(opCtx, dbName, MODE_IX);
+        int numCollectionsTraversed = 0;
         catalog::forEachCollectionFromDb(
             opCtx, dbName, MODE_IS, [&](const CollectionPtr& collection) {
                 ASSERT_TRUE(
@@ -788,9 +788,9 @@ TEST_F(ForEachCollectionFromDbTest, ForEachCollectionFromDb) {
     }
 
     {
-        auto dbLock = std::make_unique<Lock::DBLock>(opCtx, "db3", MODE_IX);
-        int numCollectionsTraversed = 0;
         const DatabaseName dbName(boost::none, "db3");
+        auto dbLock = std::make_unique<Lock::DBLock>(opCtx, dbName, MODE_IX);
+        int numCollectionsTraversed = 0;
         catalog::forEachCollectionFromDb(
             opCtx, dbName, MODE_S, [&](const CollectionPtr& collection) {
                 numCollectionsTraversed++;
@@ -806,9 +806,9 @@ TEST_F(ForEachCollectionFromDbTest, ForEachCollectionFromDbWithPredicate) {
     auto opCtx = operationContext();
 
     {
-        auto dbLock = std::make_unique<Lock::DBLock>(opCtx, "db", MODE_IX);
-        int numCollectionsTraversed = 0;
         const DatabaseName dbName(boost::none, "db");
+        auto dbLock = std::make_unique<Lock::DBLock>(opCtx, dbName, MODE_IX);
+        int numCollectionsTraversed = 0;
         catalog::forEachCollectionFromDb(
             opCtx,
             dbName,
@@ -829,9 +829,9 @@ TEST_F(ForEachCollectionFromDbTest, ForEachCollectionFromDbWithPredicate) {
     }
 
     {
-        auto dbLock = std::make_unique<Lock::DBLock>(opCtx, "db", MODE_IX);
-        int numCollectionsTraversed = 0;
         const DatabaseName dbName(boost::none, "db");
+        auto dbLock = std::make_unique<Lock::DBLock>(opCtx, dbName, MODE_IX);
+        int numCollectionsTraversed = 0;
         catalog::forEachCollectionFromDb(
             opCtx,
             dbName,
diff --git a/src/mongo/db/catalog/create_collection_test.cpp b/src/mongo/db/catalog/create_collection_test.cpp
index b5cce6e6686..8d711c44dc0 100644
--- a/src/mongo/db/catalog/create_collection_test.cpp
+++ b/src/mongo/db/catalog/create_collection_test.cpp
@@ -146,7 +146,7 @@ TEST_F(CreateCollectionTest, CreateCollectionForApplyOpsWithSpecificUuidNoExisti
     ASSERT_FALSE(collectionExists(opCtx.get(), newNss));
 
     auto uuid = UUID::gen();
-    Lock::DBLock lock(opCtx.get(), newNss.db(), MODE_IX);
+    Lock::DBLock lock(opCtx.get(), newNss.dbName(), MODE_IX);
     ASSERT_OK(createCollectionForApplyOps(opCtx.get(),
                                           newNss.db().toString(),
                                           uuid,
@@ -232,7 +232,7 @@ TEST_F(CreateCollectionTest,
 
     auto opCtx = makeOpCtx();
     auto uuid = UUID::gen();
-    Lock::DBLock lock(opCtx.get(), newNss.db(), MODE_IX);
+    Lock::DBLock lock(opCtx.get(), newNss.dbName(), MODE_IX);
 
     // Create drop pending collection using StorageInterface.
     {
diff --git a/src/mongo/db/catalog/database_test.cpp b/src/mongo/db/catalog/database_test.cpp
index 1df4bf7fa1b..14ee383f73e 100644
--- a/src/mongo/db/catalog/database_test.cpp
+++ b/src/mongo/db/catalog/database_test.cpp
@@ -415,7 +415,7 @@ TEST_F(
 
 TEST_F(DatabaseTest, AutoGetDBSucceedsWithDeadlineNow) {
     NamespaceString nss("test", "coll");
-    Lock::DBLock lock(_opCtx.get(), nss.db(), MODE_X);
+    Lock::DBLock lock(_opCtx.get(), nss.dbName(), MODE_X);
     ASSERT(_opCtx.get()->lockState()->isDbLockedForMode(nss.db(), MODE_X));
     try {
         AutoGetDb db(_opCtx.get(), nss.db(), MODE_X, Date_t::now());
@@ -427,7 +427,7 @@ TEST_F(DatabaseTest, AutoGetDBSucceedsWithDeadlineNow) {
 
 TEST_F(DatabaseTest, AutoGetDBSucceedsWithDeadlineMin) {
     NamespaceString nss("test", "coll");
-    Lock::DBLock lock(_opCtx.get(), nss.db(), MODE_X);
+    Lock::DBLock lock(_opCtx.get(), nss.dbName(), MODE_X);
     ASSERT(_opCtx.get()->lockState()->isDbLockedForMode(nss.db(), MODE_X));
     try {
         AutoGetDb db(_opCtx.get(), nss.db(), MODE_X, Date_t());
@@ -439,7 +439,7 @@ TEST_F(DatabaseTest, AutoGetDBSucceedsWithDeadlineMin) {
 
 TEST_F(DatabaseTest, AutoGetCollectionForReadCommandSucceedsWithDeadlineNow) {
     NamespaceString nss("test", "coll");
-    Lock::DBLock dbLock(_opCtx.get(), nss.db(), MODE_X);
+    Lock::DBLock dbLock(_opCtx.get(), nss.dbName(), MODE_X);
     ASSERT(_opCtx.get()->lockState()->isDbLockedForMode(nss.db(), MODE_X));
     Lock::CollectionLock collLock(_opCtx.get(), nss, MODE_X);
     ASSERT(_opCtx.get()->lockState()->isCollectionLockedForMode(nss, MODE_X));
@@ -453,7 +453,7 @@ TEST_F(DatabaseTest, AutoGetCollectionForReadCommandSucceedsWithDeadlineNow) {
 
 TEST_F(DatabaseTest, AutoGetCollectionForReadCommandSucceedsWithDeadlineMin) {
     NamespaceString nss("test", "coll");
-    Lock::DBLock dbLock(_opCtx.get(), nss.db(), MODE_X);
+    Lock::DBLock dbLock(_opCtx.get(), nss.dbName(), MODE_X);
     ASSERT(_opCtx.get()->lockState()->isDbLockedForMode(nss.db(), MODE_X));
     Lock::CollectionLock collLock(_opCtx.get(), nss, MODE_X);
     ASSERT(_opCtx.get()->lockState()->isCollectionLockedForMode(nss, MODE_X));
diff --git a/src/mongo/db/catalog/rename_collection.cpp b/src/mongo/db/catalog/rename_collection.cpp
index 75487199954..9b3c15a4f04 100644
--- a/src/mongo/db/catalog/rename_collection.cpp
+++ b/src/mongo/db/catalog/rename_collection.cpp
@@ -295,7 +295,7 @@ Status renameCollectionWithinDB(OperationContext* opCtx,
     invariant(source.db() == target.db());
     DisableDocumentValidation validationDisabler(opCtx);
 
-    Lock::DBLock dbWriteLock(opCtx, source.db(), MODE_IX);
+    Lock::DBLock dbWriteLock(opCtx, source.dbName(), MODE_IX);
 
     {
         auto dss = DatabaseShardingState::get(opCtx, source.db());
@@ -356,7 +356,7 @@ Status renameCollectionWithinDBForApplyOps(OperationContext* opCtx,
     invariant(source.db() == target.db());
     DisableDocumentValidation validationDisabler(opCtx);
 
-    Lock::DBLock dbWriteLock(opCtx, source.db(), MODE_X);
+    Lock::DBLock dbWriteLock(opCtx, source.dbName(), MODE_X);
 
     {
         auto dss = DatabaseShardingState::get(opCtx, source.db());
@@ -483,13 +483,13 @@ Status renameBetweenDBs(OperationContext* opCtx,
         // Lock the DB using MODE_IX to ensure we have the global lock in that mode, as to prevent
         // upgrade from MODE_IS to MODE_IX, which caused deadlock on systems not supporting Database
         // locking and should be avoided in general.
-        sourceDbLock.emplace(opCtx, source.db(), MODE_IX);
+        sourceDbLock.emplace(opCtx, source.dbName(), MODE_IX);
         sourceCollLock.emplace(opCtx, source, MODE_S);
     }
 
     boost::optional<Lock::DBLock> targetDBLock;
     if (!opCtx->lockState()->isDbLockedForMode(target.db(), MODE_X)) {
-        targetDBLock.emplace(opCtx, target.db(), MODE_X);
+        targetDBLock.emplace(opCtx, target.dbName(), MODE_X);
     }
 
     {
diff --git a/src/mongo/db/catalog/rename_collection_test.cpp b/src/mongo/db/catalog/rename_collection_test.cpp
index 20c4d4be11b..77d9f423d74 100644
--- a/src/mongo/db/catalog/rename_collection_test.cpp
+++ b/src/mongo/db/catalog/rename_collection_test.cpp
@@ -1069,8 +1069,8 @@ TEST_F(RenameCollectionTest, RenameCollectionAcrossDatabasesWithLocks) {
     // from secondary oplog application).
     _createCollection(_opCtx.get(), _sourceNss);
     _insertDocument(_opCtx.get(), _sourceNss, BSON("_id" << 0));
-    Lock::DBLock sourceLk(_opCtx.get(), _sourceNss.db(), MODE_X);
-    Lock::DBLock targetLk(_opCtx.get(), _targetNssDifferentDb.db(), MODE_X);
+    Lock::DBLock sourceLk(_opCtx.get(), _sourceNss.dbName(), MODE_X);
+    Lock::DBLock targetLk(_opCtx.get(), _targetNssDifferentDb.dbName(), MODE_X);
     ASSERT_OK(renameCollection(_opCtx.get(), _sourceNss, _targetNssDifferentDb, {}));
     ASSERT_TRUE(_opObserver->onInsertsIsTargetDatabaseExclusivelyLocked);
 }
diff --git a/src/mongo/db/catalog_raii.cpp b/src/mongo/db/catalog_raii.cpp
index e376905e45f..760bd4fa8fb 100644
--- a/src/mongo/db/catalog_raii.cpp
+++ b/src/mongo/db/catalog_raii.cpp
@@ -168,9 +168,10 @@ void acquireCollectionLocksInResourceIdOrder(
 
 }  // namespace
 
-// TODO SERVER-62918 Pass DatabaseName instead of string for dbName.
+// TODO SERVER-62923 Use DatabaseName obj to construct '_dbLock' and to pass to
+// DatabaseHolder::getDb().
 AutoGetDb::AutoGetDb(OperationContext* opCtx, StringData dbName, LockMode mode, Date_t deadline)
-    : _dbName(dbName), _dbLock(opCtx, dbName, mode, deadline), _db([&] {
+    : _dbName(dbName), _dbLock(opCtx, DatabaseName(boost::none, dbName), mode, deadline), _db([&] {
           const DatabaseName tenantDbName(boost::none, dbName);
           auto databaseHolder = DatabaseHolder::get(opCtx);
           return databaseHolder->getDb(opCtx, tenantDbName);
diff --git a/src/mongo/db/catalog_raii_test.cpp b/src/mongo/db/catalog_raii_test.cpp
index 2b86133de66..b0423a7a4db 100644
--- a/src/mongo/db/catalog_raii_test.cpp
+++ b/src/mongo/db/catalog_raii_test.cpp
@@ -89,7 +89,7 @@ void failsWithLockTimeout(std::function<void()> func, Milliseconds timeoutMillis
 }
 
 TEST_F(CatalogRAIITestFixture, AutoGetDBDeadline) {
-    Lock::DBLock dbLock1(client1.second.get(), nss.db(), MODE_X);
+    Lock::DBLock dbLock1(client1.second.get(), nss.dbName(), MODE_X);
     ASSERT(client1.second->lockState()->isDbLockedForMode(nss.db(), MODE_X));
     failsWithLockTimeout(
         [&] { AutoGetDb db(client2.second.get(), nss.db(), MODE_X, Date_t::now() + timeoutMs); },
@@ -105,7 +105,7 @@ TEST_F(CatalogRAIITestFixture, AutoGetDBGlobalLockDeadline) {
 }
 
 TEST_F(CatalogRAIITestFixture, AutoGetDBDeadlineNow) {
-    Lock::DBLock dbLock1(client1.second.get(), nss.db(), MODE_IX);
+    Lock::DBLock dbLock1(client1.second.get(), nss.dbName(), MODE_IX);
     ASSERT(client1.second->lockState()->isDbLockedForMode(nss.db(), MODE_IX));
     AutoGetDb db(client2.second.get(), nss.db(), MODE_IX);
     failsWithLockTimeout(
@@ -114,7 +114,7 @@ TEST_F(CatalogRAIITestFixture, AutoGetDBDeadlineNow) {
 }
 
 TEST_F(CatalogRAIITestFixture, AutoGetDBDeadlineMin) {
-    Lock::DBLock dbLock1(client1.second.get(), nss.db(), MODE_IX);
+    Lock::DBLock dbLock1(client1.second.get(), nss.dbName(), MODE_IX);
     ASSERT(client1.second->lockState()->isDbLockedForMode(nss.db(), MODE_IX));
     AutoGetDb db(client2.second.get(), nss.db(), MODE_IX);
     failsWithLockTimeout([&] { AutoGetDb db(client2.second.get(), nss.db(), MODE_X, Date_t{}); },
@@ -122,7 +122,7 @@ TEST_F(CatalogRAIITestFixture, AutoGetDBDeadlineMin) {
 }
 
 TEST_F(CatalogRAIITestFixture, AutoGetCollectionCollLockDeadline) {
-    Lock::DBLock dbLock1(client1.second.get(), nss.db(), MODE_IX);
+    Lock::DBLock dbLock1(client1.second.get(), nss.dbName(), MODE_IX);
     ASSERT(client1.second->lockState()->isDbLockedForMode(nss.db(), MODE_IX));
     Lock::CollectionLock collLock1(client1.second.get(), nss, MODE_X);
     ASSERT(client1.second->lockState()->isCollectionLockedForMode(nss, MODE_X));
@@ -138,7 +138,7 @@ TEST_F(CatalogRAIITestFixture, AutoGetCollectionCollLockDeadline) {
 }
 
 TEST_F(CatalogRAIITestFixture, AutoGetCollectionDBLockDeadline) {
-    Lock::DBLock dbLock1(client1.second.get(), nss.db(), MODE_X);
+    Lock::DBLock dbLock1(client1.second.get(), nss.dbName(), MODE_X);
     ASSERT(client1.second->lockState()->isDbLockedForMode(nss.db(), MODE_X));
     failsWithLockTimeout(
         [&] {
@@ -166,7 +166,7 @@ TEST_F(CatalogRAIITestFixture, AutoGetCollectionGlobalLockDeadline) {
 }
 
 TEST_F(CatalogRAIITestFixture, AutoGetCollectionDeadlineNow) {
-    Lock::DBLock dbLock1(client1.second.get(), nss.db(), MODE_IX);
+    Lock::DBLock dbLock1(client1.second.get(), nss.dbName(), MODE_IX);
     ASSERT(client1.second->lockState()->isDbLockedForMode(nss.db(), MODE_IX));
     Lock::CollectionLock collLock1(client1.second.get(), nss, MODE_X);
     ASSERT(client1.second->lockState()->isCollectionLockedForMode(nss, MODE_X));
@@ -183,7 +183,7 @@ TEST_F(CatalogRAIITestFixture, AutoGetCollectionDeadlineNow) {
 }
 
 TEST_F(CatalogRAIITestFixture, AutoGetCollectionDeadlineMin) {
-    Lock::DBLock dbLock1(client1.second.get(), nss.db(), MODE_IX);
+    Lock::DBLock dbLock1(client1.second.get(), nss.dbName(), MODE_IX);
     ASSERT(client1.second->lockState()->isDbLockedForMode(nss.db(), MODE_IX));
     Lock::CollectionLock collLock1(client1.second.get(), nss, MODE_X);
     ASSERT(client1.second->lockState()->isCollectionLockedForMode(nss, MODE_X));
@@ -215,7 +215,7 @@ TEST_F(CatalogRAIITestFixture, AutoGetCollectionNotCompatibleWithRSTLExclusiveLo
 }
 
 TEST_F(CatalogRAIITestFixture, AutoGetCollectionDBLockCompatibleX) {
-    Lock::DBLock dbLock1(client1.second.get(), nss.db(), MODE_IX);
+    Lock::DBLock dbLock1(client1.second.get(), nss.dbName(), MODE_IX);
     ASSERT(client1.second->lockState()->isDbLockedForMode(nss.db(), MODE_IX));
 
     AutoGetCollection coll(client2.second.get(), nss, MODE_X);
@@ -379,7 +379,7 @@ TEST_F(CatalogRAIITestFixture, AutoGetCollectionLockFreeGlobalLockDeadline) {
 }
 
 TEST_F(CatalogRAIITestFixture, AutoGetCollectionLockFreeCompatibleWithCollectionExclusiveLock) {
-    Lock::DBLock dbLock1(client1.second.get(), nss.db(), MODE_IX);
+    Lock::DBLock dbLock1(client1.second.get(), nss.dbName(), MODE_IX);
     ASSERT(client1.second->lockState()->isDbLockedForMode(nss.db(), MODE_IX));
     Lock::CollectionLock collLock1(client1.second.get(), nss, MODE_X);
     ASSERT(client1.second->lockState()->isCollectionLockedForMode(nss, MODE_X));
@@ -391,7 +391,7 @@ TEST_F(CatalogRAIITestFixture, AutoGetCollectionLockFreeCompatibleWithCollection
 }
 
 TEST_F(CatalogRAIITestFixture, AutoGetCollectionLockFreeCompatibleWithDatabaseExclusiveLock) {
-    Lock::DBLock dbLock1(client1.second.get(), nss.db(), MODE_X);
+    Lock::DBLock dbLock1(client1.second.get(), nss.dbName(), MODE_X);
     ASSERT(client1.second->lockState()->isDbLockedForMode(nss.db(), MODE_X));
 
     AutoGetCollectionLockFree coll(
diff --git a/src/mongo/db/cloner.cpp b/src/mongo/db/cloner.cpp
index a6f394b481d..31fef75adc3 100644
--- a/src/mongo/db/cloner.cpp
+++ b/src/mongo/db/cloner.cpp
@@ -96,7 +96,9 @@ struct Cloner::BatchHandler {
 
     void operator()(DBClientCursor& cursor) {
         boost::optional<Lock::DBLock> dbLock;
-        dbLock.emplace(opCtx, _dbName, MODE_X);
+        // TODO SERVER-63111 Once the Cloner holds a DatabaseName obj, use _dbName directly
+        DatabaseName dbName(boost::none, _dbName);
+        dbLock.emplace(opCtx, dbName, MODE_X);
         uassert(ErrorCodes::NotWritablePrimary,
                 str::stream() << "Not primary while cloning collection " << nss,
                 !opCtx->writesAreReplicated() ||
@@ -104,8 +106,6 @@ struct Cloner::BatchHandler {
 
         // Make sure database still exists after we resume from the temp release
         auto databaseHolder = DatabaseHolder::get(opCtx);
-        // TODO SERVER-63111 use TenantDatabase in the Cloner.
-        const DatabaseName dbName(boost::none, _dbName);
         auto db = databaseHolder->openDb(opCtx, dbName);
         auto catalog = CollectionCatalog::get(opCtx);
         auto collection = catalog->lookupCollectionByNamespace(opCtx, nss);
@@ -143,7 +143,10 @@ struct Cloner::BatchHandler {
 
                 CurOp::get(opCtx)->yielded();
 
-                dbLock.emplace(opCtx, _dbName, MODE_X);
+                // TODO SERVER-63111 Once the cloner takes in a DatabaseName obj, use _dbName
+                // directly
+                DatabaseName dbName(boost::none, _dbName);
+                dbLock.emplace(opCtx, dbName, MODE_X);
 
                 // Check if everything is still all right.
                 if (opCtx->writesAreReplicated()) {
@@ -521,7 +524,9 @@ Status Cloner::copyDb(OperationContext* opCtx,
     }
 
     {
-        Lock::DBLock dbXLock(opCtx, dBName, MODE_X);
+        // TODO SERVER-63111 Once the cloner takes in a DatabaseName obj, use dBName directly
+        DatabaseName dbName(boost::none, dBName);
+        Lock::DBLock dbXLock(opCtx, dbName, MODE_X);
         uassert(ErrorCodes::NotWritablePrimary,
                 str::stream() << "Not primary while cloning database " << dBName
                               << " (after getting list of collections to clone)",
diff --git a/src/mongo/db/commands/create_indexes.cpp b/src/mongo/db/commands/create_indexes.cpp
index 9b848683cd3..cc485daef04 100644
--- a/src/mongo/db/commands/create_indexes.cpp
+++ b/src/mongo/db/commands/create_indexes.cpp
@@ -497,7 +497,7 @@ CreateIndexesReply runCreateIndexesWithCoordinator(OperationContext* opCtx,
     boost::optional<UUID> collectionUUID;
     CreateIndexesReply reply;
     {
-        Lock::DBLock dbLock(opCtx, ns.db(), MODE_IX);
+        Lock::DBLock dbLock(opCtx, ns.dbName(), MODE_IX);
         checkDatabaseShardingState(opCtx, ns);
         if (!repl::ReplicationCoordinator::get(opCtx)->canAcceptWritesFor(opCtx, ns)) {
             uasserted(ErrorCodes::NotWritablePrimary,
diff --git a/src/mongo/db/commands/dbcommands_d.cpp b/src/mongo/db/commands/dbcommands_d.cpp
index 7512ed32615..fa7dfbf71d1 100644
--- a/src/mongo/db/commands/dbcommands_d.cpp
+++ b/src/mongo/db/commands/dbcommands_d.cpp
@@ -324,7 +324,7 @@ public:
                 // a lock. For example, AutoGetCollection will throw if this namespace has since
                 // turned into a view and AutoGetDb will throw if the database version is stale.
                 UninterruptibleLockGuard noInterrupt(opCtx->lockState());
-                Lock::DBLock dbLock(opCtx, nss.db(), MODE_IS);
+                Lock::DBLock dbLock(opCtx, nss.dbName(), MODE_IS);
                 invariant(dbLock.isLocked(),
                           "Expected lock acquisition to succeed due to UninterruptibleLockGuard");
                 Lock::CollectionLock collLock(opCtx, nss, MODE_IS);
diff --git a/src/mongo/db/commands/feature_compatibility_version.cpp b/src/mongo/db/commands/feature_compatibility_version.cpp
index 8e08ae43b2d..d06f305eb58 100644
--- a/src/mongo/db/commands/feature_compatibility_version.cpp
+++ b/src/mongo/db/commands/feature_compatibility_version.cpp
@@ -380,7 +380,7 @@ bool FeatureCompatibilityVersion::hasNoReplicatedCollections(OperationContext* o
     std::vector<DatabaseName> dbNames = storageEngine->listDatabases();
     auto catalog = CollectionCatalog::get(opCtx);
     for (auto&& dbName : dbNames) {
-        Lock::DBLock dbLock(opCtx, dbName.db(), MODE_S);
+        Lock::DBLock dbLock(opCtx, dbName, MODE_S);
         for (auto&& collNss : catalog->getAllCollectionNamesFromDb(opCtx, dbName)) {
             if (collNss.isReplicated()) {
                 return false;
diff --git a/src/mongo/db/commands/set_feature_compatibility_version_command.cpp b/src/mongo/db/commands/set_feature_compatibility_version_command.cpp
index 6ccc3ad374f..0a996e29646 100644
--- a/src/mongo/db/commands/set_feature_compatibility_version_command.cpp
+++ b/src/mongo/db/commands/set_feature_compatibility_version_command.cpp
@@ -574,8 +574,7 @@ private:
         if (serverGlobalParams.featureCompatibility
                 .isFCVDowngradingOrAlreadyDowngradedFromLatest()) {
             for (const auto& dbName : DatabaseHolder::get(opCtx)->getNames()) {
-                const auto& db = dbName.db();
-                Lock::DBLock dbLock(opCtx, db, MODE_IX);
+                Lock::DBLock dbLock(opCtx, dbName, MODE_IX);
                 catalog::forEachCollectionFromDb(
                     opCtx,
                     dbName,
@@ -620,8 +619,7 @@ private:
             // Block downgrade for collections with encrypted fields
             // TODO SERVER-65077: Remove once FCV 6.0 becomes last-lts.
             for (const auto& dbName : DatabaseHolder::get(opCtx)->getNames()) {
-                const auto& db = dbName.db();
-                Lock::DBLock dbLock(opCtx, db, MODE_IX);
+                Lock::DBLock dbLock(opCtx, dbName, MODE_IX);
                 catalog::forEachCollectionFromDb(
                     opCtx, dbName, MODE_X, [&](const CollectionPtr& collection) {
                         uassert(
diff --git a/src/mongo/db/commands/sleep_command.cpp b/src/mongo/db/commands/sleep_command.cpp
index a62c61a0e40..8a56e807e75 100644
--- a/src/mongo/db/commands/sleep_command.cpp
+++ b/src/mongo/db/commands/sleep_command.cpp
@@ -103,7 +103,7 @@ public:
             dbMode = isSharedLockMode(mode) ? MODE_IS : MODE_IX;
         }
 
-        Lock::DBLock dbLock(opCtx, nss.db(), dbMode, Date_t::max());
+        Lock::DBLock dbLock(opCtx, nss.dbName(), dbMode, Date_t::max());
 
         if (nsIsDbOnly(ns)) {
             LOGV2(6001602,
diff --git a/src/mongo/db/commands/test_commands.cpp b/src/mongo/db/commands/test_commands.cpp
index 4e17908e830..f335d0623a1 100644
--- a/src/mongo/db/commands/test_commands.cpp
+++ b/src/mongo/db/commands/test_commands.cpp
@@ -96,7 +96,9 @@ public:
               "collection"_attr = nss.coll());
         BSONObj obj = cmdObj["obj"].embeddedObjectUserCheck();
 
-        Lock::DBLock lk(opCtx, dbname, MODE_X);
+        // TODO SERVER-66561 Use DatabaseName obj passed in
+        DatabaseName dbName(boost::none, dbname);
+        Lock::DBLock lk(opCtx, dbName, MODE_X);
         OldClientContext ctx(opCtx, nss.ns());
         Database* db = ctx.db();
 
diff --git a/src/mongo/db/concurrency/d_concurrency.cpp b/src/mongo/db/concurrency/d_concurrency.cpp
index 5d77d75d4a5..4a76d9bf6d3 100644
--- a/src/mongo/db/concurrency/d_concurrency.cpp
+++ b/src/mongo/db/concurrency/d_concurrency.cpp
@@ -211,11 +211,14 @@ void Lock::GlobalLock::_unlock() {
 }
 
 Lock::DBLock::DBLock(OperationContext* opCtx,
-                     StringData db,
+                     const DatabaseName& dbName,
                      LockMode mode,
                      Date_t deadline,
                      bool skipGlobalAndRSTLLocks)
-    : _id(RESOURCE_DATABASE, db), _opCtx(opCtx), _result(LOCK_INVALID), _mode(mode) {
+    : _id(RESOURCE_DATABASE, dbName.toStringWithTenantId()),
+      _opCtx(opCtx),
+      _result(LOCK_INVALID),
+      _mode(mode) {
 
     if (!skipGlobalAndRSTLLocks) {
         _globalLock.emplace(opCtx,
@@ -223,7 +226,7 @@ Lock::DBLock::DBLock(OperationContext* opCtx,
                             deadline,
                             InterruptBehavior::kThrow);
     }
-    massert(28539, "need a valid database name", !db.empty() && nsIsDbOnly(db));
+    massert(28539, "need a valid database name", !dbName.db().empty());
 
     _opCtx->lockState()->lock(_opCtx, _id, _mode, deadline);
     _result = LOCK_OK;
diff --git a/src/mongo/db/concurrency/d_concurrency.h b/src/mongo/db/concurrency/d_concurrency.h
index 4e3433d5f6d..df64a741e59 100644
--- a/src/mongo/db/concurrency/d_concurrency.h
+++ b/src/mongo/db/concurrency/d_concurrency.h
@@ -305,7 +305,7 @@ public:
     class DBLock {
     public:
         DBLock(OperationContext* opCtx,
-               StringData db,
+               const DatabaseName& dbName,
                LockMode mode,
                Date_t deadline = Date_t::max(),
                bool skipGlobalAndRSTLLocks = false);
diff --git a/src/mongo/db/concurrency/d_concurrency_bm.cpp b/src/mongo/db/concurrency/d_concurrency_bm.cpp
index 74ae09a9eb6..ecc944d64fa 100644
--- a/src/mongo/db/concurrency/d_concurrency_bm.cpp
+++ b/src/mongo/db/concurrency/d_concurrency_bm.cpp
@@ -137,8 +137,9 @@ BENCHMARK_DEFINE_F(DConcurrencyTest, BM_CollectionIntentSharedLock)(benchmark::S
         makeKClientsWithLockers(state.threads);
     }
 
+    DatabaseName dbName(boost::none, "test");
     for (auto keepRunning : state) {
-        Lock::DBLock dlk(clients[state.thread_index].second.get(), "test", MODE_IS);
+        Lock::DBLock dlk(clients[state.thread_index].second.get(), dbName, MODE_IS);
         Lock::CollectionLock clk(
             clients[state.thread_index].second.get(), NamespaceString("test.coll"), MODE_IS);
     }
@@ -153,8 +154,9 @@ BENCHMARK_DEFINE_F(DConcurrencyTest, BM_CollectionIntentExclusiveLock)(benchmark
         makeKClientsWithLockers(state.threads);
     }
 
+    DatabaseName dbName(boost::none, "test");
     for (auto keepRunning : state) {
-        Lock::DBLock dlk(clients[state.thread_index].second.get(), "test", MODE_IX);
+        Lock::DBLock dlk(clients[state.thread_index].second.get(), dbName, MODE_IX);
         Lock::CollectionLock clk(
             clients[state.thread_index].second.get(), NamespaceString("test.coll"), MODE_IX);
     }
@@ -169,8 +171,9 @@ BENCHMARK_DEFINE_F(DConcurrencyTest, BM_CollectionSharedLock)(benchmark::State&
         makeKClientsWithLockers(state.threads);
     }
 
+    DatabaseName dbName(boost::none, "test");
     for (auto keepRunning : state) {
-        Lock::DBLock dlk(clients[state.thread_index].second.get(), "test", MODE_IS);
+        Lock::DBLock dlk(clients[state.thread_index].second.get(), dbName, MODE_IS);
         Lock::CollectionLock clk(
             clients[state.thread_index].second.get(), NamespaceString("test.coll"), MODE_S);
     }
@@ -185,8 +188,9 @@ BENCHMARK_DEFINE_F(DConcurrencyTest, BM_CollectionExclusiveLock)(benchmark::Stat
         makeKClientsWithLockers(state.threads);
     }
 
+    DatabaseName dbName(boost::none, "test");
     for (auto keepRunning : state) {
-        Lock::DBLock dlk(clients[state.thread_index].second.get(), "test", MODE_IX);
+        Lock::DBLock dlk(clients[state.thread_index].second.get(), dbName, MODE_IX);
         Lock::CollectionLock clk(
             clients[state.thread_index].second.get(), NamespaceString("test.coll"), MODE_X);
     }
diff --git a/src/mongo/db/concurrency/d_concurrency_test.cpp b/src/mongo/db/concurrency/d_concurrency_test.cpp
index 06742ea2bc6..17ad4e01cb8 100644
--- a/src/mongo/db/concurrency/d_concurrency_test.cpp
+++ b/src/mongo/db/concurrency/d_concurrency_test.cpp
@@ -308,7 +308,7 @@ TEST_F(DConcurrencyTestFixture,
     ASSERT_EQ(lockState->getLockMode(resourceIdReplicationStateTransitionLock), MODE_IX);
 
     {
-        Lock::DBLock dbWrite(opCtx.get(), "db", MODE_IX);
+        Lock::DBLock dbWrite(opCtx.get(), DatabaseName(boost::none, "db"), MODE_IX);
         ASSERT(lockState->isW());
         ASSERT(MODE_X == lockState->getLockMode(resourceIdGlobal))
             << "unexpected global lock mode " << modeName(lockState->getLockMode(resourceIdGlobal));
@@ -350,7 +350,7 @@ TEST_F(DConcurrencyTestFixture,
     ASSERT_EQ(lockState->getLockMode(resourceIdReplicationStateTransitionLock), MODE_IX);
 
     {
-        Lock::DBLock dbWrite(opCtx.get(), "db", MODE_IX);
+        Lock::DBLock dbWrite(opCtx.get(), DatabaseName(boost::none, "db"), MODE_IX);
         ASSERT(lockState->isW());
         ASSERT(MODE_X == lockState->getLockMode(resourceIdGlobal))
             << "unexpected global lock mode " << modeName(lockState->getLockMode(resourceIdGlobal));
@@ -389,7 +389,7 @@ TEST_F(DConcurrencyTestFixture,
     ASSERT_EQ(lockState->getLockMode(resourceIdReplicationStateTransitionLock), MODE_IX);
 
     {
-        Lock::DBLock dbWrite(opCtx.get(), "db", MODE_IX);
+        Lock::DBLock dbWrite(opCtx.get(), DatabaseName(boost::none, "db"), MODE_IX);
         ASSERT(lockState->isW());
         ASSERT(MODE_X == lockState->getLockMode(resourceIdGlobal))
             << "unexpected global lock mode " << modeName(lockState->getLockMode(resourceIdGlobal));
@@ -553,7 +553,7 @@ TEST_F(DConcurrencyTestFixture, DBLockXSetsGlobalWriteLockedOnOperationContext)
     ASSERT_FALSE(opCtx->lockState()->wasGlobalLockTakenForWrite());
     ASSERT_FALSE(opCtx->lockState()->wasGlobalLockTaken());
 
-    { Lock::DBLock dbWrite(opCtx, "db", MODE_X); }
+    { Lock::DBLock dbWrite(opCtx, DatabaseName(boost::none, "db"), MODE_X); }
     ASSERT_TRUE(opCtx->lockState()->wasGlobalLockTakenForWrite());
     ASSERT_TRUE(opCtx->lockState()->wasGlobalLockTaken());
 }
@@ -564,7 +564,7 @@ TEST_F(DConcurrencyTestFixture, DBLockSDoesNotSetGlobalWriteLockedOnOperationCon
     ASSERT_FALSE(opCtx->lockState()->wasGlobalLockTakenForWrite());
     ASSERT_FALSE(opCtx->lockState()->wasGlobalLockTaken());
 
-    { Lock::DBLock dbRead(opCtx, "db", MODE_S); }
+    { Lock::DBLock dbRead(opCtx, DatabaseName(boost::none, "db"), MODE_S); }
     ASSERT_FALSE(opCtx->lockState()->wasGlobalLockTakenForWrite());
     ASSERT_TRUE(opCtx->lockState()->wasGlobalLockTaken());
 }
@@ -641,7 +641,7 @@ TEST_F(DConcurrencyTestFixture, DBLockSDoesNotSetGlobalLockTakenInModeConflictin
     auto opCtx = clients[0].second.get();
     ASSERT_FALSE(opCtx->lockState()->wasGlobalLockTakenInModeConflictingWithWrites());
 
-    { Lock::DBLock dbWrite(opCtx, "db", MODE_S); }
+    { Lock::DBLock dbWrite(opCtx, DatabaseName(boost::none, "db"), MODE_S); }
     ASSERT_FALSE(opCtx->lockState()->wasGlobalLockTakenInModeConflictingWithWrites());
 }
 
@@ -650,7 +650,7 @@ TEST_F(DConcurrencyTestFixture, DBLockISDoesNotSetGlobalLockTakenInModeConflicti
     auto opCtx = clients[0].second.get();
     ASSERT_FALSE(opCtx->lockState()->wasGlobalLockTakenInModeConflictingWithWrites());
 
-    { Lock::DBLock dbWrite(opCtx, "db", MODE_IS); }
+    { Lock::DBLock dbWrite(opCtx, DatabaseName(boost::none, "db"), MODE_IS); }
     ASSERT_FALSE(opCtx->lockState()->wasGlobalLockTakenInModeConflictingWithWrites());
 }
 
@@ -659,7 +659,7 @@ TEST_F(DConcurrencyTestFixture, DBLockIXSetsGlobalLockTakenInModeConflictingWith
     auto opCtx = clients[0].second.get();
     ASSERT_FALSE(opCtx->lockState()->wasGlobalLockTakenInModeConflictingWithWrites());
 
-    { Lock::DBLock dbWrite(opCtx, "db", MODE_IX); }
+    { Lock::DBLock dbWrite(opCtx, DatabaseName(boost::none, "db"), MODE_IX); }
     ASSERT_TRUE(opCtx->lockState()->wasGlobalLockTakenInModeConflictingWithWrites());
 }
 
@@ -668,7 +668,7 @@ TEST_F(DConcurrencyTestFixture, DBLockXSetsGlobalLockTakenInModeConflictingWithW
     auto opCtx = clients[0].second.get();
     ASSERT_FALSE(opCtx->lockState()->wasGlobalLockTakenInModeConflictingWithWrites());
 
-    { Lock::DBLock dbRead(opCtx, "db", MODE_X); }
+    { Lock::DBLock dbRead(opCtx, DatabaseName(boost::none, "db"), MODE_X); }
     ASSERT_TRUE(opCtx->lockState()->wasGlobalLockTakenInModeConflictingWithWrites());
 }
 
@@ -993,11 +993,12 @@ TEST_F(DConcurrencyTestFixture, DBLockWaitIsInterruptible) {
 
     // The main thread takes an exclusive lock, causing the spawned thread to wait when it attempts
     // to acquire a conflicting lock.
-    Lock::DBLock dbLock(opCtx1, "db", MODE_X);
+    DatabaseName dbName(boost::none, "db");
+    Lock::DBLock dbLock(opCtx1, dbName, MODE_X);
 
     auto result = runTaskAndKill(opCtx2, [&]() {
         // This lock conflicts with the other DBLock.
-        Lock::DBLock d(opCtx2, "db", MODE_S);
+        Lock::DBLock d(opCtx2, dbName, MODE_S);
     });
 
     ASSERT_THROWS_CODE(result.get(), AssertionException, ErrorCodes::Interrupted);
@@ -1030,15 +1031,17 @@ TEST_F(DConcurrencyTestFixture, DBLockWaitIsNotInterruptibleWithLockGuard) {
 
     // The main thread takes an exclusive lock, causing the spawned thread to wait when it attempts
     // to acquire a conflicting lock.
-    boost::optional<Lock::DBLock> dbLock = Lock::DBLock(opCtx1, "db", MODE_X);
+    boost::optional<Lock::DBLock> dbLock =
+        Lock::DBLock(opCtx1, DatabaseName(boost::none, "db"), MODE_X);
 
     // Killing the lock wait should not interrupt it.
-    auto result = runTaskAndKill(opCtx2,
-                                 [&]() {
-                                     UninterruptibleLockGuard noInterrupt(opCtx2->lockState());
-                                     Lock::DBLock d(opCtx2, "db", MODE_S);
-                                 },
-                                 [&] { dbLock.reset(); });
+    auto result =
+        runTaskAndKill(opCtx2,
+                       [&]() {
+                           UninterruptibleLockGuard noInterrupt(opCtx2->lockState());
+                           Lock::DBLock d(opCtx2, DatabaseName(boost::none, "db"), MODE_S);
+                       },
+                       [&] { dbLock.reset(); });
     // Should not throw an exception.
     result.get();
 }
@@ -1074,7 +1077,7 @@ TEST_F(DConcurrencyTestFixture, LockCompleteInterruptedWhenUncontested) {
 TEST_F(DConcurrencyTestFixture, DBLockTakesS) {
     auto opCtx = makeOperationContext();
     getClient()->swapLockState(std::make_unique<LockerImpl>(opCtx->getServiceContext()));
-    Lock::DBLock dbRead(opCtx.get(), "db", MODE_S);
+    Lock::DBLock dbRead(opCtx.get(), DatabaseName(boost::none, "db"), MODE_S);
 
     const ResourceId resIdDb(RESOURCE_DATABASE, std::string("db"));
     ASSERT(opCtx->lockState()->getLockMode(resIdDb) == MODE_S);
@@ -1083,7 +1086,7 @@ TEST_F(DConcurrencyTestFixture, DBLockTakesS) {
 TEST_F(DConcurrencyTestFixture, DBLockTakesX) {
     auto opCtx = makeOperationContext();
     getClient()->swapLockState(std::make_unique<LockerImpl>(opCtx->getServiceContext()));
-    Lock::DBLock dbWrite(opCtx.get(), "db", MODE_X);
+    Lock::DBLock dbWrite(opCtx.get(), DatabaseName(boost::none, "db"), MODE_X);
 
     const ResourceId resIdDb(RESOURCE_DATABASE, std::string("db"));
     ASSERT(opCtx->lockState()->getLockMode(resIdDb) == MODE_X);
@@ -1092,7 +1095,7 @@ TEST_F(DConcurrencyTestFixture, DBLockTakesX) {
 TEST_F(DConcurrencyTestFixture, DBLockTakesISForAdminIS) {
     auto opCtx = makeOperationContext();
     getClient()->swapLockState(std::make_unique<LockerImpl>(opCtx->getServiceContext()));
-    Lock::DBLock dbRead(opCtx.get(), "admin", MODE_IS);
+    Lock::DBLock dbRead(opCtx.get(), DatabaseName(boost::none, "admin"), MODE_IS);
 
     ASSERT(opCtx->lockState()->getLockMode(resourceIdAdminDB) == MODE_IS);
 }
@@ -1100,7 +1103,7 @@ TEST_F(DConcurrencyTestFixture, DBLockTakesISForAdminIS) {
 TEST_F(DConcurrencyTestFixture, DBLockTakesSForAdminS) {
     auto opCtx = makeOperationContext();
     getClient()->swapLockState(std::make_unique<LockerImpl>(opCtx->getServiceContext()));
-    Lock::DBLock dbRead(opCtx.get(), "admin", MODE_S);
+    Lock::DBLock dbRead(opCtx.get(), DatabaseName(boost::none, "admin"), MODE_S);
 
     ASSERT(opCtx->lockState()->getLockMode(resourceIdAdminDB) == MODE_S);
 }
@@ -1108,7 +1111,7 @@ TEST_F(DConcurrencyTestFixture, DBLockTakesSForAdminS) {
 TEST_F(DConcurrencyTestFixture, DBLockTakesIXForAdminIX) {
     auto opCtx = makeOperationContext();
     getClient()->swapLockState(std::make_unique<LockerImpl>(opCtx->getServiceContext()));
-    Lock::DBLock dbWrite(opCtx.get(), "admin", MODE_IX);
+    Lock::DBLock dbWrite(opCtx.get(), DatabaseName(boost::none, "admin"), MODE_IX);
 
     ASSERT(opCtx->lockState()->getLockMode(resourceIdAdminDB) == MODE_IX);
 }
@@ -1116,7 +1119,7 @@ TEST_F(DConcurrencyTestFixture, DBLockTakesIXForAdminIX) {
 TEST_F(DConcurrencyTestFixture, DBLockTakesXForAdminX) {
     auto opCtx = makeOperationContext();
     getClient()->swapLockState(std::make_unique<LockerImpl>(opCtx->getServiceContext()));
-    Lock::DBLock dbWrite(opCtx.get(), "admin", MODE_X);
+    Lock::DBLock dbWrite(opCtx.get(), DatabaseName(boost::none, "admin"), MODE_X);
 
     ASSERT(opCtx->lockState()->getLockMode(resourceIdAdminDB) == MODE_X);
 }
@@ -1124,8 +1127,9 @@ TEST_F(DConcurrencyTestFixture, DBLockTakesXForAdminX) {
 TEST_F(DConcurrencyTestFixture, MultipleWriteDBLocksOnSameThread) {
     auto opCtx = makeOperationContext();
     getClient()->swapLockState(std::make_unique<LockerImpl>(opCtx->getServiceContext()));
-    Lock::DBLock r1(opCtx.get(), "db1", MODE_X);
-    Lock::DBLock r2(opCtx.get(), "db1", MODE_X);
+    DatabaseName dbName(boost::none, "db1");
+    Lock::DBLock r1(opCtx.get(), dbName, MODE_X);
+    Lock::DBLock r2(opCtx.get(), dbName, MODE_X);
 
     ASSERT(opCtx->lockState()->isDbLockedForMode("db1", MODE_X));
 }
@@ -1134,8 +1138,9 @@ TEST_F(DConcurrencyTestFixture, MultipleConflictingDBLocksOnSameThread) {
     auto opCtx = makeOperationContext();
     getClient()->swapLockState(std::make_unique<LockerImpl>(opCtx->getServiceContext()));
     auto lockState = opCtx->lockState();
-    Lock::DBLock r1(opCtx.get(), "db1", MODE_X);
-    Lock::DBLock r2(opCtx.get(), "db1", MODE_S);
+    DatabaseName dbName(boost::none, "db1");
+    Lock::DBLock r1(opCtx.get(), dbName, MODE_X);
+    Lock::DBLock r2(opCtx.get(), dbName, MODE_S);
 
     ASSERT(lockState->isDbLockedForMode("db1", MODE_X));
     ASSERT(lockState->isDbLockedForMode("db1", MODE_S));
@@ -1147,7 +1152,7 @@ TEST_F(DConcurrencyTestFixture, IsDbLockedForSMode) {
     auto opCtx = makeOperationContext();
     getClient()->swapLockState(std::make_unique<LockerImpl>(opCtx->getServiceContext()));
     auto lockState = opCtx->lockState();
-    Lock::DBLock dbLock(opCtx.get(), dbName, MODE_S);
+    Lock::DBLock dbLock(opCtx.get(), DatabaseName(boost::none, "db"), MODE_S);
 
     ASSERT(lockState->isDbLockedForMode(dbName, MODE_IS));
     ASSERT(!lockState->isDbLockedForMode(dbName, MODE_IX));
@@ -1161,7 +1166,7 @@ TEST_F(DConcurrencyTestFixture, IsDbLockedForXMode) {
     auto opCtx = makeOperationContext();
     getClient()->swapLockState(std::make_unique<LockerImpl>(opCtx->getServiceContext()));
     auto lockState = opCtx->lockState();
-    Lock::DBLock dbLock(opCtx.get(), dbName, MODE_X);
+    Lock::DBLock dbLock(opCtx.get(), DatabaseName(boost::none, "db"), MODE_X);
 
     ASSERT(lockState->isDbLockedForMode(dbName, MODE_IS));
     ASSERT(lockState->isDbLockedForMode(dbName, MODE_IX));
@@ -1176,7 +1181,7 @@ TEST_F(DConcurrencyTestFixture, IsCollectionLocked_DB_Locked_IS) {
     getClient()->swapLockState(std::make_unique<LockerImpl>(opCtx->getServiceContext()));
     auto lockState = opCtx->lockState();
 
-    Lock::DBLock dbLock(opCtx.get(), "db1", MODE_IS);
+    Lock::DBLock dbLock(opCtx.get(), ns.dbName(), MODE_IS);
 
     {
         Lock::CollectionLock collLock(opCtx.get(), ns, MODE_IS);
@@ -1204,7 +1209,7 @@ TEST_F(DConcurrencyTestFixture, IsCollectionLocked_DB_Locked_IX) {
     getClient()->swapLockState(std::make_unique<LockerImpl>(opCtx->getServiceContext()));
     auto lockState = opCtx->lockState();
 
-    Lock::DBLock dbLock(opCtx.get(), "db1", MODE_IX);
+    Lock::DBLock dbLock(opCtx.get(), ns.dbName(), MODE_IX);
 
     {
         Lock::CollectionLock collLock(opCtx.get(), ns, MODE_IX);
@@ -1266,56 +1271,110 @@ TEST_F(DConcurrencyTestFixture, Stress) {
                     Lock::GlobalRead r2(clients[threadId].second.get());
                     ASSERT(clients[threadId].second->lockState()->isReadLocked());
                 } else if (i % 7 == 5) {
-                    { Lock::DBLock r(clients[threadId].second.get(), "foo", MODE_S); }
-                    { Lock::DBLock r(clients[threadId].second.get(), "bar", MODE_S); }
+                    {
+                        Lock::DBLock r(clients[threadId].second.get(),
+                                       DatabaseName(boost::none, "foo"),
+                                       MODE_S);
+                    }
+                    {
+                        Lock::DBLock r(clients[threadId].second.get(),
+                                       DatabaseName(boost::none, "bar"),
+                                       MODE_S);
+                    }
                 } else if (i % 7 == 6) {
                     if (i > kNumIterations / 2) {
                         int q = i % 11;
 
                         if (q == 0) {
-                            Lock::DBLock r(clients[threadId].second.get(), "foo", MODE_S);
+                            Lock::DBLock r(clients[threadId].second.get(),
+                                           DatabaseName(boost::none, "foo"),
+                                           MODE_S);
                             ASSERT(clients[threadId].second->lockState()->isDbLockedForMode(
                                 "foo", MODE_S));
 
-                            Lock::DBLock r2(clients[threadId].second.get(), "foo", MODE_S);
+                            Lock::DBLock r2(clients[threadId].second.get(),
+                                            DatabaseName(boost::none, "foo"),
+                                            MODE_S);
                             ASSERT(clients[threadId].second->lockState()->isDbLockedForMode(
                                 "foo", MODE_S));
 
-                            Lock::DBLock r3(clients[threadId].second.get(), "local", MODE_S);
+                            Lock::DBLock r3(clients[threadId].second.get(),
+                                            DatabaseName(boost::none, "local"),
+                                            MODE_S);
                             ASSERT(clients[threadId].second->lockState()->isDbLockedForMode(
                                 "foo", MODE_S));
                             ASSERT(clients[threadId].second->lockState()->isDbLockedForMode(
                                 "local", MODE_S));
                         } else if (q == 1) {
                             // test locking local only -- with no preceding lock
-                            { Lock::DBLock x(clients[threadId].second.get(), "local", MODE_S); }
+                            {
+                                Lock::DBLock x(clients[threadId].second.get(),
+                                               DatabaseName(boost::none, "local"),
+                                               MODE_S);
+                            }
 
-                            Lock::DBLock x(clients[threadId].second.get(), "local", MODE_X);
+                            Lock::DBLock x(clients[threadId].second.get(),
+                                           DatabaseName(boost::none, "local"),
+                                           MODE_X);
 
                         } else if (q == 2) {
-                            { Lock::DBLock x(clients[threadId].second.get(), "admin", MODE_S); }
-                            { Lock::DBLock x(clients[threadId].second.get(), "admin", MODE_X); }
+                            {
+                                Lock::DBLock x(clients[threadId].second.get(),
+                                               DatabaseName(boost::none, "admin"),
+                                               MODE_S);
+                            }
+                            {
+                                Lock::DBLock x(clients[threadId].second.get(),
+                                               DatabaseName(boost::none, "admin"),
+                                               MODE_X);
+                            }
                         } else if (q == 3) {
-                            Lock::DBLock x(clients[threadId].second.get(), "foo", MODE_X);
-                            Lock::DBLock y(clients[threadId].second.get(), "admin", MODE_S);
+                            Lock::DBLock x(clients[threadId].second.get(),
+                                           DatabaseName(boost::none, "foo"),
+                                           MODE_X);
+                            Lock::DBLock y(clients[threadId].second.get(),
+                                           DatabaseName(boost::none, "admin"),
+                                           MODE_S);
                         } else if (q == 4) {
-                            Lock::DBLock x(clients[threadId].second.get(), "foo2", MODE_S);
-                            Lock::DBLock y(clients[threadId].second.get(), "admin", MODE_S);
+                            Lock::DBLock x(clients[threadId].second.get(),
+                                           DatabaseName(boost::none, "foo2"),
+                                           MODE_S);
+                            Lock::DBLock y(clients[threadId].second.get(),
+                                           DatabaseName(boost::none, "admin"),
+                                           MODE_S);
                         } else if (q == 5) {
-                            Lock::DBLock x(clients[threadId].second.get(), "foo", MODE_IS);
+                            Lock::DBLock x(clients[threadId].second.get(),
+                                           DatabaseName(boost::none, "foo"),
+                                           MODE_IS);
                         } else if (q == 6) {
-                            Lock::DBLock x(clients[threadId].second.get(), "foo", MODE_IX);
-                            Lock::DBLock y(clients[threadId].second.get(), "local", MODE_IX);
+                            Lock::DBLock x(clients[threadId].second.get(),
+                                           DatabaseName(boost::none, "foo"),
+                                           MODE_IX);
+                            Lock::DBLock y(clients[threadId].second.get(),
+                                           DatabaseName(boost::none, "local"),
+                                           MODE_IX);
                         } else {
-                            Lock::DBLock w(clients[threadId].second.get(), "foo", MODE_X);
-
-                            Lock::DBLock r2(clients[threadId].second.get(), "foo", MODE_S);
-                            Lock::DBLock r3(clients[threadId].second.get(), "local", MODE_S);
+                            Lock::DBLock w(clients[threadId].second.get(),
+                                           DatabaseName(boost::none, "foo"),
+                                           MODE_X);
+
+                            Lock::DBLock r2(clients[threadId].second.get(),
+                                            DatabaseName(boost::none, "foo"),
+                                            MODE_S);
+                            Lock::DBLock r3(clients[threadId].second.get(),
+                                            DatabaseName(boost::none, "local"),
+                                            MODE_S);
                         }
                     } else {
-                        Lock::DBLock r(clients[threadId].second.get(), "foo", MODE_S);
-                        Lock::DBLock r2(clients[threadId].second.get(), "foo", MODE_S);
-                        Lock::DBLock r3(clients[threadId].second.get(), "local", MODE_S);
+                        Lock::DBLock r(clients[threadId].second.get(),
+                                       DatabaseName(boost::none, "foo"),
+                                       MODE_S);
+                        Lock::DBLock r2(clients[threadId].second.get(),
+                                        DatabaseName(boost::none, "foo"),
+                                        MODE_S);
+                        Lock::DBLock r3(clients[threadId].second.get(),
+                                        DatabaseName(boost::none, "local"),
+                                        MODE_S);
                     }
                 }
 
@@ -1364,10 +1423,14 @@ TEST_F(DConcurrencyTestFixture, StressPartitioned) {
                 }
 
                 if (i % 2 == 0) {
-                    Lock::DBLock x(clients[threadId].second.get(), "foo", MODE_IS);
+                    Lock::DBLock x(
+                        clients[threadId].second.get(), DatabaseName(boost::none, "foo"), MODE_IS);
                 } else {
-                    Lock::DBLock x(clients[threadId].second.get(), "foo", MODE_IX);
-                    Lock::DBLock y(clients[threadId].second.get(), "local", MODE_IX);
+                    Lock::DBLock x(
+                        clients[threadId].second.get(), DatabaseName(boost::none, "foo"), MODE_IX);
+                    Lock::DBLock y(clients[threadId].second.get(),
+                                   DatabaseName(boost::none, "local"),
+                                   MODE_IX);
                 }
 
                 if (threadId == kMaxStressThreads - 1)
@@ -1656,23 +1719,25 @@ TEST_F(DConcurrencyTestFixture, DBLockInInterruptedContextThrowsEvenWhenUncontes
     opCtx->markKilled();
 
     boost::optional<Lock::DBLock> dbWriteLock;
-    ASSERT_THROWS_CODE(
-        dbWriteLock.emplace(opCtx, "db", MODE_IX), AssertionException, ErrorCodes::Interrupted);
+    ASSERT_THROWS_CODE(dbWriteLock.emplace(opCtx, DatabaseName(boost::none, "db"), MODE_IX),
+                       AssertionException,
+                       ErrorCodes::Interrupted);
 }
 
 TEST_F(DConcurrencyTestFixture, DBLockInInterruptedContextThrowsEvenWhenAcquiringRecursively) {
     auto clients = makeKClientsWithLockers(1);
     auto opCtx = clients[0].second.get();
 
-    Lock::DBLock dbWriteLock(opCtx, "db", MODE_X);
+    Lock::DBLock dbWriteLock(opCtx, DatabaseName(boost::none, "db"), MODE_X);
 
     opCtx->markKilled();
 
     {
         boost::optional<Lock::DBLock> recursiveDBWriteLock;
-        ASSERT_THROWS_CODE(recursiveDBWriteLock.emplace(opCtx, "db", MODE_X),
-                           AssertionException,
-                           ErrorCodes::Interrupted);
+        ASSERT_THROWS_CODE(
+            recursiveDBWriteLock.emplace(opCtx, DatabaseName(boost::none, "db"), MODE_X),
+            AssertionException,
+            ErrorCodes::Interrupted);
     }
 }
 
@@ -1683,7 +1748,7 @@ TEST_F(DConcurrencyTestFixture, DBLockInInterruptedContextRespectsUninterruptibl
     opCtx->markKilled();
 
     UninterruptibleLockGuard noInterrupt(opCtx->lockState());
-    Lock::DBLock dbWriteLock(opCtx, "db", MODE_X);  // Does not throw.
+    Lock::DBLock dbWriteLock(opCtx, DatabaseName(boost::none, "db"), MODE_X);  // Does not throw.
 }
 
 TEST_F(DConcurrencyTestFixture, DBLockTimeout) {
@@ -1693,14 +1758,16 @@ TEST_F(DConcurrencyTestFixture, DBLockTimeout) {
 
     const Milliseconds timeoutMillis = Milliseconds(1500);
 
-    Lock::DBLock L1(opctx1, "testdb"_sd, MODE_X, Date_t::max());
+    Lock::DBLock L1(opctx1, DatabaseName(boost::none, "testdb"), MODE_X, Date_t::max());
     ASSERT(opctx1->lockState()->isDbLockedForMode("testdb"_sd, MODE_X));
     ASSERT(L1.isLocked());
 
     Date_t t1 = Date_t::now();
-    ASSERT_THROWS_CODE(Lock::DBLock(opctx2, "testdb"_sd, MODE_X, Date_t::now() + timeoutMillis),
-                       AssertionException,
-                       ErrorCodes::LockTimeout);
+    ASSERT_THROWS_CODE(
+        Lock::DBLock(
+            opctx2, DatabaseName(boost::none, "testdb"), MODE_X, Date_t::now() + timeoutMillis),
+        AssertionException,
+        ErrorCodes::LockTimeout);
     Date_t t2 = Date_t::now();
     ASSERT_GTE(t2 - t1 + kMaxClockJitterMillis, Milliseconds(timeoutMillis));
 }
@@ -1716,9 +1783,11 @@ TEST_F(DConcurrencyTestFixture, DBLockTimeoutDueToGlobalLock) {
     ASSERT(G1.isLocked());
 
     Date_t t1 = Date_t::now();
-    ASSERT_THROWS_CODE(Lock::DBLock(opctx2, "testdb"_sd, MODE_X, Date_t::now() + timeoutMillis),
-                       AssertionException,
-                       ErrorCodes::LockTimeout);
+    ASSERT_THROWS_CODE(
+        Lock::DBLock(
+            opctx2, DatabaseName(boost::none, "testdb"), MODE_X, Date_t::now() + timeoutMillis),
+        AssertionException,
+        ErrorCodes::LockTimeout);
     Date_t t2 = Date_t::now();
     ASSERT_GTE(t2 - t1 + kMaxClockJitterMillis, Milliseconds(timeoutMillis));
 }
@@ -1727,7 +1796,7 @@ TEST_F(DConcurrencyTestFixture, CollectionLockInInterruptedContextThrowsEvenWhen
     auto clients = makeKClientsWithLockers(1);
     auto opCtx = clients[0].second.get();
 
-    Lock::DBLock dbLock(opCtx, "db", MODE_IX);
+    Lock::DBLock dbLock(opCtx, DatabaseName(boost::none, "db"), MODE_IX);
     opCtx->markKilled();
 
     {
@@ -1743,7 +1812,7 @@ TEST_F(DConcurrencyTestFixture,
     auto clients = makeKClientsWithLockers(1);
     auto opCtx = clients[0].second.get();
 
-    Lock::DBLock dbLock(opCtx, "db", MODE_IX);
+    Lock::DBLock dbLock(opCtx, DatabaseName(boost::none, "db"), MODE_IX);
     Lock::CollectionLock collLock(opCtx, NamespaceString("db.coll"), MODE_IX);
 
     opCtx->markKilled();
@@ -1760,7 +1829,7 @@ TEST_F(DConcurrencyTestFixture, CollectionLockInInterruptedContextRespectsUninte
     auto clients = makeKClientsWithLockers(1);
     auto opCtx = clients[0].second.get();
 
-    Lock::DBLock dbLock(opCtx, "db", MODE_IX);
+    Lock::DBLock dbLock(opCtx, DatabaseName(boost::none, "db"), MODE_IX);
 
     opCtx->markKilled();
 
@@ -1775,13 +1844,13 @@ TEST_F(DConcurrencyTestFixture, CollectionLockTimeout) {
 
     const Milliseconds timeoutMillis = Milliseconds(1500);
 
-    Lock::DBLock DBL1(opctx1, "testdb"_sd, MODE_IX, Date_t::max());
+    Lock::DBLock DBL1(opctx1, DatabaseName(boost::none, "testdb"), MODE_IX, Date_t::max());
     ASSERT(opctx1->lockState()->isDbLockedForMode("testdb"_sd, MODE_IX));
     Lock::CollectionLock CL1(opctx1, NamespaceString("testdb.test"), MODE_X, Date_t::max());
     ASSERT(opctx1->lockState()->isCollectionLockedForMode(NamespaceString("testdb.test"), MODE_X));
 
     Date_t t1 = Date_t::now();
-    Lock::DBLock DBL2(opctx2, "testdb"_sd, MODE_IX, Date_t::max());
+    Lock::DBLock DBL2(opctx2, DatabaseName(boost::none, "testdb"), MODE_IX, Date_t::max());
     ASSERT(opctx2->lockState()->isDbLockedForMode("testdb"_sd, MODE_IX));
     ASSERT_THROWS_CODE(
         Lock::CollectionLock(
@@ -2305,5 +2374,39 @@ TEST_F(DConcurrencyTestFixture, PBWMRespectsMaxTimeMS) {
         pbwm2.lock(opCtx2, MODE_X), AssertionException, ErrorCodes::ExceededTimeLimit);
 }
 
+TEST_F(DConcurrencyTestFixture, DifferentTenantsTakeDBLockOnConflictingNamespaceOk) {
+    auto clients = makeKClientsWithLockers(2);
+    auto opCtx1 = clients[0].second.get();
+    auto opCtx2 = clients[1].second.get();
+
+    auto db = "db1";
+    auto tenant1 = TenantId(OID::gen());
+    auto tenant2 = TenantId(OID::gen());
+
+    DatabaseName dbName1(tenant1, db);
+    DatabaseName dbName2(tenant2, db);
+
+    Lock::DBLock r1(opCtx1, dbName1, MODE_X);
+    Lock::DBLock r2(opCtx2, dbName2, MODE_X);
+
+    ASSERT(opCtx1->lockState()->isDbLockedForMode(dbName1.toStringWithTenantId(), MODE_X));
+    ASSERT(opCtx2->lockState()->isDbLockedForMode(dbName2.toStringWithTenantId(), MODE_X));
+}
+
+TEST_F(DConcurrencyTestFixture, ConflictingTenantDBLockThrows) {
+    auto clients = makeKClientsWithLockers(2);
+    auto opCtx1 = clients[0].second.get();
+    auto opCtx2 = clients[1].second.get();
+
+    auto db = "db1";
+    DatabaseName dbName1(TenantId(OID::gen()), db);
+
+    Lock::DBLock r1(opCtx1, dbName1, MODE_X);
+
+    auto result = runTaskAndKill(opCtx2, [&]() { Lock::DBLock r2(opCtx2, dbName1, MODE_S); });
+
+    ASSERT_THROWS_CODE(result.get(), AssertionException, ErrorCodes::Interrupted);
+}
+
 }  // namespace
 }  // namespace mongo
diff --git a/src/mongo/db/db_raii_test.cpp b/src/mongo/db/db_raii_test.cpp
index 905cba46446..4a8e8f8f361 100644
--- a/src/mongo/db/db_raii_test.cpp
+++ b/src/mongo/db/db_raii_test.cpp
@@ -114,7 +114,7 @@ void failsWithLockTimeout(std::function<void()> func, Milliseconds timeoutMillis
 }
 
 TEST_F(DBRAIITestFixture, AutoGetCollectionForReadCollLockDeadline) {
-    Lock::DBLock dbLock1(client1.second.get(), nss.db(), MODE_IX);
+    Lock::DBLock dbLock1(client1.second.get(), nss.dbName(), MODE_IX);
     ASSERT(client1.second->lockState()->isDbLockedForMode(nss.db(), MODE_IX));
     Lock::CollectionLock collLock1(client1.second.get(), nss, MODE_X);
     ASSERT(client1.second->lockState()->isCollectionLockedForMode(nss, MODE_X));
@@ -129,7 +129,7 @@ TEST_F(DBRAIITestFixture, AutoGetCollectionForReadCollLockDeadline) {
 }
 
 TEST_F(DBRAIITestFixture, AutoGetCollectionForReadDBLockDeadline) {
-    Lock::DBLock dbLock1(client1.second.get(), nss.db(), MODE_X);
+    Lock::DBLock dbLock1(client1.second.get(), nss.dbName(), MODE_X);
     ASSERT(client1.second->lockState()->isDbLockedForMode(nss.db(), MODE_X));
     failsWithLockTimeout(
         [&] {
@@ -155,7 +155,7 @@ TEST_F(DBRAIITestFixture, AutoGetCollectionForReadGlobalLockDeadline) {
 }
 
 TEST_F(DBRAIITestFixture, AutoGetCollectionForReadDeadlineNow) {
-    Lock::DBLock dbLock1(client1.second.get(), nss.db(), MODE_IX);
+    Lock::DBLock dbLock1(client1.second.get(), nss.dbName(), MODE_IX);
     ASSERT(client1.second->lockState()->isDbLockedForMode(nss.db(), MODE_IX));
     Lock::CollectionLock collLock1(client1.second.get(), nss, MODE_X);
     ASSERT(client1.second->lockState()->isCollectionLockedForMode(nss, MODE_X));
@@ -171,7 +171,7 @@ TEST_F(DBRAIITestFixture, AutoGetCollectionForReadDeadlineNow) {
 }
 
 TEST_F(DBRAIITestFixture, AutoGetCollectionForReadDeadlineMin) {
-    Lock::DBLock dbLock1(client1.second.get(), nss.db(), MODE_IX);
+    Lock::DBLock dbLock1(client1.second.get(), nss.dbName(), MODE_IX);
     ASSERT(client1.second->lockState()->isDbLockedForMode(nss.db(), MODE_IX));
     Lock::CollectionLock collLock1(client1.second.get(), nss, MODE_X);
     ASSERT(client1.second->lockState()->isCollectionLockedForMode(nss, MODE_X));
@@ -185,7 +185,7 @@ TEST_F(DBRAIITestFixture, AutoGetCollectionForReadDeadlineMin) {
 }
 
 TEST_F(DBRAIITestFixture, AutoGetCollectionForReadDBLockCompatibleXNoCollection) {
-    Lock::DBLock dbLock1(client1.second.get(), nss.db(), MODE_IX);
+    Lock::DBLock dbLock1(client1.second.get(), nss.dbName(), MODE_IX);
     ASSERT(client1.second->lockState()->isDbLockedForMode(nss.db(), MODE_IX));
 
     AutoGetCollectionForRead coll(client2.second.get(), nss);
@@ -196,7 +196,7 @@ TEST_F(DBRAIITestFixture, AutoGetCollectionForReadDBLockCompatibleXCollectionExi
     ASSERT_OK(
         storageInterface()->createCollection(client1.second.get(), nss, defaultCollectionOptions));
 
-    Lock::DBLock dbLock1(client1.second.get(), nss.db(), MODE_IX);
+    Lock::DBLock dbLock1(client1.second.get(), nss.dbName(), MODE_IX);
     ASSERT(client1.second->lockState()->isDbLockedForMode(nss.db(), MODE_IX));
 
     AutoGetCollectionForRead coll(client2.second.get(), nss);
@@ -207,7 +207,7 @@ TEST_F(DBRAIITestFixture, AutoGetCollectionForReadDBLockCompatibleXCollectionExi
     ASSERT_OK(
         storageInterface()->createCollection(client1.second.get(), nss, defaultCollectionOptions));
 
-    Lock::DBLock dbLock1(client1.second.get(), nss.db(), MODE_IX);
+    Lock::DBLock dbLock1(client1.second.get(), nss.dbName(), MODE_IX);
     ASSERT(client1.second->lockState()->isDbLockedForMode(nss.db(), MODE_IX));
     auto opCtx = client2.second.get();
     opCtx->recoveryUnit()->setTimestampReadSource(RecoveryUnit::ReadSource::kProvided,
@@ -224,7 +224,7 @@ TEST_F(DBRAIITestFixture,
         storageInterface()->createCollection(client1.second.get(), nss, defaultCollectionOptions));
     ASSERT_OK(repl::ReplicationCoordinator::get(client1.second.get())
                   ->setFollowerMode(repl::MemberState::RS_SECONDARY));
-    Lock::DBLock dbLock1(client1.second.get(), nss.db(), MODE_IX);
+    Lock::DBLock dbLock1(client1.second.get(), nss.dbName(), MODE_IX);
     ASSERT(client1.second->lockState()->isDbLockedForMode(nss.db(), MODE_IX));
 
     // Simulate using a DBDirectClient to test this behavior for user reads.
@@ -245,7 +245,7 @@ TEST_F(DBRAIITestFixture,
     auto snapshotManager =
         client1.second.get()->getServiceContext()->getStorageEngine()->getSnapshotManager();
     snapshotManager->setLastApplied(replCoord->getMyLastAppliedOpTime().getTimestamp());
-    Lock::DBLock dbLock1(client1.second.get(), nss.db(), MODE_IX);
+    Lock::DBLock dbLock1(client1.second.get(), nss.dbName(), MODE_IX);
     ASSERT(client1.second->lockState()->isDbLockedForMode(nss.db(), MODE_IX));
 
     // Simulate using a DBDirectClient to test this behavior for user reads.
@@ -274,7 +274,7 @@ TEST_F(DBRAIITestFixture,
         client1.second.get()->getServiceContext()->getStorageEngine()->getSnapshotManager();
     snapshotManager->setLastApplied(opTime.getTimestamp());
 
-    Lock::DBLock dbLock1(client1.second.get(), nss.db(), MODE_IX);
+    Lock::DBLock dbLock1(client1.second.get(), nss.dbName(), MODE_IX);
     ASSERT(client1.second->lockState()->isDbLockedForMode(nss.db(), MODE_IX));
 
     // Simulate using a DBDirectClient to test this behavior for user reads.
diff --git a/src/mongo/db/free_mon/free_mon_storage_test.cpp b/src/mongo/db/free_mon/free_mon_storage_test.cpp
index 06906389cdd..bdd6db0bf52 100644
--- a/src/mongo/db/free_mon/free_mon_storage_test.cpp
+++ b/src/mongo/db/free_mon/free_mon_storage_test.cpp
@@ -233,7 +233,7 @@ TEST_F(FreeMonStorageTest, TestSecondary) {
 void insertDoc(OperationContext* optCtx, const NamespaceString nss, StringData id) {
     auto storageInterface = repl::StorageInterface::get(optCtx);
 
-    Lock::DBLock dblk(optCtx, nss.db(), MODE_IX);
+    Lock::DBLock dblk(optCtx, nss.dbName(), MODE_IX);
     Lock::CollectionLock lk(optCtx, nss, MODE_IX);
 
     BSONObj fakeDoc = BSON("_id" << id);
diff --git a/src/mongo/db/index_builds_coordinator.cpp b/src/mongo/db/index_builds_coordinator.cpp
index 5b954baa536..d3cca2a6349 100644
--- a/src/mongo/db/index_builds_coordinator.cpp
+++ b/src/mongo/db/index_builds_coordinator.cpp
@@ -663,7 +663,9 @@ Status IndexBuildsCoordinator::_setUpResumeIndexBuild(OperationContext* opCtx,
         return {ErrorCodes::FailPointEnabled, "failSetUpResumeIndexBuild fail point is enabled"};
     }
 
-    Lock::DBLock dbLock(opCtx, dbName, MODE_IX);
+    // TODO SERVER-67439 Use dbName directly
+    DatabaseName databaseName(boost::none, dbName);
+    Lock::DBLock dbLock(opCtx, databaseName, MODE_IX);
     Lock::CollectionLock collLock(opCtx, nssOrUuid, MODE_X);
 
     CollectionWriter collection(opCtx, resumeInfo.getCollectionUUID());
@@ -1239,7 +1241,10 @@ bool IndexBuildsCoordinator::abortIndexBuildByBuildUUID(OperationContext* opCtx,
         LOGV2(4656010, "Attempting to abort index build", "buildUUID"_attr = replState->buildUUID);
 
         const NamespaceStringOrUUID dbAndUUID(replState->dbName, replState->collectionUUID);
-        Lock::DBLock dbLock(opCtx, replState->dbName, MODE_IX);
+        // TODO SERVER-67437 Once ReplIndexBuildState holds DatabaseName, use dbName directly for
+        // lock
+        DatabaseName dbName(boost::none, replState->dbName);
+        Lock::DBLock dbLock(opCtx, dbName, MODE_IX);
 
         if (IndexBuildProtocol::kSinglePhase == replState->protocol) {
             // Unlock RSTL to avoid deadlocks with prepare conflicts and state transitions caused by
@@ -1878,7 +1883,10 @@ Status IndexBuildsCoordinator::_setUpIndexBuildForTwoPhaseRecovery(
 
     // Don't use the AutoGet helpers because they require an open database, which may not be the
     // case when an index builds is restarted during recovery.
-    Lock::DBLock dbLock(opCtx, dbName, MODE_IX);
+
+    // TODO SERVER-67439 Use dbName directly
+    DatabaseName databaseName(boost::none, dbName);
+    Lock::DBLock dbLock(opCtx, databaseName, MODE_IX);
     Lock::CollectionLock collLock(opCtx, nssOrUuid, MODE_X);
     auto collection = CollectionCatalog::get(opCtx)->lookupCollectionByUUID(opCtx, collectionUUID);
     invariant(collection);
@@ -2225,7 +2233,10 @@ void IndexBuildsCoordinator::_cleanUpSinglePhaseAfterFailure(
     runOnAlternateContext(
         opCtx, "self-abort", [this, replState, status](OperationContext* abortCtx) {
             ShouldNotConflictWithSecondaryBatchApplicationBlock noConflict(abortCtx->lockState());
-            Lock::DBLock dbLock(abortCtx, replState->dbName, MODE_IX);
+            // TODO SERVER-67437 Once ReplIndexBuildState holds DatabaseName, use dbName directly
+            // for lock
+            DatabaseName dbName(boost::none, replState->dbName);
+            Lock::DBLock dbLock(abortCtx, dbName, MODE_IX);
 
             // Unlock RSTL to avoid deadlocks with prepare conflicts and state transitions caused by
             // taking a strong collection lock. See SERVER-42621.
@@ -2259,7 +2270,10 @@ void IndexBuildsCoordinator::_cleanUpTwoPhaseAfterFailure(
 
             // Take RSTL (implicitly by DBLock) to observe and prevent replication state from
             // changing.
-            Lock::DBLock dbLock(abortCtx, replState->dbName, MODE_IX);
+            // TODO SSERVER-67437 Once ReplIndexBuildState holds DatabaseName, use dbName directly
+            // for lock
+            DatabaseName dbName(boost::none, replState->dbName);
+            Lock::DBLock dbLock(abortCtx, dbName, MODE_IX);
 
             // Index builds may not fail on secondaries. If a primary replicated an abortIndexBuild
             // oplog entry, then this index build would have received an IndexBuildAborted error
@@ -2535,7 +2549,10 @@ void IndexBuildsCoordinator::_scanCollectionAndInsertSortedKeysIntoIndex(
         // if it waited.
         _awaitLastOpTimeBeforeInterceptorsMajorityCommitted(opCtx, replState);
 
-        Lock::DBLock autoDb(opCtx, replState->dbName, MODE_IX);
+        // TODO SERVER-67437 Once ReplIndexBuildState holds DatabaseName, use dbName directly for
+        // lock
+        DatabaseName dbName(boost::none, replState->dbName);
+        Lock::DBLock autoDb(opCtx, dbName, MODE_IX);
         const NamespaceStringOrUUID dbAndUUID(replState->dbName, replState->collectionUUID);
         Lock::CollectionLock collLock(opCtx, dbAndUUID, MODE_IX);
 
@@ -2554,7 +2571,10 @@ void IndexBuildsCoordinator::_scanCollectionAndInsertSortedKeysIntoIndex(
 void IndexBuildsCoordinator::_insertSortedKeysIntoIndexForResume(
     OperationContext* opCtx, std::shared_ptr<ReplIndexBuildState> replState) {
     {
-        Lock::DBLock autoDb(opCtx, replState->dbName, MODE_IX);
+        // TODO SERVER-67437 Once ReplIndexBuildState holds DatabaseName, use dbName directly for
+        // lock
+        DatabaseName dbName(boost::none, replState->dbName);
+        Lock::DBLock autoDb(opCtx, dbName, MODE_IX);
         const NamespaceStringOrUUID dbAndUUID(replState->dbName, replState->collectionUUID);
         Lock::CollectionLock collLock(opCtx, dbAndUUID, MODE_IX);
 
@@ -2595,7 +2615,10 @@ void IndexBuildsCoordinator::_insertKeysFromSideTablesWithoutBlockingWrites(
     // Perform the first drain while holding an intent lock.
     const NamespaceStringOrUUID dbAndUUID(replState->dbName, replState->collectionUUID);
     {
-        Lock::DBLock autoDb(opCtx, replState->dbName, MODE_IX);
+        // TODO SERVER-67437 Once ReplIndexBuildState holds DatabaseName, use dbName directly for
+        // lock
+        DatabaseName dbName(boost::none, replState->dbName);
+        Lock::DBLock autoDb(opCtx, dbName, MODE_IX);
         Lock::CollectionLock collLock(opCtx, dbAndUUID, MODE_IX);
 
         uassertStatusOK(_indexBuildsManager.drainBackgroundWrites(
@@ -2620,7 +2643,10 @@ void IndexBuildsCoordinator::_insertKeysFromSideTablesBlockingWrites(
     const NamespaceStringOrUUID dbAndUUID(replState->dbName, replState->collectionUUID);
     // Perform the second drain while stopping writes on the collection.
     {
-        Lock::DBLock autoDb(opCtx, replState->dbName, MODE_IX);
+        // TODO SERVER-67437 Once ReplIndexBuildState holds DatabaseName, use dbName directly for
+        // lock
+        DatabaseName dbName(boost::none, replState->dbName);
+        Lock::DBLock autoDb(opCtx, dbName, MODE_IX);
 
         // Unlock RSTL to avoid deadlocks with prepare conflicts and state transitions. See
         // SERVER-42621.
@@ -2656,7 +2682,9 @@ IndexBuildsCoordinator::CommitResult IndexBuildsCoordinator::_insertKeysFromSide
         hangIndexBuildBeforeCommit.pauseWhileSet();
     }
 
-    Lock::DBLock autoDb(opCtx, replState->dbName, MODE_IX);
+    // TODO SERVER-67437 Once ReplIndexBuildState holds DatabaseName, use dbName directly for lock
+    DatabaseName dbName(boost::none, replState->dbName);
+    Lock::DBLock autoDb(opCtx, dbName, MODE_IX);
 
     // Unlock RSTL to avoid deadlocks with prepare conflicts and state transitions caused by waiting
     // for a a strong collection lock. See SERVER-42621.
diff --git a/src/mongo/db/pipeline/process_interface/common_mongod_process_interface.cpp b/src/mongo/db/pipeline/process_interface/common_mongod_process_interface.cpp
index 2fecb18bebe..9e59e0eddd5 100644
--- a/src/mongo/db/pipeline/process_interface/common_mongod_process_interface.cpp
+++ b/src/mongo/db/pipeline/process_interface/common_mongod_process_interface.cpp
@@ -582,7 +582,7 @@ bool CommonMongodProcessInterface::fieldsHaveSupportingUniqueIndex(
     // We purposefully avoid a helper like AutoGetCollection here because we don't want to check the
     // db version or do anything else. We simply want to protect against concurrent modifications to
     // the catalog.
-    Lock::DBLock dbLock(opCtx, nss.db(), MODE_IS);
+    Lock::DBLock dbLock(opCtx, nss.dbName(), MODE_IS);
     Lock::CollectionLock collLock(opCtx, nss, MODE_IS);
     auto databaseHolder = DatabaseHolder::get(opCtx);
     auto db = databaseHolder->getDb(opCtx, nss.dbName());
diff --git a/src/mongo/db/repl/apply_ops.cpp b/src/mongo/db/repl/apply_ops.cpp
index 4887982c95c..96ff0518616 100644
--- a/src/mongo/db/repl/apply_ops.cpp
+++ b/src/mongo/db/repl/apply_ops.cpp
@@ -107,7 +107,7 @@ Status _applyOps(OperationContext* opCtx,
 
             // ApplyOps does not have the global writer lock when applying transaction
             // operations, so we need to acquire the DB and Collection locks.
-            Lock::DBLock dbLock(opCtx, nss.db(), MODE_IX);
+            Lock::DBLock dbLock(opCtx, nss.dbName(), MODE_IX);
 
             // When processing an update on a non-existent collection, applyOperation_inlock()
             // returns UpdateOperationFailed on updates and allows the collection to be
@@ -363,7 +363,9 @@ Status applyOps(OperationContext* opCtx,
     // There's one case where we are allowed to take the database lock instead of the global
     // lock - no preconditions; only CRUD ops; and non-atomic mode.
     if (!info.getPreCondition() && info.areOpsCrudOnly() && !info.getAllowAtomic()) {
-        dbWriteLock.emplace(opCtx, dbName, MODE_IX);
+        // TODO SERVER-62880 Once the dbName is of type DatabaseName, pass it directly to the DBlock
+        DatabaseName databaseName(boost::none, dbName);
+        dbWriteLock.emplace(opCtx, databaseName, MODE_IX);
     } else {
         globalWriteLock.emplace(opCtx);
     }
diff --git a/src/mongo/db/repl/idempotency_test_fixture.cpp b/src/mongo/db/repl/idempotency_test_fixture.cpp
index e844e2fb6fc..d74b3171b67 100644
--- a/src/mongo/db/repl/idempotency_test_fixture.cpp
+++ b/src/mongo/db/repl/idempotency_test_fixture.cpp
@@ -359,7 +359,7 @@ std::vector<CollectionState> IdempotencyTest::validateAllCollections() {
         if (dbName.db() != "local") {
             std::vector<NamespaceString> collectionNames;
             {
-                Lock::DBLock lk(_opCtx.get(), dbName.db(), MODE_S);
+                Lock::DBLock lk(_opCtx.get(), dbName, MODE_S);
                 collectionNames = catalog->getAllCollectionNamesFromDb(_opCtx.get(), dbName);
             }
             for (const auto& nss : collectionNames) {
diff --git a/src/mongo/db/repl/oplog.cpp b/src/mongo/db/repl/oplog.cpp
index 7ffffbbf2c1..2919ebe31b5 100644
--- a/src/mongo/db/repl/oplog.cpp
+++ b/src/mongo/db/repl/oplog.cpp
@@ -848,7 +848,7 @@ const StringMap<ApplyOpMetadata> kOpsMap = {
           // complete.
           const bool allowRenameOutOfTheWay = (mode != repl::OplogApplication::Mode::kSecondary);
 
-          Lock::DBLock dbLock(opCtx, nss.db(), MODE_IX);
+          Lock::DBLock dbLock(opCtx, nss.dbName(), MODE_IX);
           if (auto idIndexElem = cmd["idIndex"]) {
               // Remove "idIndex" field from command.
               auto cmdWithoutIdIndex = cmd.removeField("idIndex");
@@ -896,7 +896,7 @@ const StringMap<ApplyOpMetadata> kOpsMap = {
                   "createIndexes value must be a string",
                   first.type() == mongo::String);
           BSONObj indexSpec = cmd.removeField("createIndexes");
-          Lock::DBLock dbLock(opCtx, nss.db(), MODE_IX);
+          Lock::DBLock dbLock(opCtx, nss.dbName(), MODE_IX);
           Lock::CollectionLock collLock(opCtx, nss, MODE_X);
           createIndexForApplyOps(opCtx, indexSpec, nss, mode);
           return Status::OK();
diff --git a/src/mongo/db/repl/oplog_applier_impl_test_fixture.cpp b/src/mongo/db/repl/oplog_applier_impl_test_fixture.cpp
index 9dfb154a971..d4b8ad32e2f 100644
--- a/src/mongo/db/repl/oplog_applier_impl_test_fixture.cpp
+++ b/src/mongo/db/repl/oplog_applier_impl_test_fixture.cpp
@@ -459,7 +459,7 @@ void createCollection(OperationContext* opCtx,
                       const NamespaceString& nss,
                       const CollectionOptions& options) {
     writeConflictRetry(opCtx, "createCollection", nss.ns(), [&] {
-        Lock::DBLock dbLk(opCtx, nss.db(), MODE_IX);
+        Lock::DBLock dbLk(opCtx, nss.dbName(), MODE_IX);
         Lock::CollectionLock collLk(opCtx, nss, MODE_X);
 
         OldClientContext ctx(opCtx, nss.ns());
@@ -498,7 +498,7 @@ void createIndex(OperationContext* opCtx,
                  const NamespaceString& nss,
                  const UUID collUUID,
                  const BSONObj& spec) {
-    Lock::DBLock dbLk(opCtx, nss.db(), MODE_IX);
+    Lock::DBLock dbLk(opCtx, nss.dbName(), MODE_IX);
     Lock::CollectionLock collLk(opCtx, nss, MODE_X);
     auto indexBuildsCoord = IndexBuildsCoordinator::get(opCtx);
     indexBuildsCoord->createIndex(
diff --git a/src/mongo/db/repl/replication_consistency_markers_impl_test.cpp b/src/mongo/db/repl/replication_consistency_markers_impl_test.cpp
index 08202481ee8..b797fbd36ed 100644
--- a/src/mongo/db/repl/replication_consistency_markers_impl_test.cpp
+++ b/src/mongo/db/repl/replication_consistency_markers_impl_test.cpp
@@ -64,7 +64,7 @@ NamespaceString kInitialSyncIdNss("local", "replset.initialSyncId");
  */
 BSONObj getMinValidDocument(OperationContext* opCtx, const NamespaceString& minValidNss) {
     return writeConflictRetry(opCtx, "getMinValidDocument", minValidNss.ns(), [opCtx, minValidNss] {
-        Lock::DBLock dblk(opCtx, minValidNss.db(), MODE_IS);
+        Lock::DBLock dblk(opCtx, minValidNss.dbName(), MODE_IS);
         Lock::CollectionLock lk(opCtx, minValidNss, MODE_IS);
         BSONObj mv;
         if (Helpers::getSingleton(opCtx, minValidNss.ns().c_str(), mv)) {
diff --git a/src/mongo/db/repl/replication_coordinator_external_state_impl.cpp b/src/mongo/db/repl/replication_coordinator_external_state_impl.cpp
index 5d450af12d7..de903787a74 100644
--- a/src/mongo/db/repl/replication_coordinator_external_state_impl.cpp
+++ b/src/mongo/db/repl/replication_coordinator_external_state_impl.cpp
@@ -133,7 +133,8 @@ namespace repl {
 namespace {
 
 const char localDbName[] = "local";
-const auto configDatabaseName = localDbName;
+// TODO SERVER-62491 Use SystemTenantId
+const auto configDatabaseName = DatabaseName(boost::none, localDbName);
 const auto lastVoteDatabaseName = localDbName;
 const char meCollectionName[] = "local.me";
 const auto meDatabaseName = localDbName;
diff --git a/src/mongo/db/repl/rollback_impl.cpp b/src/mongo/db/repl/rollback_impl.cpp
index 728fb0b505d..8e32fba099b 100644
--- a/src/mongo/db/repl/rollback_impl.cpp
+++ b/src/mongo/db/repl/rollback_impl.cpp
@@ -1370,7 +1370,7 @@ void RollbackImpl::_resetDropPendingState(OperationContext* opCtx) {
     std::vector<DatabaseName> dbNames = storageEngine->listDatabases();
     auto databaseHolder = DatabaseHolder::get(opCtx);
     for (const auto& dbName : dbNames) {
-        Lock::DBLock dbLock(opCtx, dbName.db(), MODE_X);
+        Lock::DBLock dbLock(opCtx, dbName, MODE_X);
         auto db = databaseHolder->openDb(opCtx, dbName);
         db->checkForIdIndexesAndDropPendingCollections(opCtx);
     }
diff --git a/src/mongo/db/repl/rollback_test_fixture.cpp b/src/mongo/db/repl/rollback_test_fixture.cpp
index f2486997bb6..6372b635d3c 100644
--- a/src/mongo/db/repl/rollback_test_fixture.cpp
+++ b/src/mongo/db/repl/rollback_test_fixture.cpp
@@ -210,7 +210,7 @@ std::pair<BSONObj, RecordId> RollbackTest::makeCommandOpForApplyOps(boost::optio
 Collection* RollbackTest::_createCollection(OperationContext* opCtx,
                                             const NamespaceString& nss,
                                             const CollectionOptions& options) {
-    Lock::DBLock dbLock(opCtx, nss.db(), MODE_X);
+    Lock::DBLock dbLock(opCtx, nss.dbName(), MODE_X);
     mongo::WriteUnitOfWork wuow(opCtx);
     auto databaseHolder = DatabaseHolder::get(opCtx);
     auto db = databaseHolder->openDb(opCtx, nss.dbName());
diff --git a/src/mongo/db/repl/rs_rollback.cpp b/src/mongo/db/repl/rs_rollback.cpp
index 8777903803c..d28b881cc20 100644
--- a/src/mongo/db/repl/rs_rollback.cpp
+++ b/src/mongo/db/repl/rs_rollback.cpp
@@ -909,7 +909,7 @@ void rollbackCreateIndexes(OperationContext* opCtx, UUID uuid, std::set<std::str
     boost::optional<NamespaceString> nss =
         CollectionCatalog::get(opCtx)->lookupNSSByUUID(opCtx, uuid);
     invariant(nss);
-    Lock::DBLock dbLock(opCtx, nss->db(), MODE_X);
+    Lock::DBLock dbLock(opCtx, nss->dbName(), MODE_X);
     CollectionWriter collection(opCtx, uuid);
 
     // If we cannot find the collection, we skip over dropping the index.
@@ -973,7 +973,7 @@ void rollbackDropIndexes(OperationContext* opCtx,
     auto catalog = CollectionCatalog::get(opCtx);
     boost::optional<NamespaceString> nss = catalog->lookupNSSByUUID(opCtx, uuid);
     invariant(nss);
-    Lock::DBLock dbLock(opCtx, nss->db(), MODE_IX);
+    Lock::DBLock dbLock(opCtx, nss->dbName(), MODE_IX);
     Lock::CollectionLock collLock(opCtx, *nss, MODE_X);
     CollectionPtr collection = catalog->lookupCollectionByNamespace(opCtx, *nss);
 
@@ -1142,8 +1142,7 @@ void renameOutOfTheWay(OperationContext* opCtx, RenameCollectionInfo info, Datab
  */
 void rollbackRenameCollection(OperationContext* opCtx, UUID uuid, RenameCollectionInfo info) {
 
-    auto dbString = info.renameFrom.db();
-    const DatabaseName dbName(boost::none, dbString);
+    auto dbName = info.renameFrom.dbName();
 
     LOGV2(21679,
           "Attempting to rename collection with UUID: {uuid}, from: {renameFrom}, to: "
@@ -1152,7 +1151,7 @@ void rollbackRenameCollection(OperationContext* opCtx, UUID uuid, RenameCollecti
           "uuid"_attr = uuid,
           "renameFrom"_attr = info.renameFrom,
           "renameTo"_attr = info.renameTo);
-    Lock::DBLock dbLock(opCtx, dbString, MODE_X);
+    Lock::DBLock dbLock(opCtx, dbName, MODE_X);
     auto databaseHolder = DatabaseHolder::get(opCtx);
     auto db = databaseHolder->openDb(opCtx, dbName);
     invariant(db);
@@ -1581,7 +1580,7 @@ void rollback_internal::syncFixUp(OperationContext* opCtx,
                   "namespace"_attr = *nss,
                   "uuid"_attr = uuid);
 
-            Lock::DBLock dbLock(opCtx, nss->db(), MODE_X);
+            Lock::DBLock dbLock(opCtx, nss->dbName(), MODE_X);
 
             auto databaseHolder = DatabaseHolder::get(opCtx);
             auto db = databaseHolder->openDb(opCtx, nss->dbName());
@@ -1737,7 +1736,7 @@ void rollback_internal::syncFixUp(OperationContext* opCtx,
 
                 // TODO: Lots of overhead in context. This can be faster.
                 const NamespaceString docNss(doc.ns);
-                Lock::DBLock docDbLock(opCtx, docNss.db(), MODE_X);
+                Lock::DBLock docDbLock(opCtx, docNss.dbName(), MODE_X);
                 OldClientContext ctx(opCtx, doc.ns.toString());
                 CollectionWriter collection(opCtx, uuid);
 
@@ -1956,7 +1955,7 @@ void rollback_internal::syncFixUp(OperationContext* opCtx,
     // Cleans up the oplog.
     {
         const NamespaceString oplogNss(NamespaceString::kRsOplogNamespace);
-        Lock::DBLock oplogDbLock(opCtx, oplogNss.db(), MODE_IX);
+        Lock::DBLock oplogDbLock(opCtx, oplogNss.dbName(), MODE_IX);
         Lock::CollectionLock oplogCollectionLoc(opCtx, oplogNss, MODE_X);
         OldClientContext ctx(opCtx, oplogNss.ns());
         auto oplogCollection =
diff --git a/src/mongo/db/repl/storage_interface_impl_test.cpp b/src/mongo/db/repl/storage_interface_impl_test.cpp
index 14362a56821..cd85959ef3b 100644
--- a/src/mongo/db/repl/storage_interface_impl_test.cpp
+++ b/src/mongo/db/repl/storage_interface_impl_test.cpp
@@ -122,7 +122,7 @@ void createCollection(OperationContext* opCtx,
                       const NamespaceString& nss,
                       const CollectionOptions& options = generateOptionsWithUuid()) {
     writeConflictRetry(opCtx, "createCollection", nss.ns(), [&] {
-        Lock::DBLock dblk(opCtx, nss.db(), MODE_X);
+        Lock::DBLock dblk(opCtx, nss.dbName(), MODE_X);
         OldClientContext ctx(opCtx, nss.ns());
         auto db = ctx.db();
         ASSERT_TRUE(db);
@@ -138,7 +138,7 @@ void createCollection(OperationContext* opCtx,
  * collection after the given index is created.
  */
 int _createIndexOnEmptyCollection(OperationContext* opCtx, NamespaceString nss, BSONObj indexSpec) {
-    Lock::DBLock dbLock(opCtx, nss.db(), MODE_X);
+    Lock::DBLock dbLock(opCtx, nss.dbName(), MODE_X);
     AutoGetCollection coll(opCtx, nss, MODE_X);
 
     WriteUnitOfWork wunit(opCtx);
diff --git a/src/mongo/db/s/balancer_stats_registry.cpp b/src/mongo/db/s/balancer_stats_registry.cpp
index f2c6dd5945c..c2308b26d2d 100644
--- a/src/mongo/db/s/balancer_stats_registry.cpp
+++ b/src/mongo/db/s/balancer_stats_registry.cpp
@@ -61,14 +61,16 @@ ThreadPool::Options makeDefaultThreadPoolOptions() {
 }  // namespace
 
 ScopedRangeDeleterLock::ScopedRangeDeleterLock(OperationContext* opCtx)
-    : _configLock(opCtx, NamespaceString::kConfigDb, MODE_IX),
+    // TODO SERVER-62491 Use system tenantId for DBLock
+    : _configLock(opCtx, DatabaseName(boost::none, NamespaceString::kConfigDb), MODE_IX),
       _rangeDeletionLock(opCtx, NamespaceString::kRangeDeletionNamespace, MODE_X) {}
 
 // Take DB and Collection lock in mode IX as well as collection UUID lock to serialize with
 // operations that take the above version of the ScopedRangeDeleterLock such as FCV downgrade and
 // BalancerStatsRegistry initialization.
 ScopedRangeDeleterLock::ScopedRangeDeleterLock(OperationContext* opCtx, const UUID& collectionUuid)
-    : _configLock(opCtx, NamespaceString::kConfigDb, MODE_IX),
+    // TODO SERVER-62491 Use system tenantId for DBLock
+    : _configLock(opCtx, DatabaseName(boost::none, NamespaceString::kConfigDb), MODE_IX),
       _rangeDeletionLock(opCtx, NamespaceString::kRangeDeletionNamespace, MODE_IX),
       _collectionUuidLock(Lock::ResourceLock(
           opCtx->lockState(),
diff --git a/src/mongo/db/s/database_sharding_state.cpp b/src/mongo/db/s/database_sharding_state.cpp
index 776b23857d0..d4eabcc197a 100644
--- a/src/mongo/db/s/database_sharding_state.cpp
+++ b/src/mongo/db/s/database_sharding_state.cpp
@@ -101,7 +101,8 @@ void DatabaseShardingState::checkIsPrimaryShardForDb(OperationContext* opCtx, St
             OperationShardingState::get(opCtx).hasDbVersion());
 
     const auto dbPrimaryShardId = [&]() {
-        Lock::DBLock dbWriteLock(opCtx, dbName, MODE_IS);
+        // TODO SERVER-63706 Use dbName directly
+        Lock::DBLock dbWriteLock(opCtx, DatabaseName(boost::none, dbName), MODE_IS);
         auto dss = DatabaseShardingState::get(opCtx, dbName);
         auto dssLock = DatabaseShardingState::DSSLock::lockShared(opCtx, dss);
         // The following call will also ensure that the database version matches
diff --git a/src/mongo/db/s/drop_collection_coordinator.cpp b/src/mongo/db/s/drop_collection_coordinator.cpp
index fa1e2f4b84e..0262090f6af 100644
--- a/src/mongo/db/s/drop_collection_coordinator.cpp
+++ b/src/mongo/db/s/drop_collection_coordinator.cpp
@@ -51,7 +51,7 @@ DropReply DropCollectionCoordinator::dropCollectionLocally(OperationContext* opC
                                                            const NamespaceString& nss) {
     {
         // Clear CollectionShardingRuntime entry
-        Lock::DBLock dbLock(opCtx, nss.db(), MODE_IX);
+        Lock::DBLock dbLock(opCtx, nss.dbName(), MODE_IX);
         Lock::CollectionLock collLock(opCtx, nss, MODE_IX);
         auto* csr = CollectionShardingRuntime::get(opCtx, nss);
         csr->clearFilteringMetadata(opCtx);
diff --git a/src/mongo/db/s/drop_database_coordinator.cpp b/src/mongo/db/s/drop_database_coordinator.cpp
index 54b8ef1108e..708f004f801 100644
--- a/src/mongo/db/s/drop_database_coordinator.cpp
+++ b/src/mongo/db/s/drop_database_coordinator.cpp
@@ -84,7 +84,10 @@ public:
                                   const std::string dbName,
                                   const BSONObj reason)
         : _opCtx(opCtx), _dbName(std::move(dbName)), _reason(std::move(reason)) {
-        Lock::DBLock dbLock(_opCtx, _dbName, MODE_X);
+        // TODO SERVER-67438 Once ScopedDatabaseCriticalSection holds a DatabaseName obj, use dbName
+        // directly
+        DatabaseName databaseName(boost::none, _dbName);
+        Lock::DBLock dbLock(_opCtx, databaseName, MODE_X);
         auto dss = DatabaseShardingState::get(_opCtx, _dbName);
         auto dssLock = DatabaseShardingState::DSSLock::lockExclusive(_opCtx, dss);
         dss->enterCriticalSectionCatchUpPhase(_opCtx, dssLock, _reason);
@@ -93,7 +96,10 @@ public:
 
     ~ScopedDatabaseCriticalSection() {
         UninterruptibleLockGuard guard(_opCtx->lockState());
-        Lock::DBLock dbLock(_opCtx, _dbName, MODE_X);
+        // TODO SERVER-67438 Once ScopedDatabaseCriticalSection holds a DatabaseName obj, use dbName
+        // directly
+        DatabaseName databaseName(boost::none, _dbName);
+        Lock::DBLock dbLock(_opCtx, databaseName, MODE_X);
         auto dss = DatabaseShardingState::get(_opCtx, _dbName);
         dss->exitCriticalSection(_opCtx, _reason);
     }
@@ -145,7 +151,8 @@ void DropDatabaseCoordinator::_dropShardedCollection(
 }
 
 void DropDatabaseCoordinator::_clearDatabaseInfoOnPrimary(OperationContext* opCtx) {
-    Lock::DBLock dbLock(opCtx, _dbName, MODE_X);
+    // TODO SERVER-67438 Use _dbName directly once it's of type DatabaseName
+    Lock::DBLock dbLock(opCtx, DatabaseName(boost::none, _dbName), MODE_X);
     auto dss = DatabaseShardingState::get(opCtx, _dbName);
     dss->clearDatabaseInfo(opCtx);
 }
diff --git a/src/mongo/db/s/op_observer_sharding_impl.cpp b/src/mongo/db/s/op_observer_sharding_impl.cpp
index 2432902effd..096aeeca1cc 100644
--- a/src/mongo/db/s/op_observer_sharding_impl.cpp
+++ b/src/mongo/db/s/op_observer_sharding_impl.cpp
@@ -87,7 +87,7 @@ void assertMovePrimaryInProgress(OperationContext* opCtx, NamespaceString const&
 
     // TODO SERVER-58222: evaluate whether this is safe or whether acquiring the lock can block.
     AllowLockAcquisitionOnTimestampedUnitOfWork allowLockAcquisition(opCtx->lockState());
-    Lock::DBLock dblock(opCtx, nss.db(), MODE_IS);
+    Lock::DBLock dblock(opCtx, nss.dbName(), MODE_IS);
     auto dss = DatabaseShardingState::get(opCtx, nss.db().toString());
     if (!dss) {
         return;
diff --git a/src/mongo/db/s/rename_collection_coordinator.cpp b/src/mongo/db/s/rename_collection_coordinator.cpp
index 74b3835a0ea..b2899aa71ca 100644
--- a/src/mongo/db/s/rename_collection_coordinator.cpp
+++ b/src/mongo/db/s/rename_collection_coordinator.cpp
@@ -74,7 +74,7 @@ boost::optional<UUID> getCollectionUUID(OperationContext* opCtx,
     if (optCollectionType) {
         return optCollectionType->getUuid();
     }
-    Lock::DBLock dbLock(opCtx, nss.db(), MODE_IS);
+    Lock::DBLock dbLock(opCtx, nss.dbName(), MODE_IS);
     Lock::CollectionLock collLock(opCtx, nss, MODE_IS);
     const auto collPtr = CollectionCatalog::get(opCtx)->lookupCollectionByNamespace(opCtx, nss);
     if (!collPtr && !throwOnNotFound) {
diff --git a/src/mongo/db/s/rename_collection_participant_service.cpp b/src/mongo/db/s/rename_collection_participant_service.cpp
index f03f8d7edd7..58ced2cc9ac 100644
--- a/src/mongo/db/s/rename_collection_participant_service.cpp
+++ b/src/mongo/db/s/rename_collection_participant_service.cpp
@@ -74,7 +74,7 @@ void dropCollectionLocally(OperationContext* opCtx, const NamespaceString& nss)
 
 void clearFilteringMetadata(OperationContext* opCtx, const NamespaceString& nss) {
     UninterruptibleLockGuard noInterrupt(opCtx->lockState());
-    Lock::DBLock dbLock(opCtx, nss.db(), MODE_IX);
+    Lock::DBLock dbLock(opCtx, nss.dbName(), MODE_IX);
     Lock::CollectionLock collLock(opCtx, nss, MODE_IX);
     auto* csr = CollectionShardingRuntime::get(opCtx, nss);
     csr->clearFilteringMetadata(opCtx);
@@ -90,7 +90,7 @@ void renameOrDropTarget(OperationContext* opCtx,
                         const UUID& sourceUUID,
                         const boost::optional<UUID>& targetUUID) {
     {
-        Lock::DBLock dbLock(opCtx, toNss.db(), MODE_IS);
+        Lock::DBLock dbLock(opCtx, toNss.dbName(), MODE_IS);
         Lock::CollectionLock collLock(opCtx, toNss, MODE_IS);
         const auto targetCollPtr =
             CollectionCatalog::get(opCtx)->lookupCollectionByNamespace(opCtx, toNss);
@@ -107,7 +107,7 @@ void renameOrDropTarget(OperationContext* opCtx,
     }
 
     {
-        Lock::DBLock dbLock(opCtx, fromNss.db(), MODE_IS);
+        Lock::DBLock dbLock(opCtx, fromNss.dbName(), MODE_IS);
         Lock::CollectionLock collLock(opCtx, fromNss, MODE_IS);
         // ensure idempotency by checking sourceUUID
         const auto sourceCollPtr =
diff --git a/src/mongo/db/s/session_catalog_migration_destination.cpp b/src/mongo/db/s/session_catalog_migration_destination.cpp
index 614621e2ad0..d7511dee872 100644
--- a/src/mongo/db/s/session_catalog_migration_destination.cpp
+++ b/src/mongo/db/s/session_catalog_migration_destination.cpp
@@ -309,7 +309,7 @@ ProcessOplogResult processSessionOplog(const BSONObj& oplogBSON,
             // transaction table db lock to ensure the same lock ordering with normal replicated
             // updates to the table.
             Lock::DBLock lk(
-                opCtx, NamespaceString::kSessionTransactionsTableNamespace.db(), MODE_IX);
+                opCtx, NamespaceString::kSessionTransactionsTableNamespace.dbName(), MODE_IX);
             WriteUnitOfWork wunit(opCtx);
 
             result.oplogTime = repl::logOp(opCtx, &oplogEntry);
diff --git a/src/mongo/db/s/shard_filtering_metadata_refresh.cpp b/src/mongo/db/s/shard_filtering_metadata_refresh.cpp
index 4c7df87ac58..51bb630571f 100644
--- a/src/mongo/db/s/shard_filtering_metadata_refresh.cpp
+++ b/src/mongo/db/s/shard_filtering_metadata_refresh.cpp
@@ -71,7 +71,8 @@ void onDbVersionMismatch(OperationContext* opCtx,
         // TODO: It is not safe here to read the DB version without checking for critical section
         //
         if (clientDbVersion) {
-            Lock::DBLock dbLock(opCtx, dbName, MODE_IS);
+            // TODO SERVER-67440 Use dbName directly
+            Lock::DBLock dbLock(opCtx, DatabaseName(boost::none, dbName), MODE_IS);
             auto dss = DatabaseShardingState::get(opCtx, dbName);
             auto dssLock = DatabaseShardingState::DSSLock::lockShared(opCtx, dss);
             const auto serverDbVersion = dss->getDbVersion(opCtx, dssLock);
@@ -157,7 +158,7 @@ SharedSemiFuture<void> recoverRefreshShardVersion(ServiceContext* serviceContext
                 // version. It is then ok to lock views in order to clear filtering metadata.
                 //
                 // DBLock and CollectionLock must be used in order to avoid shard version checks
-                Lock::DBLock dbLock(opCtx, nss.db(), MODE_IX);
+                Lock::DBLock dbLock(opCtx, nss.dbName(), MODE_IX);
                 Lock::CollectionLock collLock(opCtx, nss, MODE_IX);
 
                 auto* const csr = CollectionShardingRuntime::get(opCtx, nss);
@@ -190,7 +191,7 @@ SharedSemiFuture<void> recoverRefreshShardVersion(ServiceContext* serviceContext
                     {
                         // DBLock and CollectionLock must be used in order to avoid shard version
                         // checks
-                        Lock::DBLock dbLock(opCtx, nss.db(), MODE_IX);
+                        Lock::DBLock dbLock(opCtx, nss.dbName(), MODE_IX);
                         Lock::CollectionLock collLock(opCtx, nss, MODE_IX);
 
                         auto const& csr = CollectionShardingRuntime::get(opCtx, nss);
@@ -259,7 +260,7 @@ void onShardVersionMismatch(OperationContext* opCtx,
         {
             boost::optional<Lock::DBLock> dbLock;
             boost::optional<Lock::CollectionLock> collLock;
-            dbLock.emplace(opCtx, nss.db(), MODE_IS);
+            dbLock.emplace(opCtx, nss.dbName(), MODE_IS);
             collLock.emplace(opCtx, nss, MODE_IS);
 
             auto* const csr = CollectionShardingRuntime::get(opCtx, nss);
@@ -380,7 +381,7 @@ ChunkVersion forceShardFilteringMetadataRefresh(OperationContext* opCtx,
         // DBLock and CollectionLock are used here to avoid throwing further recursive stale
         // config errors, as well as a possible InvalidViewDefinition error if an invalid view
         // is in the 'system.views' collection.
-        Lock::DBLock dbLock(opCtx, nss.db(), MODE_IX);
+        Lock::DBLock dbLock(opCtx, nss.dbName(), MODE_IX);
         Lock::CollectionLock collLock(opCtx, nss, MODE_IX);
         CollectionShardingRuntime::get(opCtx, nss)
             ->setFilteringMetadata(opCtx, CollectionMetadata());
@@ -394,7 +395,7 @@ ChunkVersion forceShardFilteringMetadataRefresh(OperationContext* opCtx,
         // DBLock and CollectionLock are used here to avoid throwing further recursive stale
         // config errors, as well as a possible InvalidViewDefinition error if an invalid view
         // is in the 'system.views' collection.
-        Lock::DBLock dbLock(opCtx, nss.db(), MODE_IS);
+        Lock::DBLock dbLock(opCtx, nss.dbName(), MODE_IS);
         Lock::CollectionLock collLock(opCtx, nss, MODE_IS);
         auto optMetadata = CollectionShardingRuntime::get(opCtx, nss)->getCurrentMetadataIfKnown();
 
@@ -423,7 +424,7 @@ ChunkVersion forceShardFilteringMetadataRefresh(OperationContext* opCtx,
     // DBLock and CollectionLock are used here to avoid throwing further recursive stale config
     // errors, as well as a possible InvalidViewDefinition error if an invalid view is in the
     // 'system.views' collection.
-    Lock::DBLock dbLock(opCtx, nss.db(), MODE_IX);
+    Lock::DBLock dbLock(opCtx, nss.dbName(), MODE_IX);
     Lock::CollectionLock collLock(opCtx, nss, MODE_IX);
     auto* const csr = CollectionShardingRuntime::get(opCtx, nss);
 
@@ -485,7 +486,8 @@ void forceDatabaseRefresh(OperationContext* opCtx, const StringData dbName) {
 
     if (swRefreshedDbInfo == ErrorCodes::NamespaceNotFound) {
         // db has been dropped, set the db version to boost::none
-        Lock::DBLock dbLock(opCtx, dbName, MODE_X);
+        // TODO SERVER-67440 Use dbName directly
+        Lock::DBLock dbLock(opCtx, DatabaseName(boost::none, dbName), MODE_X);
         auto dss = DatabaseShardingState::get(opCtx, dbName);
         dss->clearDatabaseInfo(opCtx);
         return;
@@ -500,7 +502,8 @@ void forceDatabaseRefresh(OperationContext* opCtx, const StringData dbName) {
     {
         // Take the DBLock directly rather than using AutoGetDb, to prevent a recursive call
         // into checkDbVersion().
-        Lock::DBLock dbLock(opCtx, dbName, MODE_IS);
+        // TODO SERVER-67440 Use dbName directly
+        Lock::DBLock dbLock(opCtx, DatabaseName(boost::none, dbName), MODE_IS);
         auto dss = DatabaseShardingState::get(opCtx, dbName);
         auto dssLock = DatabaseShardingState::DSSLock::lockShared(opCtx, dss);
 
@@ -518,7 +521,8 @@ void forceDatabaseRefresh(OperationContext* opCtx, const StringData dbName) {
     }
 
     // The cached version is older than the refreshed version; update the cached version.
-    Lock::DBLock dbLock(opCtx, dbName, MODE_X);
+    // TODO SERVER-67440 Use dbName directly
+    Lock::DBLock dbLock(opCtx, DatabaseName(boost::none, dbName), MODE_X);
     auto dss = DatabaseShardingState::get(opCtx, dbName);
     auto dssLock = DatabaseShardingState::DSSLock::lockExclusive(opCtx, dss);
 
diff --git a/src/mongo/db/s/split_chunk.cpp b/src/mongo/db/s/split_chunk.cpp
index 964871d3740..7b9067e7902 100644
--- a/src/mongo/db/s/split_chunk.cpp
+++ b/src/mongo/db/s/split_chunk.cpp
@@ -100,7 +100,7 @@ bool checkMetadataForSuccessfulSplitChunk(OperationContext* opCtx,
                                           const ChunkRange& chunkRange,
                                           const std::vector<BSONObj>& splitPoints) {
     // DBLock and CollectionLock must be used in order to avoid shard version checks
-    Lock::DBLock dbLock(opCtx, nss.db(), MODE_IS);
+    Lock::DBLock dbLock(opCtx, nss.dbName(), MODE_IS);
     Lock::CollectionLock collLock(opCtx, nss, MODE_IS);
 
     const auto metadataAfterSplit =
diff --git a/src/mongo/db/sessions_collection_rs.cpp b/src/mongo/db/sessions_collection_rs.cpp
index 1bce83b547f..4a60f4489c5 100644
--- a/src/mongo/db/sessions_collection_rs.cpp
+++ b/src/mongo/db/sessions_collection_rs.cpp
@@ -81,7 +81,7 @@ auto SessionsCollectionRS::_makePrimaryConnection(OperationContext* opCtx) {
 bool SessionsCollectionRS::_isStandaloneOrPrimary(const NamespaceString& ns,
                                                   OperationContext* opCtx) {
     ShouldNotConflictWithSecondaryBatchApplicationBlock noPBWMBlock(opCtx->lockState());
-    Lock::DBLock lk(opCtx, ns.db(), MODE_IS);
+    Lock::DBLock lk(opCtx, ns.dbName(), MODE_IS);
     Lock::CollectionLock lock(opCtx, NamespaceString::kLogicalSessionsNamespace, MODE_IS);
 
     auto coord = mongo::repl::ReplicationCoordinator::get(opCtx);
diff --git a/src/mongo/db/storage/kv/durable_catalog_test.cpp b/src/mongo/db/storage/kv/durable_catalog_test.cpp
index 9df5105231f..c74edd4d025 100644
--- a/src/mongo/db/storage/kv/durable_catalog_test.cpp
+++ b/src/mongo/db/storage/kv/durable_catalog_test.cpp
@@ -90,7 +90,7 @@ public:
 
     std::tuple<RecordId, UUID> createCollection(const NamespaceString& nss,
                                                 CollectionOptions options) {
-        Lock::DBLock dbLk(operationContext(), nss.db(), MODE_IX);
+        Lock::DBLock dbLk(operationContext(), nss.dbName(), MODE_IX);
         Lock::CollectionLock collLk(operationContext(), nss, MODE_IX);
 
         WriteUnitOfWork wuow(operationContext());
@@ -124,7 +124,7 @@ public:
     IndexCatalogEntry* createIndex(BSONObj keyPattern,
                                    std::string indexType = IndexNames::BTREE,
                                    bool twoPhase = false) {
-        Lock::DBLock dbLk(operationContext(), _nss.db(), MODE_IX);
+        Lock::DBLock dbLk(operationContext(), _nss.dbName(), MODE_IX);
         Lock::CollectionLock collLk(operationContext(), _nss, MODE_X);
 
         std::string indexName = "idx" + std::to_string(_numIndexesCreated);
@@ -204,7 +204,7 @@ protected:
     void setUp() override {
         DurableCatalogTest::setUp();
 
-        Lock::DBLock dbLock(operationContext(), nss.db(), MODE_IX);
+        Lock::DBLock dbLock(operationContext(), nss.dbName(), MODE_IX);
         Lock::CollectionLock collLock(operationContext(), nss, MODE_IX);
 
         WriteUnitOfWork wuow{operationContext()};
@@ -247,7 +247,7 @@ protected:
     StatusWith<DurableCatalog::ImportResult> importCollectionTest(const NamespaceString& nss,
                                                                   const BSONObj& metadata,
                                                                   const BSONObj& storageMetadata) {
-        Lock::DBLock dbLock(operationContext(), nss.db(), MODE_IX);
+        Lock::DBLock dbLock(operationContext(), nss.dbName(), MODE_IX);
         Lock::CollectionLock collLock(operationContext(), nss, MODE_X);
 
         WriteUnitOfWork wuow(operationContext());
@@ -546,7 +546,7 @@ TEST_F(DurableCatalogTest, SinglePhaseIndexBuild) {
     ASSERT_FALSE(collection->getIndexBuildUUID(indexEntry->descriptor()->indexName()));
 
     {
-        Lock::DBLock dbLk(operationContext(), collection->ns().db(), MODE_IX);
+        Lock::DBLock dbLk(operationContext(), collection->ns().dbName(), MODE_IX);
         Lock::CollectionLock collLk(operationContext(), collection->ns(), MODE_X);
 
         WriteUnitOfWork wuow(operationContext());
@@ -570,7 +570,7 @@ TEST_F(DurableCatalogTest, TwoPhaseIndexBuild) {
     ASSERT_TRUE(collection->getIndexBuildUUID(indexEntry->descriptor()->indexName()));
 
     {
-        Lock::DBLock dbLk(operationContext(), collection->ns().db(), MODE_IX);
+        Lock::DBLock dbLk(operationContext(), collection->ns().dbName(), MODE_IX);
         Lock::CollectionLock collLk(operationContext(), collection->ns(), MODE_X);
 
         WriteUnitOfWork wuow(operationContext());
diff --git a/src/mongo/db/storage/kv/kv_engine_test_harness.cpp b/src/mongo/db/storage/kv/kv_engine_test_harness.cpp
index 82870be5494..ce7b10e5287 100644
--- a/src/mongo/db/storage/kv/kv_engine_test_harness.cpp
+++ b/src/mongo/db/storage/kv/kv_engine_test_harness.cpp
@@ -82,7 +82,7 @@ protected:
                            const NamespaceString& ns,
                            const CollectionOptions& options,
                            DurableCatalogImpl* catalog) {
-        Lock::DBLock dbLk(opCtx, ns.db(), MODE_IX);
+        Lock::DBLock dbLk(opCtx, ns.dbName(), MODE_IX);
         auto swEntry = catalog->_addEntry(opCtx, ns, options);
         ASSERT_OK(swEntry.getStatus());
         return swEntry.getValue().catalogId;
diff --git a/src/mongo/db/storage/kv/storage_engine_test.cpp b/src/mongo/db/storage/kv/storage_engine_test.cpp
index ae0569a10ec..ebfd3bb017a 100644
--- a/src/mongo/db/storage/kv/storage_engine_test.cpp
+++ b/src/mongo/db/storage/kv/storage_engine_test.cpp
@@ -294,7 +294,7 @@ TEST_F(StorageEngineTest, ReconcileUnfinishedBackgroundSecondaryIndex) {
     const bool isBackgroundSecondaryBuild = true;
     const boost::optional<UUID> buildUUID = boost::none;
     {
-        Lock::DBLock dbLk(opCtx.get(), ns.db(), MODE_IX);
+        Lock::DBLock dbLk(opCtx.get(), ns.dbName(), MODE_IX);
         Lock::CollectionLock collLk(opCtx.get(), ns, MODE_X);
 
         WriteUnitOfWork wuow(opCtx.get());
@@ -344,7 +344,7 @@ TEST_F(StorageEngineTest, ReconcileTwoPhaseIndexBuilds) {
     // Start two indexes with the same buildUUID to simulate building multiple indexes within the
     // same build.
     {
-        Lock::DBLock dbLk(opCtx.get(), ns.db(), MODE_IX);
+        Lock::DBLock dbLk(opCtx.get(), ns.dbName(), MODE_IX);
         Lock::CollectionLock collLk(opCtx.get(), ns, MODE_X);
         {
             WriteUnitOfWork wuow(opCtx.get());
diff --git a/src/mongo/db/storage/storage_repair_observer_test.cpp b/src/mongo/db/storage/storage_repair_observer_test.cpp
index 580ca293505..bed95255be1 100644
--- a/src/mongo/db/storage/storage_repair_observer_test.cpp
+++ b/src/mongo/db/storage/storage_repair_observer_test.cpp
@@ -67,7 +67,7 @@ public:
 
     void createMockReplConfig(OperationContext* opCtx) {
         BSONObj replConfig;
-        Lock::DBLock dbLock(opCtx, "local", MODE_X);
+        Lock::DBLock dbLock(opCtx, DatabaseName(boost::none, "local"), MODE_X);
         Helpers::putSingleton(opCtx, "local.system.replset", replConfig);
     }
 
@@ -83,7 +83,7 @@ public:
 
     bool hasReplConfig(OperationContext* opCtx) {
         BSONObj replConfig;
-        Lock::DBLock dbLock(opCtx, "local", MODE_IS);
+        Lock::DBLock dbLock(opCtx, DatabaseName(boost::none, "local"), MODE_IS);
         return Helpers::getSingleton(opCtx, "local.system.replset", replConfig);
     }
 
diff --git a/src/mongo/db/transaction_participant.cpp b/src/mongo/db/transaction_participant.cpp
index 65a756ea3b1..d37d4213fec 100644
--- a/src/mongo/db/transaction_participant.cpp
+++ b/src/mongo/db/transaction_participant.cpp
@@ -573,7 +573,7 @@ TransactionParticipant::getOldestActiveTimestamp(Timestamp stableTimestamp) {
 
         ShouldNotConflictWithSecondaryBatchApplicationBlock shouldNotConflictBlock(
             opCtx->lockState());
-        Lock::DBLock dbLock(opCtx.get(), nss.db(), MODE_IS, deadline);
+        Lock::DBLock dbLock(opCtx.get(), nss.dbName(), MODE_IS, deadline);
         Lock::CollectionLock collLock(opCtx.get(), nss, MODE_IS, deadline);
 
         auto databaseHolder = DatabaseHolder::get(opCtx.get());
diff --git a/src/mongo/db/transaction_participant_test.cpp b/src/mongo/db/transaction_participant_test.cpp
index ee477f77463..796acf8f2c9 100644
--- a/src/mongo/db/transaction_participant_test.cpp
+++ b/src/mongo/db/transaction_participant_test.cpp
@@ -419,7 +419,7 @@ TEST_F(TxnParticipantTest, TransactionThrowsLockTimeoutIfLockIsUnavailable) {
     auto txnParticipant = TransactionParticipant::get(opCtx());
     txnParticipant.unstashTransactionResources(opCtx(), "insert");
 
-    { Lock::DBLock dbXLock(opCtx(), dbName, MODE_X); }
+    { Lock::DBLock dbXLock(opCtx(), DatabaseName(boost::none, dbName), MODE_X); }
     txnParticipant.stashTransactionResources(opCtx());
     auto clientWithDatabaseXLock = Client::releaseCurrent();
 
@@ -452,7 +452,7 @@ TEST_F(TxnParticipantTest, TransactionThrowsLockTimeoutIfLockIsUnavailable) {
         newTxnParticipant.unstashTransactionResources(newOpCtx.get(), "insert");
 
         Date_t t1 = Date_t::now();
-        ASSERT_THROWS_CODE(Lock::DBLock(newOpCtx.get(), dbName, MODE_X),
+        ASSERT_THROWS_CODE(Lock::DBLock(newOpCtx.get(), DatabaseName(boost::none, dbName), MODE_X),
                            AssertionException,
                            ErrorCodes::LockTimeout);
         Date_t t2 = Date_t::now();
@@ -460,7 +460,7 @@ TEST_F(TxnParticipantTest, TransactionThrowsLockTimeoutIfLockIsUnavailable) {
         ASSERT_GTE(t2 - t1, Milliseconds(defaultMaxTransactionLockRequestTimeoutMillis));
 
         // A non-conflicting lock acquisition should work just fine.
-        { Lock::DBLock tempLock(newOpCtx.get(), "NewTestDB", MODE_X); }
+        { Lock::DBLock tempLock(newOpCtx.get(), DatabaseName(boost::none, "NewTestDB"), MODE_X); }
     }
     // Restore the original client so that teardown works.
     Client::releaseCurrent();
@@ -984,7 +984,7 @@ TEST_F(TxnParticipantTest, UnstashFailsShouldLeaveTxnResourceStashUnchanged) {
 
     // Simulate the locking of an insert.
     {
-        Lock::DBLock dbLock(opCtx(), "test", MODE_IX);
+        Lock::DBLock dbLock(opCtx(), DatabaseName(boost::none, "test"), MODE_IX);
         Lock::CollectionLock collLock(opCtx(), NamespaceString("test.foo"), MODE_IX);
     }
 
@@ -1131,7 +1131,7 @@ TEST_F(TxnParticipantTest, StepDownDuringPreparedAbortReleasesRSTL) {
 
     // Simulate the locking of an insert.
     {
-        Lock::DBLock dbLock(opCtx(), "test", MODE_IX);
+        Lock::DBLock dbLock(opCtx(), DatabaseName(boost::none, "test"), MODE_IX);
         Lock::CollectionLock collLock(opCtx(), NamespaceString("test.foo"), MODE_IX);
     }
 
@@ -1184,7 +1184,7 @@ TEST_F(TxnParticipantTest, StepDownDuringPreparedCommitReleasesRSTL) {
 
     // Simulate the locking of an insert.
     {
-        Lock::DBLock dbLock(opCtx(), "test", MODE_IX);
+        Lock::DBLock dbLock(opCtx(), DatabaseName(boost::none, "test"), MODE_IX);
         Lock::CollectionLock collLock(opCtx(), NamespaceString("test.foo"), MODE_IX);
     }
 
@@ -1847,7 +1847,7 @@ TEST_F(TxnParticipantTest, ReacquireLocksForPreparedTransactionsOnStepUp) {
         txnParticipant.unstashTransactionResources(opCtx(), "prepareTransaction");
         // Simulate the locking of an insert.
         {
-            Lock::DBLock dbLock(opCtx(), "test", MODE_IX);
+            Lock::DBLock dbLock(opCtx(), DatabaseName(boost::none, "test"), MODE_IX);
             Lock::CollectionLock collLock(opCtx(), NamespaceString("test.foo"), MODE_IX);
         }
         txnParticipant.prepareTransaction(opCtx(), repl::OpTime({1, 1}, 1));
diff --git a/src/mongo/db/views/view_catalog_test.cpp b/src/mongo/db/views/view_catalog_test.cpp
index 1a3bfb33fb4..1d6b091681a 100644
--- a/src/mongo/db/views/view_catalog_test.cpp
+++ b/src/mongo/db/views/view_catalog_test.cpp
@@ -114,7 +114,7 @@ public:
                       const NamespaceString& viewOn,
                       const BSONArray& pipeline,
                       const BSONObj& collation) {
-        Lock::DBLock dbLock(operationContext(), viewName.db(), MODE_IX);
+        Lock::DBLock dbLock(operationContext(), viewName.dbName(), MODE_IX);
         Lock::CollectionLock collLock(operationContext(), viewName, MODE_IX);
         Lock::CollectionLock sysCollLock(
             operationContext(),
@@ -133,7 +133,7 @@ public:
                       const NamespaceString& viewName,
                       const NamespaceString& viewOn,
                       const BSONArray& pipeline) {
-        Lock::DBLock dbLock(operationContext(), viewName.db(), MODE_IX);
+        Lock::DBLock dbLock(operationContext(), viewName.dbName(), MODE_IX);
         Lock::CollectionLock collLock(operationContext(), viewName, MODE_X);
         Lock::CollectionLock sysCollLock(
             operationContext(),
@@ -149,7 +149,7 @@ public:
     }
 
     Status dropView(OperationContext* opCtx, const NamespaceString& viewName) {
-        Lock::DBLock dbLock(operationContext(), viewName.db(), MODE_IX);
+        Lock::DBLock dbLock(operationContext(), viewName.dbName(), MODE_IX);
         Lock::CollectionLock collLock(operationContext(), viewName, MODE_IX);
         Lock::CollectionLock sysCollLock(
             operationContext(),
@@ -169,7 +169,7 @@ public:
 
     std::shared_ptr<const ViewDefinition> lookup(OperationContext* opCtx,
                                                  const NamespaceString& ns) {
-        Lock::DBLock dbLock(operationContext(), NamespaceString(ns).db(), MODE_IS);
+        Lock::DBLock dbLock(operationContext(), ns.dbName(), MODE_IS);
         return getCatalog()->lookupView(operationContext(), ns);
     }
 
@@ -525,7 +525,7 @@ TEST_F(ViewCatalogFixture, LookupRIDExistingViewRollback) {
     const NamespaceString viewName("db.view");
     const NamespaceString viewOn("db.coll");
     {
-        Lock::DBLock dbLock(operationContext(), viewName.db(), MODE_X);
+        Lock::DBLock dbLock(operationContext(), viewName.dbName(), MODE_X);
         Lock::CollectionLock collLock(operationContext(), viewName, MODE_IX);
         Lock::CollectionLock sysCollLock(
             operationContext(),
@@ -568,7 +568,7 @@ TEST_F(ViewCatalogFixture, LookupRIDAfterDropRollback) {
     }
 
     {
-        Lock::DBLock dbLock(operationContext(), viewName.db(), MODE_X);
+        Lock::DBLock dbLock(operationContext(), viewName.dbName(), MODE_X);
         Lock::CollectionLock collLock(operationContext(), viewName, MODE_IX);
         Lock::CollectionLock sysCollLock(
             operationContext(),
@@ -606,7 +606,7 @@ TEST_F(ViewCatalogFixture, LookupRIDAfterModifyRollback) {
     }
 
     {
-        Lock::DBLock dbLock(operationContext(), viewName.db(), MODE_IX);
+        Lock::DBLock dbLock(operationContext(), viewName.dbName(), MODE_IX);
         Lock::CollectionLock collLock(operationContext(), viewName, MODE_X);
         Lock::CollectionLock sysCollLock(
             operationContext(),
@@ -648,15 +648,14 @@ TEST_F(ViewCatalogFixture, Iterate) {
 
     std::set<std::string> viewNames = {"db.view1", "db.view2", "db.view3"};
 
-    Lock::DBLock dbLock(operationContext(), "db", MODE_IX);
-    getCatalog()->iterateViews(operationContext(),
-                               DatabaseName(boost::none, "db"),
-                               [&viewNames](const ViewDefinition& view) {
-                                   std::string name = view.name().toString();
-                                   ASSERT(viewNames.end() != viewNames.find(name));
-                                   viewNames.erase(name);
-                                   return true;
-                               });
+    Lock::DBLock dbLock(operationContext(), view1.dbName(), MODE_IX);
+    getCatalog()->iterateViews(
+        operationContext(), view1.dbName(), [&viewNames](const ViewDefinition& view) {
+            std::string name = view.name().toString();
+            ASSERT(viewNames.end() != viewNames.find(name));
+            viewNames.erase(name);
+            return true;
+        });
 
     ASSERT(viewNames.empty());
 }
@@ -678,7 +677,7 @@ TEST_F(ViewCatalogFixture, ResolveViewCorrectPipeline) {
     ASSERT_OK(createView(operationContext(), view2, view1, pipeline2.arr(), emptyCollation));
     ASSERT_OK(createView(operationContext(), view3, view2, pipeline3.arr(), emptyCollation));
 
-    Lock::DBLock dbLock(operationContext(), "db", MODE_IX);
+    Lock::DBLock dbLock(operationContext(), view1.dbName(), MODE_IX);
     auto resolvedView =
         view_catalog_helpers::resolveView(operationContext(), getCatalog(), view3, boost::none);
     ASSERT(resolvedView.isOK());
@@ -699,7 +698,7 @@ TEST_F(ViewCatalogFixture, ResolveViewCorrectPipeline) {
 TEST_F(ViewCatalogFixture, ResolveViewOnCollectionNamespace) {
     const NamespaceString collectionNamespace("db.coll");
 
-    Lock::DBLock dbLock(operationContext(), "db", MODE_IS);
+    Lock::DBLock dbLock(operationContext(), collectionNamespace.dbName(), MODE_IS);
     auto resolvedView = uassertStatusOK(view_catalog_helpers::resolveView(
         operationContext(), getCatalog(), collectionNamespace, boost::none));
 
@@ -723,7 +722,7 @@ TEST_F(ViewCatalogFixture, ResolveViewCorrectlyExtractsDefaultCollation) {
     ASSERT_OK(createView(operationContext(), view1, viewOn, pipeline1.arr(), collation));
     ASSERT_OK(createView(operationContext(), view2, view1, pipeline2.arr(), collation));
 
-    Lock::DBLock dbLock(operationContext(), "db", MODE_IS);
+    Lock::DBLock dbLock(operationContext(), view1.dbName(), MODE_IS);
     auto resolvedView =
         view_catalog_helpers::resolveView(operationContext(), getCatalog(), view2, boost::none);
     ASSERT(resolvedView.isOK());