SERVER-58989 Make timestamp required in DatabaseVersionBase IDL

13 files changed, 58 insertions, 132 deletions

diff --git a/src/mongo/s/build_versioned_requests_for_targeted_shards_test.cpp b/src/mongo/s/build_versioned_requests_for_targeted_shards_test.cpp
index accbd515922..f82794e31f3 100644
--- a/src/mongo/s/build_versioned_requests_for_targeted_shards_test.cpp
+++ b/src/mongo/s/build_versioned_requests_for_targeted_shards_test.cpp
@@ -73,7 +73,8 @@ protected:
 
     void expectGetDatabaseUnsharded() {
         expectFindSendBSONObjVector(kConfigHostAndPort, [&]() {
-            DatabaseType db(kNss.db().toString(), {"0"}, false, DatabaseVersion(UUID::gen()));
+            DatabaseType db(
+                kNss.db().toString(), {"0"}, false, DatabaseVersion(UUID::gen(), Timestamp()));
             return std::vector<BSONObj>{db.toBSON()};
         }());
     }
diff --git a/src/mongo/s/catalog/sharding_catalog_client_test.cpp b/src/mongo/s/catalog/sharding_catalog_client_test.cpp
index 54528489f36..cd23a564d32 100644
--- a/src/mongo/s/catalog/sharding_catalog_client_test.cpp
+++ b/src/mongo/s/catalog/sharding_catalog_client_test.cpp
@@ -158,7 +158,8 @@ TEST_F(ShardingCatalogClientTest, GetDatabaseInvalidName) {
 TEST_F(ShardingCatalogClientTest, GetDatabaseExisting) {
     configTargeter()->setFindHostReturnValue(HostAndPort("TestHost1"));
 
-    DatabaseType expectedDb("bigdata", ShardId("shard0000"), true, DatabaseVersion(UUID::gen()));
+    DatabaseType expectedDb(
+        "bigdata", ShardId("shard0000"), true, DatabaseVersion(UUID::gen(), Timestamp()));
 
     const OpTime newOpTime(Timestamp(7, 6), 5);
 
@@ -205,7 +206,8 @@ TEST_F(ShardingCatalogClientTest, GetDatabaseStaleSecondaryRetrySuccess) {
     HostAndPort secondHost{"TestHost2"};
     configTargeter()->setFindHostReturnValue(firstHost);
 
-    DatabaseType expectedDb("bigdata", ShardId("shard0000"), true, DatabaseVersion(UUID::gen()));
+    DatabaseType expectedDb(
+        "bigdata", ShardId("shard0000"), true, DatabaseVersion(UUID::gen(), Timestamp()));
 
     auto future = launchAsync([this, &expectedDb] {
         return catalogClient()->getDatabase(
@@ -891,8 +893,10 @@ TEST_F(ShardingCatalogClientTest, GetCollectionsInvalidCollectionType) {
 TEST_F(ShardingCatalogClientTest, GetDatabasesForShardValid) {
     configTargeter()->setFindHostReturnValue(HostAndPort("TestHost1"));
 
-    DatabaseType dbt1("db1", ShardId("shard0000"), false, DatabaseVersion(UUID::gen()));
-    DatabaseType dbt2("db2", ShardId("shard0000"), false, DatabaseVersion(UUID::gen()));
+    DatabaseType dbt1(
+        "db1", ShardId("shard0000"), false, DatabaseVersion(UUID::gen(), Timestamp()));
+    DatabaseType dbt2(
+        "db2", ShardId("shard0000"), false, DatabaseVersion(UUID::gen(), Timestamp()));
 
     auto future = launchAsync([this] {
         return assertGet(
@@ -934,7 +938,7 @@ TEST_F(ShardingCatalogClientTest, GetDatabasesForShardInvalidDoc) {
     });
 
     onFindCommand([](const RemoteCommandRequest& request) {
-        DatabaseType dbt1("db1", {"shard0000"}, false, DatabaseVersion(UUID::gen()));
+        DatabaseType dbt1("db1", {"shard0000"}, false, DatabaseVersion(UUID::gen(), Timestamp()));
         return vector<BSONObj>{
             dbt1.toBSON(),
             BSON(DatabaseType::name() << 0)  // DatabaseType::name() should be a string
@@ -1039,7 +1043,7 @@ TEST_F(ShardingCatalogClientTest, GetTagsForCollectionInvalidTag) {
 TEST_F(ShardingCatalogClientTest, UpdateDatabase) {
     configTargeter()->setFindHostReturnValue(HostAndPort("TestHost1"));
 
-    DatabaseType dbt("test", ShardId("shard0000"), true, DatabaseVersion(UUID::gen()));
+    DatabaseType dbt("test", ShardId("shard0000"), true, DatabaseVersion(UUID::gen(), Timestamp()));
 
     auto future = launchAsync([this, dbt] {
         auto status =
@@ -1086,7 +1090,8 @@ TEST_F(ShardingCatalogClientTest, UpdateConfigDocumentNonRetryableError) {
     HostAndPort host1("TestHost1");
     configTargeter()->setFindHostReturnValue(host1);
 
-    DatabaseType dbt("test", ShardId("shard0001"), false, DatabaseVersion(UUID::gen()));
+    DatabaseType dbt(
+        "test", ShardId("shard0001"), false, DatabaseVersion(UUID::gen(), Timestamp()));
 
     auto future = launchAsync([this, dbt] {
         auto status =
@@ -1287,7 +1292,8 @@ TEST_F(ShardingCatalogClientTest, RetryOnFindCommandNetworkErrorSucceedsAtMaxRet
     }
 
     onFindCommand([](const RemoteCommandRequest& request) {
-        DatabaseType dbType("TestDB", ShardId("TestShard"), true, DatabaseVersion(UUID::gen()));
+        DatabaseType dbType(
+            "TestDB", ShardId("TestShard"), true, DatabaseVersion(UUID::gen(), Timestamp()));
 
         return vector<BSONObj>{dbType.toBSON()};
     });
diff --git a/src/mongo/s/catalog/type_database_test.cpp b/src/mongo/s/catalog/type_database_test.cpp
index 8a9eb73dcda..fe126d6b390 100644
--- a/src/mongo/s/catalog/type_database_test.cpp
+++ b/src/mongo/s/catalog/type_database_test.cpp
@@ -47,10 +47,12 @@ TEST(DatabaseType, Empty) {
 
 TEST(DatabaseType, Basic) {
     UUID uuid = UUID::gen();
+    Timestamp timestamp = Timestamp();
     StatusWith<DatabaseType> status = DatabaseType::fromBSON(
         BSON(DatabaseType::name("mydb")
              << DatabaseType::primary("shard") << DatabaseType::sharded(true)
-             << DatabaseType::version(BSON("uuid" << uuid << "lastMod" << 0))));
+             << DatabaseType::version(
+                    BSON("uuid" << uuid << "lastMod" << 0 << "timestamp" << timestamp))));
     ASSERT_TRUE(status.isOK());
 
     DatabaseType db = status.getValue();
diff --git a/src/mongo/s/catalog_cache_refresh_test.cpp b/src/mongo/s/catalog_cache_refresh_test.cpp
index 6a527696088..9560317bc54 100644
--- a/src/mongo/s/catalog_cache_refresh_test.cpp
+++ b/src/mongo/s/catalog_cache_refresh_test.cpp
@@ -59,7 +59,8 @@ protected:
 
     void expectGetDatabase() {
         expectFindSendBSONObjVector(kConfigHostAndPort, [&]() {
-            DatabaseType db(kNss.db().toString(), {"0"}, true, DatabaseVersion(UUID::gen()));
+            DatabaseType db(
+                kNss.db().toString(), {"0"}, true, DatabaseVersion(UUID::gen(), Timestamp()));
             return std::vector<BSONObj>{db.toBSON()};
         }());
     }
diff --git a/src/mongo/s/catalog_cache_test.cpp b/src/mongo/s/catalog_cache_test.cpp
index 0d6827577ff..5e5d41c7df8 100644
--- a/src/mongo/s/catalog_cache_test.cpp
+++ b/src/mongo/s/catalog_cache_test.cpp
@@ -181,7 +181,7 @@ protected:
 
 TEST_F(CatalogCacheTest, GetDatabase) {
     const auto dbName = "testDB";
-    const auto dbVersion = DatabaseVersion(UUID::gen());
+    const auto dbVersion = DatabaseVersion(UUID::gen(), Timestamp());
     _catalogCacheLoader->setDatabaseRefreshReturnValue(
         DatabaseType(dbName, kShards[0], true, dbVersion));
 
@@ -197,7 +197,7 @@ TEST_F(CatalogCacheTest, GetDatabase) {
 
 TEST_F(CatalogCacheTest, GetCachedDatabase) {
     const auto dbName = "testDB";
-    const auto dbVersion = DatabaseVersion(UUID::gen());
+    const auto dbVersion = DatabaseVersion(UUID::gen(), Timestamp());
     loadDatabases({DatabaseType(dbName, kShards[0], true, dbVersion)});
 
     const auto swDatabase = _catalogCache->getDatabase(operationContext(), dbName);
@@ -212,7 +212,7 @@ TEST_F(CatalogCacheTest, GetCachedDatabase) {
 
 TEST_F(CatalogCacheTest, InvalidateSingleDbOnShardRemoval) {
     const auto dbName = "testDB";
-    const auto dbVersion = DatabaseVersion(UUID::gen());
+    const auto dbVersion = DatabaseVersion(UUID::gen(), Timestamp());
     loadDatabases({DatabaseType(dbName, kShards[0], true, dbVersion)});
 
     _catalogCache->invalidateEntriesThatReferenceShard(kShards[0]);
@@ -227,7 +227,7 @@ TEST_F(CatalogCacheTest, InvalidateSingleDbOnShardRemoval) {
 
 TEST_F(CatalogCacheTest, OnStaleDatabaseVersionNoVersion) {
     // onStaleDatabaseVesrsion must invalidate the database entry if invoked with no version
-    const auto dbVersion = DatabaseVersion(UUID::gen());
+    const auto dbVersion = DatabaseVersion(UUID::gen(), Timestamp());
     loadDatabases({DatabaseType(kNss.db().toString(), kShards[0], true, dbVersion)});
 
     _catalogCache->onStaleDatabaseVersion(kNss.db(), boost::none);
@@ -237,7 +237,7 @@ TEST_F(CatalogCacheTest, OnStaleDatabaseVersionNoVersion) {
 }
 
 TEST_F(CatalogCacheTest, OnStaleShardVersionWithSameVersion) {
-    const auto dbVersion = DatabaseVersion(UUID::gen());
+    const auto dbVersion = DatabaseVersion(UUID::gen(), Timestamp());
     const auto cachedCollVersion = ChunkVersion(1, 0, OID::gen(), boost::none /* timestamp */);
 
     loadDatabases({DatabaseType(kNss.db().toString(), kShards[0], true, dbVersion)});
@@ -248,7 +248,7 @@ TEST_F(CatalogCacheTest, OnStaleShardVersionWithSameVersion) {
 }
 
 TEST_F(CatalogCacheTest, OnStaleShardVersionWithNoVersion) {
-    const auto dbVersion = DatabaseVersion(UUID::gen());
+    const auto dbVersion = DatabaseVersion(UUID::gen(), Timestamp());
     const auto cachedCollVersion = ChunkVersion(1, 0, OID::gen(), boost::none /* timestamp */);
 
     loadDatabases({DatabaseType(kNss.db().toString(), kShards[0], true, dbVersion)});
@@ -261,7 +261,7 @@ TEST_F(CatalogCacheTest, OnStaleShardVersionWithNoVersion) {
 }
 
 TEST_F(CatalogCacheTest, OnStaleShardVersionWithGraterVersion) {
-    const auto dbVersion = DatabaseVersion(UUID::gen());
+    const auto dbVersion = DatabaseVersion(UUID::gen(), Timestamp());
     const auto cachedCollVersion = ChunkVersion(1, 0, OID::gen(), boost::none /* timestamp */);
     const auto wantedCollVersion =
         ChunkVersion(2, 0, cachedCollVersion.epoch(), cachedCollVersion.getTimestamp());
@@ -278,7 +278,7 @@ TEST_F(CatalogCacheTest, OnStaleShardVersionWithGraterVersion) {
 TEST_F(CatalogCacheTest, GetDatabaseWithMetadataFormatChange) {
     const auto dbName = "testDB";
     const auto uuid = UUID::gen();
-    const DatabaseVersion versionWithoutTimestamp(uuid);
+    const DatabaseVersion versionWithoutTimestamp(uuid, Timestamp());
     const DatabaseVersion versionWithTimestamp(uuid, Timestamp(42));
 
     auto getDatabaseWithRefreshAndCheckResults = [&](const DatabaseVersion& version) {
@@ -303,7 +303,7 @@ TEST_F(CatalogCacheTest, GetDatabaseWithMetadataFormatChange) {
 }
 
 TEST_F(CatalogCacheTest, GetCollectionWithMetadataFormatChange) {
-    const auto dbVersion = DatabaseVersion(UUID::gen());
+    const auto dbVersion = DatabaseVersion(UUID::gen(), Timestamp());
     const auto epoch = OID::gen();
     const auto collVersionWithoutTimestamp = ChunkVersion(1, 0, epoch, boost::none /* timestamp */);
     const auto collVersionWithTimestamp = ChunkVersion(1, 0, epoch, Timestamp(42));
@@ -342,7 +342,7 @@ TEST_F(CatalogCacheTest, GetCollectionWithMetadataFormatChange) {
 
 TEST_F(CatalogCacheTest,
        GetCollectionWithRefreshDuringUpgradeWithMetadataFormatChangeChunksDontMatchCollection) {
-    const auto dbVersion = DatabaseVersion(UUID::gen());
+    const auto dbVersion = DatabaseVersion(UUID::gen(), Timestamp());
     const auto epoch = OID::gen();
     const auto timestamp = Timestamp(42);
 
@@ -372,7 +372,7 @@ TEST_F(CatalogCacheTest,
 
 TEST_F(CatalogCacheTest,
        GetCollectionWithRefreshDuringUpgradeWithMetadataFormatChangeSomeChunksMatchCollection) {
-    const auto dbVersion = DatabaseVersion(UUID::gen());
+    const auto dbVersion = DatabaseVersion(UUID::gen(), Timestamp());
     const auto epoch = OID::gen();
     const auto timestamp = Timestamp(42);
 
@@ -409,7 +409,7 @@ TEST_F(CatalogCacheTest,
 }
 
 TEST_F(CatalogCacheTest, GetCollectionWithRefreshDuringDowngradeWithMetadataFormatChange) {
-    const auto dbVersion = DatabaseVersion(UUID::gen());
+    const auto dbVersion = DatabaseVersion(UUID::gen(), Timestamp());
     const auto epoch = OID::gen();
     const auto timestamp = Timestamp(42);
 
@@ -438,7 +438,7 @@ TEST_F(CatalogCacheTest, GetCollectionWithRefreshDuringDowngradeWithMetadataForm
 }
 
 TEST_F(CatalogCacheTest, TimeseriesFieldsAreProperlyPropagatedOnCC) {
-    const auto dbVersion = DatabaseVersion(UUID::gen());
+    const auto dbVersion = DatabaseVersion(UUID::gen(), Timestamp());
     const auto epoch = OID::gen();
     const auto version = ChunkVersion(1, 0, epoch, Timestamp(42));
 
@@ -461,7 +461,7 @@ TEST_F(CatalogCacheTest, TimeseriesFieldsAreProperlyPropagatedOnCC) {
 }
 
 TEST_F(CatalogCacheTest, LookupCollectionWithInvalidOptions) {
-    const auto dbVersion = DatabaseVersion(UUID::gen());
+    const auto dbVersion = DatabaseVersion(UUID::gen(), Timestamp());
     const auto epoch = OID::gen();
     const auto version = ChunkVersion(1, 0, epoch, Timestamp(42));
 
diff --git a/src/mongo/s/catalog_cache_test_fixture.cpp b/src/mongo/s/catalog_cache_test_fixture.cpp
index 30ac640025c..975c8804914 100644
--- a/src/mongo/s/catalog_cache_test_fixture.cpp
+++ b/src/mongo/s/catalog_cache_test_fixture.cpp
@@ -133,7 +133,8 @@ ChunkManager CatalogCacheTestFixture::makeChunkManager(
     ChunkVersion version(1, 0, OID::gen(), boost::none /* timestamp */);
 
     const BSONObj databaseBSON = [&]() {
-        DatabaseType db(nss.db().toString(), {"0"}, true, DatabaseVersion(UUID::gen()));
+        DatabaseType db(
+            nss.db().toString(), {"0"}, true, DatabaseVersion(UUID::gen(), Timestamp()));
         return db.toBSON();
     }();
 
@@ -194,7 +195,8 @@ ChunkManager CatalogCacheTestFixture::makeChunkManager(
 
 void CatalogCacheTestFixture::expectGetDatabase(NamespaceString nss, std::string shardId) {
     expectFindSendBSONObjVector(kConfigHostAndPort, [&]() {
-        DatabaseType db(nss.db().toString(), {shardId}, true, DatabaseVersion(UUID::gen()));
+        DatabaseType db(
+            nss.db().toString(), {shardId}, true, DatabaseVersion(UUID::gen(), Timestamp()));
         return std::vector<BSONObj>{db.toBSON()};
     }());
 }
diff --git a/src/mongo/s/chunk_manager_query_test.cpp b/src/mongo/s/chunk_manager_query_test.cpp
index 47b325d5414..5d9832ae690 100644
--- a/src/mongo/s/chunk_manager_query_test.cpp
+++ b/src/mongo/s/chunk_manager_query_test.cpp
@@ -533,7 +533,7 @@ TEST_F(ChunkManagerQueryTest, SnapshotQueryWithMoreShardsThanLatestMetadata) {
                        ChunkHistory(Timestamp(1, 0), ShardId("1"))});
 
     ChunkManager chunkManager(ShardId("0"),
-                              DatabaseVersion(UUID::gen()),
+                              DatabaseVersion(UUID::gen(), Timestamp()),
                               makeStandaloneRoutingTableHistory(oldRoutingTable.makeUpdated(
                                   boost::none, boost::none, true, {chunk1})),
                               Timestamp(5, 0));
diff --git a/src/mongo/s/chunk_manager_refresh_bm.cpp b/src/mongo/s/chunk_manager_refresh_bm.cpp
index dd1012548dc..a8c7b626331 100644
--- a/src/mongo/s/chunk_manager_refresh_bm.cpp
+++ b/src/mongo/s/chunk_manager_refresh_bm.cpp
@@ -92,7 +92,7 @@ CollectionMetadata makeChunkManagerWithShardSelector(int nShards,
                                            true,
                                            chunks);
     return CollectionMetadata(ChunkManager(ShardId("Shard0"),
-                                           DatabaseVersion(UUID::gen()),
+                                           DatabaseVersion(UUID::gen(), Timestamp()),
                                            makeStandaloneRoutingTableHistory(std::move(rt)),
                                            boost::none),
                               ShardId("shard0"));
@@ -123,7 +123,7 @@ MONGO_COMPILER_NOINLINE auto runIncrementalUpdate(const CollectionMetadata& cm,
     auto rt = cm.getChunkManager()->getRoutingTableHistory_ForTest().makeUpdated(
         boost::none, boost::none, true, newChunks);
     return CollectionMetadata(ChunkManager(ShardId("shard0"),
-                                           DatabaseVersion(UUID::gen()),
+                                           DatabaseVersion(UUID::gen(), Timestamp()),
                                            makeStandaloneRoutingTableHistory(std::move(rt)),
                                            boost::none),
                               ShardId("shard0"));
@@ -184,7 +184,7 @@ auto BM_FullBuildOfChunkManager(benchmark::State& state, ShardSelectorFn selectS
                                                chunks);
         benchmark::DoNotOptimize(
             CollectionMetadata(ChunkManager(ShardId("shard0"),
-                                            DatabaseVersion(UUID::gen()),
+                                            DatabaseVersion(UUID::gen(), Timestamp()),
                                             makeStandaloneRoutingTableHistory(std::move(rt)),
                                             boost::none),
                                ShardId("shard0")));
diff --git a/src/mongo/s/comparable_database_version_test.cpp b/src/mongo/s/comparable_database_version_test.cpp
index cbf2d9b6869..2e2ce305ed9 100644
--- a/src/mongo/s/comparable_database_version_test.cpp
+++ b/src/mongo/s/comparable_database_version_test.cpp
@@ -42,7 +42,6 @@ TEST(ComparableDatabaseVersionTest, VersionsEqual) {
         ASSERT(version == version);
     };
 
-    versionsEqual(DatabaseVersion(UUID::gen()));
     versionsEqual(DatabaseVersion(UUID::gen(), Timestamp(1)));
 }
 
@@ -53,20 +52,9 @@ TEST(ComparableDatabaseVersionTest, VersionsEqualAfterCopy) {
         ASSERT(version1 == version2);
     };
 
-    versionsEqualAfterCopy(DatabaseVersion(UUID::gen()));
     versionsEqualAfterCopy(DatabaseVersion(UUID::gen(), Timestamp(1)));
 }
 
-TEST(ComparableDatabaseVersionTest, CompareVersionDifferentUuids) {
-    const auto version1 =
-        ComparableDatabaseVersion::makeComparableDatabaseVersion(DatabaseVersion(UUID::gen()));
-    const auto version2 =
-        ComparableDatabaseVersion::makeComparableDatabaseVersion(DatabaseVersion(UUID::gen()));
-    ASSERT(version2 != version1);
-    ASSERT(version2 > version1);
-    ASSERT_FALSE(version2 < version1);
-}
-
 TEST(ComparableDatabaseVersionTest, CompareVersionDifferentTimestamps) {
     const auto version1 = ComparableDatabaseVersion::makeComparableDatabaseVersion(
         DatabaseVersion(UUID::gen(), Timestamp(3)));
@@ -77,57 +65,6 @@ TEST(ComparableDatabaseVersionTest, CompareVersionDifferentTimestamps) {
     ASSERT_FALSE(version2 > version1);
 }
 
-TEST(ComparableDatabaseVersionTest, CompareEpochBasedVersionAgainstEpochAndTimestampBasedVersion) {
-    {
-        auto equalVersions = [](const DatabaseVersion& v1, const DatabaseVersion& v2) {
-            const auto version1 = ComparableDatabaseVersion::makeComparableDatabaseVersion(v1);
-            const auto version2 = ComparableDatabaseVersion::makeComparableDatabaseVersion(v2);
-            ASSERT(version1 == version2);
-            ASSERT_FALSE(version1 < version2);
-            ASSERT_FALSE(version1 > version2);
-        };
-
-        const auto epoch = UUID::gen();
-        const DatabaseVersion v1(epoch);
-        const DatabaseVersion v2(epoch, Timestamp(1));
-        equalVersions(v1, v2);
-        equalVersions(v2, v1);
-    }
-
-    {
-        auto diffVersionsMoreRecentByLastMod = [](const DatabaseVersion& v1,
-                                                  const DatabaseVersion& v2) {
-            const auto version1 = ComparableDatabaseVersion::makeComparableDatabaseVersion(v1);
-            const auto version2 = ComparableDatabaseVersion::makeComparableDatabaseVersion(v2);
-            ASSERT(version1 != version2);
-            ASSERT(version1 > version2);
-            ASSERT_FALSE(version1 < version2);
-        };
-
-        const auto epoch = UUID::gen();
-        const DatabaseVersion v1(epoch);
-        const DatabaseVersion v2(epoch, Timestamp(1));
-        diffVersionsMoreRecentByLastMod(v1.makeUpdated(), v2);
-        diffVersionsMoreRecentByLastMod(v2.makeUpdated(), v1);
-    }
-
-    {
-        auto diffVersionsMoreRecentByDisambigSeqNum = [](const DatabaseVersion& v1,
-                                                         const DatabaseVersion& v2) {
-            const auto version1 = ComparableDatabaseVersion::makeComparableDatabaseVersion(v1);
-            const auto version2 = ComparableDatabaseVersion::makeComparableDatabaseVersion(v2);
-            ASSERT(version1 != version2);
-            ASSERT(version1 < version2);
-            ASSERT_FALSE(version1 > version2);
-        };
-
-        const DatabaseVersion v1(UUID::gen());
-        const DatabaseVersion v2(UUID::gen(), Timestamp(1));
-        diffVersionsMoreRecentByDisambigSeqNum(v1, v2);
-        diffVersionsMoreRecentByDisambigSeqNum(v2, v1);
-    }
-}
-
 TEST(ComparableDatabaseVersionTest, VersionGreaterSameUuidOrTimestamp) {
     auto versionGreaterSameUuidOrTimestamp = [](const DatabaseVersion& v1) {
         const DatabaseVersion v2 = v1.makeUpdated();
@@ -138,8 +75,7 @@ TEST(ComparableDatabaseVersionTest, VersionGreaterSameUuidOrTimestamp) {
         ASSERT_FALSE(version2 < version1);
     };
 
-    versionGreaterSameUuidOrTimestamp(DatabaseVersion(UUID::gen()));
-    versionGreaterSameUuidOrTimestamp(DatabaseVersion(UUID::gen(), Timestamp(1)));
+    versionGreaterSameUuidOrTimestamp(DatabaseVersion(UUID::gen(), Timestamp(0)));
 }
 
 TEST(ComparableDatabaseVersionTest, VersionLessSameUuidOrTimestamp) {
@@ -152,7 +88,6 @@ TEST(ComparableDatabaseVersionTest, VersionLessSameUuidOrTimestamp) {
         ASSERT_FALSE(version1 > version2);
     };
 
-    versionLessSameUuidOrTimestamp(DatabaseVersion(UUID::gen()));
     versionLessSameUuidOrTimestamp(DatabaseVersion(UUID::gen(), Timestamp(1)));
 }
 
@@ -173,8 +108,7 @@ TEST(ComparableDatabaseVersionTest, DefaultConstructedVersionIsAlwaysLess) {
         ASSERT_FALSE(defaultVersion > version1);
     };
 
-    defaultConstructedVersionIsAlwaysLess(DatabaseVersion(UUID::gen()));
-    defaultConstructedVersionIsAlwaysLess(DatabaseVersion(UUID::gen(), Timestamp(1)));
+    defaultConstructedVersionIsAlwaysLess(DatabaseVersion(UUID::gen(), Timestamp()));
 }
 
 TEST(ComparableDatabaseVersionTest, CompareForcedRefreshVersionVersusValidDatabaseVersion) {
@@ -199,9 +133,8 @@ TEST(ComparableDatabaseVersionTest, CompareForcedRefreshVersionVersusValidDataba
         ASSERT(defaultVersionAfterForce < forcedRefreshVersion);
     };
 
-    compareForcedRefreshVersionVersusValidDatabaseVersion(DatabaseVersion(UUID::gen()));
     compareForcedRefreshVersionVersusValidDatabaseVersion(
-        DatabaseVersion(UUID::gen(), Timestamp(1)));
+        DatabaseVersion(UUID::gen(), Timestamp()));
 }
 
 TEST(ComparableDatabaseVersionTest, CompareTwoForcedRefreshVersions) {
diff --git a/src/mongo/s/database_version.cpp b/src/mongo/s/database_version.cpp
index 7ca5de2f01b..3a0af40956a 100644
--- a/src/mongo/s/database_version.cpp
+++ b/src/mongo/s/database_version.cpp
@@ -37,9 +37,8 @@ AtomicWord<uint64_t> ComparableDatabaseVersion::_uuidDisambiguatingSequenceNumSo
 AtomicWord<uint64_t> ComparableDatabaseVersion::_forcedRefreshSequenceNumSource{1ULL};
 
 DatabaseVersion DatabaseVersion::makeFixed() {
-    DatabaseVersion dbVersion;
+    DatabaseVersion dbVersion(UUID::gen(), Timestamp());
     dbVersion.setLastMod(0);
-    dbVersion.setUuid(UUID::gen());
     return dbVersion;
 }
 DatabaseVersion DatabaseVersion::makeUpdated() const {
@@ -104,23 +103,17 @@ bool ComparableDatabaseVersion::operator<(const ComparableDatabaseVersion& other
         return false;  // Only default constructed values have _forcedRefreshSequenceNum == 0 and
                        // they are always equal
 
-    // 1. If both versions are valid and have timestamps
-    //    1.1. if their timestamps are the same -> rely on lastMod to define the order
-    //    1.2. Otherwise  -> rely on the timestamps values to define order
-    // 2. If both versions are valid and have the same uuid -> rely on lastMod to define the order
-    // 3. Any other scenario -> rely on disambiguating sequence number
+    // 1. If both versions are valid
+    // 1.1. If both timestamps are the same -> rely on lastMod to define the order
+    // 1.2. Otherwise  -> rely on the timestamps' values to define order
+    // 2. Any other scenario -> rely on disambiguating sequence number
     if (_dbVersion && other._dbVersion) {
         const auto timestamp = _dbVersion->getTimestamp();
         const auto otherTimestamp = other._dbVersion->getTimestamp();
-        if (timestamp && otherTimestamp) {
-            if (*timestamp == *otherTimestamp)
-                return _dbVersion->getLastMod() < other._dbVersion->getLastMod();
-            else
-                return *timestamp < *otherTimestamp;
-
-        } else if (_dbVersion->getUuid() == other._dbVersion->getUuid()) {
+        if (timestamp == otherTimestamp)
             return _dbVersion->getLastMod() < other._dbVersion->getLastMod();
-        }
+        else
+            return timestamp < otherTimestamp;
     }
 
     return _uuidDisambiguatingSequenceNum < other._uuidDisambiguatingSequenceNum;
diff --git a/src/mongo/s/database_version.h b/src/mongo/s/database_version.h
index 2bfad7d883d..87ecdb6b371 100644
--- a/src/mongo/s/database_version.h
+++ b/src/mongo/s/database_version.h
@@ -47,8 +47,6 @@ class DatabaseVersion : public DatabaseVersionBase {
 public:
     using DatabaseVersionBase::getTimestamp;
 
-    DatabaseVersion() = default;
-
     explicit DatabaseVersion(const BSONObj& obj) {
         DatabaseVersionBase::parseProtected(IDLParserErrorContext("DatabaseVersion"), obj);
     }
@@ -56,18 +54,11 @@ public:
     explicit DatabaseVersion(const DatabaseVersionBase& dbv) : DatabaseVersionBase(dbv) {}
 
     /**
-     * Constructor of a DatabaseVersion based on epochs
-     */
-    explicit DatabaseVersion(mongo::UUID uuid)
-        : DatabaseVersion(uuid, boost::none /* timestamp */) {}
-
-    /**
      * Constructor of a DatabaseVersion based on epochs and timestamps
      */
-    DatabaseVersion(mongo::UUID uuid, boost::optional<mongo::Timestamp> timestamp)
-        : DatabaseVersionBase(1 /* lastMod */) {
+    DatabaseVersion(mongo::UUID uuid, mongo::Timestamp timestamp)
+        : DatabaseVersionBase(timestamp, 1 /* lastMod */) {
         setUuid(uuid);
-        setTimestamp(timestamp);
     }
 
     // Returns a new hardcoded DatabaseVersion value, which is used to distinguish databases that do
diff --git a/src/mongo/s/database_version.idl b/src/mongo/s/database_version.idl
index 557c1d1d6b9..9b073f5a34e 100644
--- a/src/mongo/s/database_version.idl
+++ b/src/mongo/s/database_version.idl
@@ -48,10 +48,7 @@ structs:
                 optional: true
             timestamp:
                 type: timestamp
-                description: "Uniquely identifies to distinguish different incarnations of this database
-                              It is optional for parsing purposes, because in versions of MongoDB
-                              prior to 5.0, this value wasn't being written."
-                optional: true
+                description: "Uniquely identifies to distinguish different incarnations of this database."
             lastMod:
                 type: int
                 description: "an integer which is bumped whenever the database's primary shard changes"
diff --git a/src/mongo/s/write_ops/batch_write_exec_test.cpp b/src/mongo/s/write_ops/batch_write_exec_test.cpp
index ca3bf151737..6f8f077859d 100644
--- a/src/mongo/s/write_ops/batch_write_exec_test.cpp
+++ b/src/mongo/s/write_ops/batch_write_exec_test.cpp
@@ -140,7 +140,7 @@ BSONObj expectInsertsReturnStaleDbVersionErrorsBase(const NamespaceString& nss,
         errorBuilder.append("index", i);
         errorBuilder.append("code", int(ErrorCodes::StaleDbVersion));
 
-        auto dbVersion = DatabaseVersion(UUID::gen());
+        auto dbVersion = DatabaseVersion(UUID::gen(), Timestamp());
         errorBuilder.append("db", nss.db());
         errorBuilder.append("vReceived", dbVersion.toBSON());
         errorBuilder.append("vWanted", dbVersion.makeUpdated().toBSON());