SERVER-32984 clean up DatabaseType class

15 files changed, 94 insertions, 181 deletions

diff --git a/src/mongo/db/s/balancer/migration_manager_test.cpp b/src/mongo/db/s/balancer/migration_manager_test.cpp
index 72a32c50627..89fa1da483d 100644
--- a/src/mongo/db/s/balancer/migration_manager_test.cpp
+++ b/src/mongo/db/s/balancer/migration_manager_test.cpp
@@ -178,10 +178,7 @@ std::shared_ptr<RemoteCommandTargeterMock> MigrationManagerTest::shardTargeterMo
 }
 
 void MigrationManagerTest::setUpDatabase(const std::string& dbName, const ShardId primaryShard) {
-    DatabaseType db;
-    db.setName(dbName);
-    db.setPrimary(primaryShard);
-    db.setSharded(true);
+    DatabaseType db(dbName, primaryShard, true);
     ASSERT_OK(catalogClient()->insertConfigDocument(
         operationContext(), DatabaseType::ConfigNS, db.toBSON(), kMajorityWriteConcern));
 }
diff --git a/src/mongo/s/catalog/sharding_catalog_add_shard_test.cpp b/src/mongo/s/catalog/sharding_catalog_add_shard_test.cpp
index db3b1cdecc6..c2e8d7e9ba6 100644
--- a/src/mongo/s/catalog/sharding_catalog_add_shard_test.cpp
+++ b/src/mongo/s/catalog/sharding_catalog_add_shard_test.cpp
@@ -379,15 +379,8 @@ TEST_F(AddShardTest, StandaloneBasicSuccess) {
     expectedShard.setMaxSizeMB(100);
     expectedShard.setState(ShardType::ShardState::kShardAware);
 
-    DatabaseType discoveredDB1;
-    discoveredDB1.setName("TestDB1");
-    discoveredDB1.setPrimary(ShardId("StandaloneShard"));
-    discoveredDB1.setSharded(false);
-
-    DatabaseType discoveredDB2;
-    discoveredDB2.setName("TestDB2");
-    discoveredDB2.setPrimary(ShardId("StandaloneShard"));
-    discoveredDB2.setSharded(false);
+    DatabaseType discoveredDB1("TestDB1", ShardId("StandaloneShard"), false);
+    DatabaseType discoveredDB2("TestDB2", ShardId("StandaloneShard"), false);
 
     auto future = launchAsync([this, expectedShardName] {
         Client::initThreadIfNotAlready();
@@ -467,15 +460,8 @@ TEST_F(AddShardTest, StandaloneGenerateName) {
     expectedShard.setMaxSizeMB(100);
     expectedShard.setState(ShardType::ShardState::kShardAware);
 
-    DatabaseType discoveredDB1;
-    discoveredDB1.setName("TestDB1");
-    discoveredDB1.setPrimary(ShardId(expectedShardName));
-    discoveredDB1.setSharded(false);
-
-    DatabaseType discoveredDB2;
-    discoveredDB2.setName("TestDB2");
-    discoveredDB2.setPrimary(ShardId(expectedShardName));
-    discoveredDB2.setSharded(false);
+    DatabaseType discoveredDB1("TestDB1", ShardId(expectedShardName), false);
+    DatabaseType discoveredDB2("TestDB2", ShardId(expectedShardName), false);
 
     auto future = launchAsync([this, &expectedShardName, &shardTarget] {
         Client::initThreadIfNotAlready();
@@ -814,10 +800,7 @@ TEST_F(AddShardTest, ShardContainsExistingDatabase) {
     targeterFactory()->addTargeterToReturn(connString, std::move(targeter));
     std::string expectedShardName = "mySet";
 
-    DatabaseType existingDB;
-    existingDB.setName("existing");
-    existingDB.setPrimary(ShardId("existingShard"));
-    existingDB.setSharded(false);
+    DatabaseType existingDB("existing", ShardId("existingShard"), false);
 
     // Add a pre-existing database.
     ASSERT_OK(catalogClient()->insertConfigDocument(operationContext(),
@@ -872,10 +855,7 @@ TEST_F(AddShardTest, SuccessfullyAddReplicaSet) {
     expectedShard.setMaxSizeMB(100);
     expectedShard.setState(ShardType::ShardState::kShardAware);
 
-    DatabaseType discoveredDB;
-    discoveredDB.setName("shardDB");
-    discoveredDB.setPrimary(ShardId(expectedShardName));
-    discoveredDB.setSharded(false);
+    DatabaseType discoveredDB("shardDB", ShardId(expectedShardName), false);
 
     auto future = launchAsync([this, &expectedShardName, &connString] {
         Client::initThreadIfNotAlready();
@@ -939,10 +919,7 @@ TEST_F(AddShardTest, ReplicaSetExtraHostsDiscovered) {
     expectedShard.setMaxSizeMB(100);
     expectedShard.setState(ShardType::ShardState::kShardAware);
 
-    DatabaseType discoveredDB;
-    discoveredDB.setName("shardDB");
-    discoveredDB.setPrimary(ShardId(expectedShardName));
-    discoveredDB.setSharded(false);
+    DatabaseType discoveredDB("shardDB", ShardId(expectedShardName), false);
 
     auto future = launchAsync([this, &expectedShardName, &seedString] {
         Client::initThreadIfNotAlready();
@@ -1007,15 +984,8 @@ TEST_F(AddShardTest, AddShardSucceedsEvenIfAddingDBsFromNewShardFails) {
     expectedShard.setMaxSizeMB(100);
     expectedShard.setState(ShardType::ShardState::kShardAware);
 
-    DatabaseType discoveredDB1;
-    discoveredDB1.setName("TestDB1");
-    discoveredDB1.setPrimary(ShardId("StandaloneShard"));
-    discoveredDB1.setSharded(false);
-
-    DatabaseType discoveredDB2;
-    discoveredDB2.setName("TestDB2");
-    discoveredDB2.setPrimary(ShardId("StandaloneShard"));
-    discoveredDB2.setSharded(false);
+    DatabaseType discoveredDB1("TestDB1", ShardId("StandaloneShard"), false);
+    DatabaseType discoveredDB2("TestDB2", ShardId("StandaloneShard"), false);
 
     // Enable fail point to cause all updates to fail.  Since we add the databases detected from
     // the shard being added with upserts, but we add the shard document itself via insert, this
diff --git a/src/mongo/s/catalog/sharding_catalog_client_impl.cpp b/src/mongo/s/catalog/sharding_catalog_client_impl.cpp
index bf99877d6df..a05befab239 100644
--- a/src/mongo/s/catalog/sharding_catalog_client_impl.cpp
+++ b/src/mongo/s/catalog/sharding_catalog_client_impl.cpp
@@ -258,21 +258,13 @@ StatusWith<repl::OpTimeWith<DatabaseType>> ShardingCatalogClientImpl::getDatabas
 
     // The admin database is always hosted on the config server.
     if (dbName == "admin") {
-        DatabaseType dbt;
-        dbt.setName(dbName);
-        dbt.setSharded(false);
-        dbt.setPrimary(ShardRegistry::kConfigServerShardId);
-
+        DatabaseType dbt(dbName, ShardRegistry::kConfigServerShardId, false);
         return repl::OpTimeWith<DatabaseType>(dbt);
     }
 
     // The config database's primary shard is always config, and it is always sharded.
     if (dbName == "config") {
-        DatabaseType dbt;
-        dbt.setName(dbName);
-        dbt.setSharded(true);
-        dbt.setPrimary(ShardRegistry::kConfigServerShardId);
-
+        DatabaseType dbt(dbName, ShardRegistry::kConfigServerShardId, true);
         return repl::OpTimeWith<DatabaseType>(dbt);
     }
 
diff --git a/src/mongo/s/catalog/sharding_catalog_manager_database_operations.cpp b/src/mongo/s/catalog/sharding_catalog_manager_database_operations.cpp
index a3e5c724208..be0e5839d2d 100644
--- a/src/mongo/s/catalog/sharding_catalog_manager_database_operations.cpp
+++ b/src/mongo/s/catalog/sharding_catalog_manager_database_operations.cpp
@@ -107,10 +107,7 @@ DatabaseType ShardingCatalogManager::createDatabase(OperationContext* opCtx,
     log() << "Placing [" << dbName << "] on: " << primaryShardId;
 
     // Insert an entry for the new database into the sharding catalog.
-    DatabaseType db;
-    db.setName(dbName);
-    db.setPrimary(primaryShardId);
-    db.setSharded(false);
+    DatabaseType db(dbName, primaryShardId, false);
     uassertStatusOK(Grid::get(opCtx)->catalogClient()->insertConfigDocument(
         opCtx, DatabaseType::ConfigNS, db.toBSON(), ShardingCatalogClient::kMajorityWriteConcern));
 
diff --git a/src/mongo/s/catalog/sharding_catalog_manager_shard_operations.cpp b/src/mongo/s/catalog/sharding_catalog_manager_shard_operations.cpp
index ebbcb8d253a..ac2582a27f7 100644
--- a/src/mongo/s/catalog/sharding_catalog_manager_shard_operations.cpp
+++ b/src/mongo/s/catalog/sharding_catalog_manager_shard_operations.cpp
@@ -698,11 +698,7 @@ StatusWith<std::string> ShardingCatalogManager::addShard(
 
     // Add all databases which were discovered on the new shard
     for (const auto& dbName : dbNamesStatus.getValue()) {
-        DatabaseType dbt;
-        dbt.setName(dbName);
-        dbt.setPrimary(shardType.getName());
-        dbt.setSharded(false);
-
+        DatabaseType dbt(dbName, shardType.getName(), false);
         Status status = Grid::get(opCtx)->catalogClient()->updateDatabase(opCtx, dbName, dbt);
         if (!status.isOK()) {
             log() << "adding shard " << shardConnectionString.toString()
diff --git a/src/mongo/s/catalog/sharding_catalog_shard_collection_test.cpp b/src/mongo/s/catalog/sharding_catalog_shard_collection_test.cpp
index 6bf42c0609f..c2d150bbe3f 100644
--- a/src/mongo/s/catalog/sharding_catalog_shard_collection_test.cpp
+++ b/src/mongo/s/catalog/sharding_catalog_shard_collection_test.cpp
@@ -233,10 +233,6 @@ TEST_F(ShardCollectionTest, withInitialChunks) {
 
     ASSERT_OK(setupShards(vector<ShardType>{shard0, shard1, shard2}));
 
-    DatabaseType db;
-    db.setName("db1");
-    db.setPrimary(shard0.getName());
-    db.setSharded(true);
     setupDatabase(kNamespace.db().toString(), shard0.getName(), true);
 
     ShardKeyPattern keyPattern(BSON("_id" << 1));
diff --git a/src/mongo/s/catalog/sharding_catalog_test.cpp b/src/mongo/s/catalog/sharding_catalog_test.cpp
index fbeb94d178d..7db7cedaf2a 100644
--- a/src/mongo/s/catalog/sharding_catalog_test.cpp
+++ b/src/mongo/s/catalog/sharding_catalog_test.cpp
@@ -159,11 +159,7 @@ TEST_F(ShardingCatalogClientTest, GetDatabaseInvalidName) {
 TEST_F(ShardingCatalogClientTest, GetDatabaseExisting) {
     configTargeter()->setFindHostReturnValue(HostAndPort("TestHost1"));
 
-    DatabaseType expectedDb;
-    expectedDb.setName("bigdata");
-    expectedDb.setPrimary(ShardId("shard0000"));
-    expectedDb.setSharded(true);
-    expectedDb.setVersion(Versioning::newDatabaseVersion());
+    DatabaseType expectedDb("bigdata", ShardId("shard0000"), true);
 
     const OpTime newOpTime(Timestamp(7, 6), 5);
 
@@ -207,11 +203,7 @@ TEST_F(ShardingCatalogClientTest, GetDatabaseStaleSecondaryRetrySuccess) {
     HostAndPort secondHost{"TestHost2"};
     configTargeter()->setFindHostReturnValue(firstHost);
 
-    DatabaseType expectedDb;
-    expectedDb.setName("bigdata");
-    expectedDb.setPrimary(ShardId("shard0000"));
-    expectedDb.setSharded(true);
-    expectedDb.setVersion(Versioning::newDatabaseVersion());
+    DatabaseType expectedDb("bigdata", ShardId("shard0000"), true);
 
     auto future = launchAsync([this, &expectedDb] {
         return assertGet(
@@ -938,13 +930,8 @@ TEST_F(ShardingCatalogClientTest, GetCollectionsInvalidCollectionType) {
 TEST_F(ShardingCatalogClientTest, GetDatabasesForShardValid) {
     configTargeter()->setFindHostReturnValue(HostAndPort("TestHost1"));
 
-    DatabaseType dbt1;
-    dbt1.setName("db1");
-    dbt1.setPrimary(ShardId("shard0000"));
-
-    DatabaseType dbt2;
-    dbt2.setName("db2");
-    dbt2.setPrimary(ShardId("shard0000"));
+    DatabaseType dbt1("db1", ShardId("shard0000"), false);
+    DatabaseType dbt2("db2", ShardId("shard0000"), false);
 
     auto future = launchAsync([this] {
         return assertGet(
@@ -987,10 +974,7 @@ TEST_F(ShardingCatalogClientTest, GetDatabasesForShardInvalidDoc) {
     });
 
     onFindCommand([](const RemoteCommandRequest& request) {
-        DatabaseType dbt1;
-        dbt1.setName("db1");
-        dbt1.setPrimary(ShardId("shard0000"));
-
+        DatabaseType dbt1("db1", {"shard0000"}, false);
         return vector<BSONObj>{
             dbt1.toBSON(),
             BSON(DatabaseType::name() << 0)  // DatabaseType::name() should be a string
@@ -1096,11 +1080,7 @@ TEST_F(ShardingCatalogClientTest, GetTagsForCollectionInvalidTag) {
 TEST_F(ShardingCatalogClientTest, UpdateDatabase) {
     configTargeter()->setFindHostReturnValue(HostAndPort("TestHost1"));
 
-    DatabaseType dbt;
-    dbt.setName("test");
-    dbt.setPrimary(ShardId("shard0000"));
-    dbt.setSharded(true);
-    dbt.setVersion(Versioning::newDatabaseVersion());
+    DatabaseType dbt("test", ShardId("shard0000"), true);
 
     auto future = launchAsync([this, dbt] {
         auto status = catalogClient()->updateDatabase(operationContext(), dbt.getName(), dbt);
@@ -1141,10 +1121,7 @@ TEST_F(ShardingCatalogClientTest, UpdateDatabaseExceededTimeLimit) {
     HostAndPort host1("TestHost1");
     configTargeter()->setFindHostReturnValue(host1);
 
-    DatabaseType dbt;
-    dbt.setName("test");
-    dbt.setPrimary(ShardId("shard0001"));
-    dbt.setSharded(false);
+    DatabaseType dbt("test", ShardId("shard0001"), false);
 
     auto future = launchAsync([this, dbt] {
         auto status = catalogClient()->updateDatabase(operationContext(), dbt.getName(), dbt);
@@ -1442,10 +1419,7 @@ TEST_F(ShardingCatalogClientTest, ReadAfterOpTimeFindThenCmd) {
             BSONObjBuilder builder;
             metadata.writeToMetadata(&builder).transitional_ignore();
 
-            DatabaseType dbType;
-            dbType.setName("TestDB");
-            dbType.setPrimary(ShardId("TestShard"));
-            dbType.setSharded("true");
+            DatabaseType dbType("TestDB", ShardId("TestShard"), true);
 
             return std::make_tuple(vector<BSONObj>{dbType.toBSON()}, builder.obj());
         });
@@ -1529,10 +1503,7 @@ TEST_F(ShardingCatalogClientTest, ReadAfterOpTimeCmdThenFind) {
         ASSERT_EQ(string("find"), request.cmdObj.firstElementFieldName());
         checkReadConcern(request.cmdObj, highestOpTime.getTimestamp(), highestOpTime.getTerm());
 
-        DatabaseType dbType;
-        dbType.setName("TestDB");
-        dbType.setPrimary(ShardId("TestShard"));
-        dbType.setSharded("true");
+        DatabaseType dbType("TestDB", ShardId("TestShard"), true);
 
         return vector<BSONObj>{dbType.toBSON()};
     });
@@ -1623,10 +1594,7 @@ TEST_F(ShardingCatalogClientTest, RetryOnFindCommandNetworkErrorSucceedsAtMaxRet
     }
 
     onFindCommand([](const RemoteCommandRequest& request) {
-        DatabaseType dbType;
-        dbType.setName("TestDB");
-        dbType.setPrimary(ShardId("TestShard"));
-        dbType.setSharded("true");
+        DatabaseType dbType("TestDB", ShardId("TestShard"), true);
 
         return vector<BSONObj>{dbType.toBSON()};
     });
diff --git a/src/mongo/s/catalog/type_database.cpp b/src/mongo/s/catalog/type_database.cpp
index d3d807c89a1..1c9412d5eec 100644
--- a/src/mongo/s/catalog/type_database.cpp
+++ b/src/mongo/s/catalog/type_database.cpp
@@ -48,76 +48,74 @@ const BSONField<std::string> DatabaseType::primary("primary");
 const BSONField<bool> DatabaseType::sharded("partitioned");
 const BSONField<BSONObj> DatabaseType::version("version");
 
+DatabaseType::DatabaseType(const std::string& dbName,
+                           const ShardId& primaryShard,
+                           bool sharded,
+                           boost::optional<DatabaseVersion> version)
+    : _name(dbName), _primary(primaryShard), _sharded(sharded), _version(version) {}
 
 StatusWith<DatabaseType> DatabaseType::fromBSON(const BSONObj& source) {
-    DatabaseType dbt;
-
+    std::string dbtName;
     {
-        std::string dbtName;
         Status status = bsonExtractStringField(source, name.name(), &dbtName);
         if (!status.isOK())
             return status;
-
-        dbt._name = dbtName;
     }
 
+    std::string dbtPrimary;
     {
-        std::string dbtPrimary;
         Status status = bsonExtractStringField(source, primary.name(), &dbtPrimary);
         if (!status.isOK())
             return status;
-
-        dbt._primary = dbtPrimary;
     }
 
+    bool dbtSharded;
     {
-        bool dbtSharded;
         Status status =
             bsonExtractBooleanFieldWithDefault(source, sharded.name(), false, &dbtSharded);
         if (!status.isOK())
             return status;
-
-        dbt._sharded = dbtSharded;
     }
 
+    boost::optional<DatabaseVersion> dbtVersion = boost::none;
     {
         BSONObj versionField = source.getObjectField("version");
-        // TODO: parse this unconditionally after v4.0.
+        // TODO: Parse this unconditionally once featureCompatibilityVersion 3.6 is no longer
+        // supported.
         if (!versionField.isEmpty()) {
-            dbt._version =
+            dbtVersion =
                 DatabaseVersion::parse(IDLParserErrorContext("DatabaseType"), versionField);
         }
     }
 
-    return StatusWith<DatabaseType>(dbt);
+    return DatabaseType{
+        std::move(dbtName), std::move(dbtPrimary), dbtSharded, std::move(dbtVersion)};
 }
 
 Status DatabaseType::validate() const {
-    if (!_name.is_initialized() || _name->empty()) {
+    if (_name.empty()) {
         return Status(ErrorCodes::NoSuchKey, "missing name");
     }
 
-    if (!_primary.is_initialized() || !_primary->isValid()) {
+    if (!_primary.isValid()) {
         return Status(ErrorCodes::NoSuchKey, "missing primary");
     }
 
-    if (!_sharded.is_initialized()) {
-        return Status(ErrorCodes::NoSuchKey, "missing sharded");
-    }
-
     return Status::OK();
 }
 
 BSONObj DatabaseType::toBSON() const {
     BSONObjBuilder builder;
-    builder.append(name.name(), _name.get_value_or(""));
-    builder.append(primary.name(), _primary.get_value_or(ShardId()).toString());
-    builder.append(sharded.name(), _sharded.get_value_or(false));
 
-    BSONObjBuilder versionBuilder;
-    DatabaseVersion defaultDbv;
-    _version.get_value_or(Versioning::newDatabaseVersion()).serialize(&versionBuilder);
-    builder.append(version.name(), versionBuilder.obj());
+    // Required fields.
+    builder.append(name.name(), _name);
+    builder.append(primary.name(), _primary.toString());
+    builder.append(sharded.name(), _sharded);
+
+    // Optional fields.
+    if (_version) {
+        builder.append(version.name(), _version->toBSON());
+    }
 
     return builder.obj();
 }
@@ -136,4 +134,12 @@ void DatabaseType::setPrimary(const ShardId& primary) {
     _primary = primary;
 }
 
+void DatabaseType::setSharded(bool sharded) {
+    _sharded = sharded;
+}
+
+void DatabaseType::setVersion(const DatabaseVersion& version) {
+    _version = version;
+}
+
 }  // namespace mongo
diff --git a/src/mongo/s/catalog/type_database.h b/src/mongo/s/catalog/type_database.h
index 8b2fcf85c7b..5e8d947ae27 100644
--- a/src/mongo/s/catalog/type_database.h
+++ b/src/mongo/s/catalog/type_database.h
@@ -51,6 +51,19 @@ class StatusWith;
  */
 class DatabaseType {
 public:
+    DatabaseType(const std::string& dbName,
+                 const ShardId& primaryShard,
+                 bool sharded,
+                 boost::optional<DatabaseVersion> = boost::none);
+
+#ifdef _WIN32
+    // TODO: Remove this when Microsoft's implementation of std::future doesn't require a default
+    // constructor.
+    // This type should not normally have a default constructor, however Microsoft's implementation
+    // of future requires one in violation of the standard so we're providing one only for Windows.
+    DatabaseType() = default;
+#endif
+
     // Name of the databases collection in the config server.
     static const NamespaceString ConfigNS;
 
@@ -81,42 +94,31 @@ public:
     std::string toString() const;
 
     const std::string& getName() const {
-        return _name.get();
+        return _name;
     }
     void setName(const std::string& name);
 
     const ShardId& getPrimary() const {
-        return _primary.get();
+        return _primary;
     }
     void setPrimary(const ShardId& primary);
 
     bool getSharded() const {
-        return _sharded.get();
-    }
-    void setSharded(bool sharded) {
-        _sharded = sharded;
-    }
-
-    DatabaseVersion getVersion() const {
-        return _version.get();
+        return _sharded;
     }
+    void setSharded(bool sharded);
 
-    void setVersion(DatabaseVersion version) {
-        _version = std::move(version);
+    boost::optional<DatabaseVersion> getVersion() const {
+        return _version;
     }
+    void setVersion(const DatabaseVersion& version);
 
 private:
-    // Requred database name
-    boost::optional<std::string> _name;
-
-    // Required primary shard (must be set even if the database is sharded, because there
-    // might be collections, which are unsharded).
-    boost::optional<ShardId> _primary;
-
-    // Required whether sharding is enabled for this database. Even though this field is of
-    // type optional, it is only used as an indicator that the value was explicitly set.
-    boost::optional<bool> _sharded;
+    std::string _name;
+    ShardId _primary;
+    bool _sharded;
 
+    // Optional while featureCompatibilityVersion 3.6 is supported.
     boost::optional<DatabaseVersion> _version;
 };
 
diff --git a/src/mongo/s/catalog/type_database_test.cpp b/src/mongo/s/catalog/type_database_test.cpp
index 08f13f2e576..86b1975c39e 100644
--- a/src/mongo/s/catalog/type_database_test.cpp
+++ b/src/mongo/s/catalog/type_database_test.cpp
@@ -50,15 +50,15 @@ TEST(DatabaseType, Basic) {
         BSON(DatabaseType::name("mydb")
              << DatabaseType::primary("shard")
              << DatabaseType::sharded(true)
-             << DatabaseType::version(BSON("uuid" << uuid << "version" << 0))));
+             << DatabaseType::version(BSON("uuid" << uuid << "lastMod" << 0))));
     ASSERT_TRUE(status.isOK());
 
     DatabaseType db = status.getValue();
     ASSERT_EQUALS(db.getName(), "mydb");
     ASSERT_EQUALS(db.getPrimary(), "shard");
     ASSERT_TRUE(db.getSharded());
-    ASSERT_EQUALS(db.getVersion().getUuid(), uuid);
-    ASSERT_EQUALS(db.getVersion().getVersion(), 0);
+    ASSERT_EQUALS(db.getVersion()->getUuid(), uuid);
+    ASSERT_EQUALS(db.getVersion()->getLastMod(), 0);
 }
 
 TEST(DatabaseType, BadType) {
diff --git a/src/mongo/s/catalog_cache_refresh_test.cpp b/src/mongo/s/catalog_cache_refresh_test.cpp
index 6e8b289a1c9..fc08a4a4fbb 100644
--- a/src/mongo/s/catalog_cache_refresh_test.cpp
+++ b/src/mongo/s/catalog_cache_refresh_test.cpp
@@ -55,11 +55,7 @@ protected:
 
     void expectGetDatabase() {
         expectFindOnConfigSendBSONObjVector([&]() {
-            DatabaseType db;
-            db.setName(kNss.db().toString());
-            db.setPrimary({"0"});
-            db.setSharded(true);
-
+            DatabaseType db(kNss.db().toString(), {"0"}, true);
             return std::vector<BSONObj>{db.toBSON()};
         }());
     }
diff --git a/src/mongo/s/catalog_cache_test_fixture.cpp b/src/mongo/s/catalog_cache_test_fixture.cpp
index 1d50c4d29a3..86890c4a41b 100644
--- a/src/mongo/s/catalog_cache_test_fixture.cpp
+++ b/src/mongo/s/catalog_cache_test_fixture.cpp
@@ -95,11 +95,7 @@ std::shared_ptr<ChunkManager> CatalogCacheTestFixture::makeChunkManager(
     ChunkVersion version(1, 0, OID::gen());
 
     const BSONObj databaseBSON = [&]() {
-        DatabaseType db;
-        db.setName(nss.db().toString());
-        db.setPrimary({"0"});
-        db.setSharded(true);
-
+        DatabaseType db(nss.db().toString(), {"0"}, true);
         return db.toBSON();
     }();
 
diff --git a/src/mongo/s/config_server_test_fixture.cpp b/src/mongo/s/config_server_test_fixture.cpp
index 0ab892018bb..a7e24e34e25 100644
--- a/src/mongo/s/config_server_test_fixture.cpp
+++ b/src/mongo/s/config_server_test_fixture.cpp
@@ -338,10 +338,7 @@ StatusWith<ChunkType> ConfigServerTestFixture::getChunkDoc(OperationContext* opC
 void ConfigServerTestFixture::setupDatabase(const std::string& dbName,
                                             const ShardId primaryShard,
                                             const bool sharded) {
-    DatabaseType db;
-    db.setName(dbName);
-    db.setPrimary(primaryShard);
-    db.setSharded(sharded);
+    DatabaseType db(dbName, primaryShard, sharded);
     ASSERT_OK(catalogClient()->insertConfigDocument(operationContext(),
                                                     DatabaseType::ConfigNS,
                                                     db.toBSON(),
diff --git a/src/mongo/s/database_version.idl b/src/mongo/s/database_version.idl
index 3875144b6bb..0a7e01632fc 100644
--- a/src/mongo/s/database_version.idl
+++ b/src/mongo/s/database_version.idl
@@ -1,4 +1,4 @@
-# Copyright (C) 2017 MongoDB Inc.
+# Copyright (C) 2018 MongoDB Inc.
 #
 # This program is free software: you can redistribute it and/or  modify
 # it under the terms of the GNU Affero General Public License, version 3,
@@ -23,11 +23,11 @@ imports:
 
 structs:
     DatabaseVersion:
-        description: "A type to represent DatabaseVersions"
+        description: "A (UUID, int) pair that uniquely identifies an incarnation of a database in a cluster and reflects changes to the database's primary shard"
         fields:
             uuid:
                 type: uuid
-                description: "UUID, indicating the incarnation of the database"
-            version:
+                description: "a unique identifier to distinguish different incarnations of this database"
+            lastMod:
                 type: int
-                description: "Int32, which is bumped whenever movePrimary is called"
+                description: "an integer which is bumped whenever the database's primary shard changes"
diff --git a/src/mongo/s/versioning.cpp b/src/mongo/s/versioning.cpp
index 9bb751cc131..11b2b4ccb06 100644
--- a/src/mongo/s/versioning.cpp
+++ b/src/mongo/s/versioning.cpp
@@ -36,14 +36,14 @@ namespace mongo {
 
 DatabaseVersion Versioning::newDatabaseVersion() {
     DatabaseVersion dbv;
-    dbv.setVersion(0);
+    dbv.setLastMod(0);
     dbv.setUuid(UUID::gen());
     return dbv;
 }
 
 DatabaseVersion Versioning::incrementDatabaseVersion(const DatabaseVersion& v) {
     DatabaseVersion dbv;
-    dbv.setVersion(v.getVersion() + 1);
+    dbv.setLastMod(v.getLastMod() + 1);
     dbv.setUuid(v.getUuid());
     return dbv;
 }