SERVER-63664 Rename disallowNewDuplicateKeys option to prepareUnique

24 files changed, 109 insertions, 122 deletions

diff --git a/src/mongo/db/catalog/coll_mod.cpp b/src/mongo/db/catalog/coll_mod.cpp
index 10847bfce86..490ab5be065 100644
--- a/src/mongo/db/catalog/coll_mod.cpp
+++ b/src/mongo/db/catalog/coll_mod.cpp
@@ -164,19 +164,18 @@ StatusWith<ParsedCollModRequest> parseCollModRequest(OperationContext* opCtx,
             }
 
             if (!cmdIndex.getExpireAfterSeconds() && !cmdIndex.getHidden() &&
-                !cmdIndex.getUnique() && !cmdIndex.getDisallowNewDuplicateKeys()) {
-                return Status(
-                    ErrorCodes::InvalidOptions,
-                    "no expireAfterSeconds, hidden, unique, or disallowNewDuplicateKeys field");
+                !cmdIndex.getUnique() && !cmdIndex.getPrepareUnique()) {
+                return Status(ErrorCodes::InvalidOptions,
+                              "no expireAfterSeconds, hidden, unique, or prepareUnique field");
             }
 
             auto cmrIndex = &cmr.indexRequest;
             auto indexObj = e.Obj();
 
-            if (cmdIndex.getUnique() || cmdIndex.getDisallowNewDuplicateKeys()) {
+            if (cmdIndex.getUnique() || cmdIndex.getPrepareUnique()) {
                 uassert(ErrorCodes::InvalidOptions,
                         "collMod does not support converting an index to 'unique' or to "
-                        "'disallowNewDuplicateKeys' mode",
+                        "'prepareUnique' mode",
                         feature_flags::gCollModIndexUnique.isEnabled(
                             serverGlobalParams.featureCompatibility));
             }
@@ -276,10 +275,10 @@ StatusWith<ParsedCollModRequest> parseCollModRequest(OperationContext* opCtx,
 
             if (cmdIndex.getUnique()) {
                 // Disallow one-step unique convertion. The user has to set
-                // 'disallowNewDuplicateKeys' to true first.
-                if (!cmrIndex->idx->disallowNewDuplicateKeys()) {
+                // 'prepareUnique' to true first.
+                if (!cmrIndex->idx->prepareUnique()) {
                     return Status(ErrorCodes::InvalidOptions,
-                                  "Cannot make index unique with 'disallowNewDuplicateKeys=false'. "
+                                  "Cannot make index unique with 'prepareUnique=false'. "
                                   "Run collMod to set it first.");
                 }
 
@@ -319,16 +318,14 @@ StatusWith<ParsedCollModRequest> parseCollModRequest(OperationContext* opCtx,
                 }
             }
 
-            if (cmdIndex.getDisallowNewDuplicateKeys()) {
+            if (cmdIndex.getPrepareUnique()) {
                 cmr.numModifications++;
                 // Attempting to modify with the same value should be treated as a no-op.
-                if (cmrIndex->idx->disallowNewDuplicateKeys() ==
-                    *cmdIndex.getDisallowNewDuplicateKeys()) {
-                    indexObjForOplog = indexObjForOplog.removeField(
-                        CollModIndex::kDisallowNewDuplicateKeysFieldName);
+                if (cmrIndex->idx->prepareUnique() == *cmdIndex.getPrepareUnique()) {
+                    indexObjForOplog =
+                        indexObjForOplog.removeField(CollModIndex::kPrepareUniqueFieldName);
                 } else {
-                    cmrIndex->indexDisallowNewDuplicateKeys =
-                        cmdIndex.getDisallowNewDuplicateKeys();
+                    cmrIndex->indexPrepareUnique = cmdIndex.getPrepareUnique();
                 }
             }
 
@@ -473,10 +470,10 @@ StatusWith<ParsedCollModRequest> parseCollModRequest(OperationContext* opCtx,
         oplogEntryBuilder->append(e);
     }
 
-    // Currently disallows the use of 'indexDisallowNewDuplicateKeys' with other collMod options.
-    if (cmr.indexRequest.indexDisallowNewDuplicateKeys && cmr.numModifications > 1) {
+    // Currently disallows the use of 'indexPrepareUnique' with other collMod options.
+    if (cmr.indexRequest.indexPrepareUnique && cmr.numModifications > 1) {
         return {ErrorCodes::InvalidOptions,
-                "disallowNewDuplicateKeys cannot be combined with any other modification."};
+                "prepareUnique cannot be combined with any other modification."};
     }
 
     return {std::move(cmr)};
diff --git a/src/mongo/db/catalog/coll_mod_index.cpp b/src/mongo/db/catalog/coll_mod_index.cpp
index e90ce013a82..6bcb123e3aa 100644
--- a/src/mongo/db/catalog/coll_mod_index.cpp
+++ b/src/mongo/db/catalog/coll_mod_index.cpp
@@ -152,26 +152,25 @@ void _processCollModIndexRequestUnique(OperationContext* opCtx,
 
     *newUnique = true;
     autoColl->getWritableCollection(opCtx)->updateUniqueSetting(opCtx, idx->indexName());
-    // Resets 'disallowNewDuplicateKeys' to false after converting to unique index;
-    autoColl->getWritableCollection(opCtx)->updateDisallowNewDuplicateKeysSetting(
+    // Resets 'prepareUnique' to false after converting to unique index;
+    autoColl->getWritableCollection(opCtx)->updatePrepareUniqueSetting(
         opCtx, idx->indexName(), false);
 }
 
 /**
- * Adjusts disallowNewDuplicateKeys setting on an index.
+ * Adjusts prepareUnique setting on an index.
  */
-void _processCollModIndexRequestDisallowNewDuplicateKeys(
-    OperationContext* opCtx,
-    AutoGetCollection* autoColl,
-    const IndexDescriptor* idx,
-    bool indexDisallowNewDuplicateKeys,
-    boost::optional<bool>* newDisallowNewDuplicateKeys,
-    boost::optional<bool>* oldDisallowNewDuplicateKeys) {
-    *newDisallowNewDuplicateKeys = indexDisallowNewDuplicateKeys;
-    *oldDisallowNewDuplicateKeys = idx->disallowNewDuplicateKeys();
-    if (*oldDisallowNewDuplicateKeys != *newDisallowNewDuplicateKeys) {
-        autoColl->getWritableCollection(opCtx)->updateDisallowNewDuplicateKeysSetting(
-            opCtx, idx->indexName(), indexDisallowNewDuplicateKeys);
+void _processCollModIndexRequestPrepareUnique(OperationContext* opCtx,
+                                              AutoGetCollection* autoColl,
+                                              const IndexDescriptor* idx,
+                                              bool indexPrepareUnique,
+                                              boost::optional<bool>* newPrepareUnique,
+                                              boost::optional<bool>* oldPrepareUnique) {
+    *newPrepareUnique = indexPrepareUnique;
+    *oldPrepareUnique = idx->prepareUnique();
+    if (*oldPrepareUnique != *newPrepareUnique) {
+        autoColl->getWritableCollection(opCtx)->updatePrepareUniqueSetting(
+            opCtx, idx->indexName(), indexPrepareUnique);
     }
 }
 
@@ -187,11 +186,10 @@ void processCollModIndexRequest(OperationContext* opCtx,
     auto indexExpireAfterSeconds = collModIndexRequest.indexExpireAfterSeconds;
     auto indexHidden = collModIndexRequest.indexHidden;
     auto indexUnique = collModIndexRequest.indexUnique;
-    auto indexDisallowNewDuplicateKeys = collModIndexRequest.indexDisallowNewDuplicateKeys;
+    auto indexPrepareUnique = collModIndexRequest.indexPrepareUnique;
 
     // Return early if there are no index modifications requested.
-    if (!indexExpireAfterSeconds && !indexHidden && !indexUnique &&
-        !indexDisallowNewDuplicateKeys) {
+    if (!indexExpireAfterSeconds && !indexHidden && !indexUnique && !indexPrepareUnique) {
         return;
     }
 
@@ -200,8 +198,8 @@ void processCollModIndexRequest(OperationContext* opCtx,
     boost::optional<bool> newHidden;
     boost::optional<bool> oldHidden;
     boost::optional<bool> newUnique;
-    boost::optional<bool> newDisallowNewDuplicateKeys;
-    boost::optional<bool> oldDisallowNewDuplicateKeys;
+    boost::optional<bool> newPrepareUnique;
+    boost::optional<bool> oldPrepareUnique;
 
     // TTL Index
     if (indexExpireAfterSeconds) {
@@ -222,13 +220,9 @@ void processCollModIndexRequest(OperationContext* opCtx,
         _processCollModIndexRequestUnique(opCtx, autoColl, idx, mode, &newUnique);
     }
 
-    if (indexDisallowNewDuplicateKeys) {
-        _processCollModIndexRequestDisallowNewDuplicateKeys(opCtx,
-                                                            autoColl,
-                                                            idx,
-                                                            *indexDisallowNewDuplicateKeys,
-                                                            &newDisallowNewDuplicateKeys,
-                                                            &oldDisallowNewDuplicateKeys);
+    if (indexPrepareUnique) {
+        _processCollModIndexRequestPrepareUnique(
+            opCtx, autoColl, idx, *indexPrepareUnique, &newPrepareUnique, &oldPrepareUnique);
     }
 
     *indexCollModInfo =
@@ -237,8 +231,8 @@ void processCollModIndexRequest(OperationContext* opCtx,
                          newHidden,
                          oldHidden,
                          newUnique,
-                         newDisallowNewDuplicateKeys,
-                         oldDisallowNewDuplicateKeys,
+                         newPrepareUnique,
+                         oldPrepareUnique,
                          idx->indexName()};
 
     // This matches the default for IndexCatalog::refreshEntry().
@@ -259,8 +253,8 @@ void processCollModIndexRequest(OperationContext* opCtx,
                                      oldHidden,
                                      newHidden,
                                      newUnique,
-                                     oldDisallowNewDuplicateKeys,
-                                     newDisallowNewDuplicateKeys,
+                                     oldPrepareUnique,
+                                     newPrepareUnique,
                                      result](boost::optional<Timestamp>) {
         // add the fields to BSONObjBuilder result
         if (oldExpireSecs) {
@@ -278,10 +272,10 @@ void processCollModIndexRequest(OperationContext* opCtx,
             invariant(*newUnique);
             result->appendBool("unique_new", true);
         }
-        if (newDisallowNewDuplicateKeys) {
-            invariant(oldDisallowNewDuplicateKeys);
-            result->append("disallowNewDuplicateKeys_old", *oldDisallowNewDuplicateKeys);
-            result->append("disallowNewDuplicateKeys_new", *newDisallowNewDuplicateKeys);
+        if (newPrepareUnique) {
+            invariant(oldPrepareUnique);
+            result->append("prepareUnique_old", *oldPrepareUnique);
+            result->append("prepareUnique_new", *newPrepareUnique);
         }
     });
 
diff --git a/src/mongo/db/catalog/coll_mod_index.h b/src/mongo/db/catalog/coll_mod_index.h
index b1323ab7788..e5f78be7f55 100644
--- a/src/mongo/db/catalog/coll_mod_index.h
+++ b/src/mongo/db/catalog/coll_mod_index.h
@@ -48,7 +48,7 @@ struct ParsedCollModIndexRequest {
     boost::optional<long long> indexExpireAfterSeconds;
     boost::optional<bool> indexHidden;
     boost::optional<bool> indexUnique;
-    boost::optional<bool> indexDisallowNewDuplicateKeys;
+    boost::optional<bool> indexPrepareUnique;
 };
 
 /**
diff --git a/src/mongo/db/catalog/collection.h b/src/mongo/db/catalog/collection.h
index 145054d8498..2ec74f97a8f 100644
--- a/src/mongo/db/catalog/collection.h
+++ b/src/mongo/db/catalog/collection.h
@@ -610,9 +610,9 @@ public:
     /*
      * Disallows or allows new duplicates in the given index.
      */
-    virtual void updateDisallowNewDuplicateKeysSetting(OperationContext* opCtx,
-                                                       StringData idxName,
-                                                       bool disallowNewDuplicateKeys) = 0;
+    virtual void updatePrepareUniqueSetting(OperationContext* opCtx,
+                                            StringData idxName,
+                                            bool prepareUnique) = 0;
 
     /**
      * Removes invalid index options on all indexes in this collection. Returns a list of index
diff --git a/src/mongo/db/catalog/collection_impl.cpp b/src/mongo/db/catalog/collection_impl.cpp
index 0e9c4a28239..4fd48515b5f 100644
--- a/src/mongo/db/catalog/collection_impl.cpp
+++ b/src/mongo/db/catalog/collection_impl.cpp
@@ -1980,14 +1980,14 @@ void CollectionImpl::updateUniqueSetting(OperationContext* opCtx, StringData idx
     });
 }
 
-void CollectionImpl::updateDisallowNewDuplicateKeysSetting(OperationContext* opCtx,
-                                                           StringData idxName,
-                                                           bool disallowNewDuplicateKeys) {
+void CollectionImpl::updatePrepareUniqueSetting(OperationContext* opCtx,
+                                                StringData idxName,
+                                                bool prepareUnique) {
     int offset = _metadata->findIndexOffset(idxName);
     invariant(offset >= 0);
 
     _writeMetadata(opCtx, [&](BSONCollectionCatalogEntry::MetaData& md) {
-        md.indexes[offset].updateDisallowNewDuplicateKeysSetting(disallowNewDuplicateKeys);
+        md.indexes[offset].updatePrepareUniqueSetting(prepareUnique);
     });
 }
 
diff --git a/src/mongo/db/catalog/collection_impl.h b/src/mongo/db/catalog/collection_impl.h
index c7fc2cc314f..be5153833d7 100644
--- a/src/mongo/db/catalog/collection_impl.h
+++ b/src/mongo/db/catalog/collection_impl.h
@@ -443,9 +443,9 @@ public:
 
     void updateUniqueSetting(OperationContext* opCtx, StringData idxName) final;
 
-    void updateDisallowNewDuplicateKeysSetting(OperationContext* opCtx,
-                                               StringData idxName,
-                                               bool disallowNewDuplicateKeys) final;
+    void updatePrepareUniqueSetting(OperationContext* opCtx,
+                                    StringData idxName,
+                                    bool prepareUnique) final;
 
     std::vector<std::string> removeInvalidIndexOptions(OperationContext* opCtx) final;
 
diff --git a/src/mongo/db/catalog/collection_mock.h b/src/mongo/db/catalog/collection_mock.h
index aeaf4798afd..f656b232a88 100644
--- a/src/mongo/db/catalog/collection_mock.h
+++ b/src/mongo/db/catalog/collection_mock.h
@@ -413,9 +413,9 @@ public:
         std::abort();
     }
 
-    void updateDisallowNewDuplicateKeysSetting(OperationContext* opCtx,
-                                               StringData idxName,
-                                               bool disallowNewDuplicateKeys) {
+    void updatePrepareUniqueSetting(OperationContext* opCtx,
+                                    StringData idxName,
+                                    bool prepareUnique) {
         std::abort();
     }
 
diff --git a/src/mongo/db/catalog/index_catalog_impl.cpp b/src/mongo/db/catalog/index_catalog_impl.cpp
index 2525730604f..4315c583234 100644
--- a/src/mongo/db/catalog/index_catalog_impl.cpp
+++ b/src/mongo/db/catalog/index_catalog_impl.cpp
@@ -1782,8 +1782,8 @@ StatusWith<BSONObj> IndexCatalogImpl::_fixIndexSpec(OperationContext* opCtx,
     if (o["hidden"].trueValue())
         b.appendBool("hidden", true);  // normalize to bool true in case was int 1 or something...
 
-    if (o["disallowNewDuplicateKeys"].trueValue())
-        b.appendBool("disallowNewDuplicateKeys",
+    if (o["prepareUnique"].trueValue())
+        b.appendBool("prepareUnique",
                      true);  // normalize to bool true in case was int 1 or something...
 
     BSONObj key = fixIndexKey(o["key"].Obj());
@@ -1815,7 +1815,7 @@ StatusWith<BSONObj> IndexCatalogImpl::_fixIndexSpec(OperationContext* opCtx,
                 // dropDups is silently ignored and removed from the spec as of SERVER-14710.
                 // ns is removed from the spec as of 4.4.
             } else if (s == "v" || s == "unique" || s == "key" || s == "name" || s == "hidden" ||
-                       s == "disallowNewDuplicateKeys") {
+                       s == "prepareUnique") {
                 // covered above
             } else {
                 b.append(e);
diff --git a/src/mongo/db/catalog/index_key_validate.cpp b/src/mongo/db/catalog/index_key_validate.cpp
index 3a663298d5d..f6081f0ff73 100644
--- a/src/mongo/db/catalog/index_key_validate.cpp
+++ b/src/mongo/db/catalog/index_key_validate.cpp
@@ -94,7 +94,7 @@ static std::set<StringData> allowedFieldNames = {
     IndexDescriptor::kUniqueFieldName,
     IndexDescriptor::kWeightsFieldName,
     IndexDescriptor::kOriginalSpecFieldName,
-    IndexDescriptor::kDisallowNewDuplicateKeysFieldName,
+    IndexDescriptor::kPrepareUniqueFieldName,
     // Index creation under legacy writeMode can result in an index spec with an _id field.
     "_id"};
 
@@ -498,7 +498,7 @@ StatusWith<BSONObj> validateIndexSpec(OperationContext* opCtx, const BSONObj& in
                     IndexDescriptor::k2dsphereCoarsestIndexedLevel == indexSpecElemFieldName ||
                     IndexDescriptor::k2dsphereFinestIndexedLevel == indexSpecElemFieldName ||
                     IndexDescriptor::kDropDuplicatesFieldName == indexSpecElemFieldName ||
-                    IndexDescriptor::kDisallowNewDuplicateKeysFieldName == indexSpecElemFieldName ||
+                    IndexDescriptor::kPrepareUniqueFieldName == indexSpecElemFieldName ||
                     "clustered" == indexSpecElemFieldName) &&
                    !indexSpecElem.isNumber() && !indexSpecElem.isBoolean()) {
             return {ErrorCodes::TypeMismatch,
diff --git a/src/mongo/db/coll_mod.idl b/src/mongo/db/coll_mod.idl
index 821aed598d6..5d9422e111f 100644
--- a/src/mongo/db/coll_mod.idl
+++ b/src/mongo/db/coll_mod.idl
@@ -63,7 +63,7 @@ structs:
                 optional: true
                 type: safeBool
                 unstable: true
-            disallowNewDuplicateKeys:
+            prepareUnique:
                 optional: true
                 type: safeBool
                 unstable: true
@@ -92,11 +92,11 @@ structs:
                 optional: true
                 type: safeBool
                 unstable: true
-            disallowNewDuplicateKeys_old:
+            prepareUnique_old:
                 optional: true
                 type: safeBool
                 unstable: true
-            disallowNewDuplicateKeys_new:
+            prepareUnique_new:
                 optional: true
                 type: safeBool
                 unstable: true
diff --git a/src/mongo/db/coll_mod_reply_validation.cpp b/src/mongo/db/coll_mod_reply_validation.cpp
index 3ebe4a58675..07de476ddde 100644
--- a/src/mongo/db/coll_mod_reply_validation.cpp
+++ b/src/mongo/db/coll_mod_reply_validation.cpp
@@ -41,14 +41,13 @@ void validateReply(const CollModReply& reply) {
                 false);
     }
 
-    auto disallowNewDuplicateKeys_new = reply.getDisallowNewDuplicateKeys_new().is_initialized();
-    auto disallowNewDuplicateKeys_old = reply.getDisallowNewDuplicateKeys_old().is_initialized();
+    auto prepareUnique_new = reply.getPrepareUnique_new().is_initialized();
+    auto prepareUnique_old = reply.getPrepareUnique_old().is_initialized();
 
-    if ((!disallowNewDuplicateKeys_new && disallowNewDuplicateKeys_old) ||
-        (disallowNewDuplicateKeys_new && !disallowNewDuplicateKeys_old)) {
+    if ((!prepareUnique_new && prepareUnique_old) || (prepareUnique_new && !prepareUnique_old)) {
         uassert(ErrorCodes::CommandResultSchemaViolation,
                 str::stream() << "Invalid CollModReply: Reply should define either both fields "
-                              << "(disallowNewDuplicateKeys_new and disallowNewDuplicateKeys_old) "
+                              << "(prepareUnique_new and prepareUnique_old) "
                                  "or none of them.",
                 false);
     }
diff --git a/src/mongo/db/coll_mod_reply_validation.h b/src/mongo/db/coll_mod_reply_validation.h
index e4a9ac9e49a..bb35a3791dd 100644
--- a/src/mongo/db/coll_mod_reply_validation.h
+++ b/src/mongo/db/coll_mod_reply_validation.h
@@ -37,7 +37,7 @@ namespace mongo::coll_mod_reply_validation {
  * are not sufficient in this case.
  * It is used to check that reply includes:
  *  - (hidden_new and hidden_old) together or none of them.
- *  - (disallowNewDuplicateKeys_new and disallowNewDuplicateKeys_old) together or none of them."
+ *  - (prepareUnique_new and prepareUnique_old) together or none of them."
  */
 void validateReply(const CollModReply& reply);
 }  // namespace mongo::coll_mod_reply_validation
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 d4ac59cfec3..119b9149557 100644
--- a/src/mongo/db/commands/set_feature_compatibility_version_command.cpp
+++ b/src/mongo/db/commands/set_feature_compatibility_version_command.cpp
@@ -745,7 +745,7 @@ private:
                                 ErrorCodes::CannotDowngrade,
                                 fmt::format(
                                     "Cannot downgrade the cluster when there are indexes that have "
-                                    "the 'disallowNewDuplicateKeys' field. Use listIndexes to find "
+                                    "the 'prepareUnique' field. Use listIndexes to find "
                                     "them and drop "
                                     "the indexes or use collMod to manually set it to false to "
                                     "remove the field "
@@ -753,7 +753,7 @@ private:
                                     "'{}' on collection: '{}'",
                                     indexEntry->descriptor()->indexName(),
                                     collection->ns().toString()),
-                                !indexEntry->descriptor()->disallowNewDuplicateKeys());
+                                !indexEntry->descriptor()->prepareUnique());
                         }
                         return true;
                     });
diff --git a/src/mongo/db/create_indexes.idl b/src/mongo/db/create_indexes.idl
index 33815ce79b8..902731f9edb 100644
--- a/src/mongo/db/create_indexes.idl
+++ b/src/mongo/db/create_indexes.idl
@@ -180,7 +180,7 @@ structs:
                 type: safeBool
                 optional: true
                 unstable: false
-            disallowNewDuplicateKeys:
+            prepareUnique:
                 type: safeBool
                 optional: true
                 unstable: true
diff --git a/src/mongo/db/index/index_access_method.cpp b/src/mongo/db/index/index_access_method.cpp
index aa0f401c91c..be710445eb1 100644
--- a/src/mongo/db/index/index_access_method.cpp
+++ b/src/mongo/db/index/index_access_method.cpp
@@ -268,7 +268,7 @@ Status SortedDataIndexAccessMethod::insertKeys(OperationContext* opCtx,
         *numInserted = 0;
     }
     bool unique = _descriptor->unique();
-    bool disallowNewDuplicateKeys = _descriptor->disallowNewDuplicateKeys();
+    bool prepareUnique = _descriptor->prepareUnique();
     bool dupsAllowed;
     if (!_descriptor->isIdIndex() && !opCtx->isEnforcingConstraints() &&
         coll->isIndexReady(_descriptor->indexName())) {
@@ -280,7 +280,7 @@ Status SortedDataIndexAccessMethod::insertKeys(OperationContext* opCtx,
         // Additionally, unique indexes conflict checking can cause out-of-order updates in
         // wiredtiger. See SERVER-59831.
         dupsAllowed = true;
-    } else if (disallowNewDuplicateKeys) {
+    } else if (prepareUnique) {
         // This currently is only used by collMod command when converting a regular index to a
         // unique index. The regular index will start rejecting duplicates even before the
         // conversion finishes.
@@ -295,7 +295,7 @@ Status SortedDataIndexAccessMethod::insertKeys(OperationContext* opCtx,
         // When duplicates are encountered and allowed, retry with dupsAllowed. Call
         // onDuplicateKey() with the inserted duplicate key.
         if (ErrorCodes::DuplicateKey == result.getStatus().code() && options.dupsAllowed &&
-            !disallowNewDuplicateKeys) {
+            !prepareUnique) {
             invariant(unique);
 
             result = _newInterface->insert(opCtx, keyString, true /* dupsAllowed */);
@@ -542,7 +542,7 @@ Status SortedDataIndexAccessMethod::doUpdate(OperationContext* opCtx,
 
     // Add all new data keys into the index.
     for (const auto& keyString : ticket.added) {
-        bool dupsAllowed = !_descriptor->disallowNewDuplicateKeys() && ticket.dupsAllowed;
+        bool dupsAllowed = !_descriptor->prepareUnique() && ticket.dupsAllowed;
         auto result = _newInterface->insert(opCtx, keyString, dupsAllowed);
         if (!result.isOK())
             return result.getStatus();
diff --git a/src/mongo/db/index/index_descriptor.cpp b/src/mongo/db/index/index_descriptor.cpp
index b276fb9b38c..3f4dbd088ed 100644
--- a/src/mongo/db/index/index_descriptor.cpp
+++ b/src/mongo/db/index/index_descriptor.cpp
@@ -107,7 +107,7 @@ constexpr StringData IndexDescriptor::kTextVersionFieldName;
 constexpr StringData IndexDescriptor::kUniqueFieldName;
 constexpr StringData IndexDescriptor::kHiddenFieldName;
 constexpr StringData IndexDescriptor::kWeightsFieldName;
-constexpr StringData IndexDescriptor::kDisallowNewDuplicateKeysFieldName;
+constexpr StringData IndexDescriptor::kPrepareUniqueFieldName;
 
 IndexDescriptor::IndexDescriptor(const std::string& accessMethodName, BSONObj infoObj)
     : _accessMethodName(accessMethodName),
@@ -136,13 +136,12 @@ IndexDescriptor::IndexDescriptor(const std::string& accessMethodName, BSONObj in
         _collation = collationElement.Obj().getOwned();
     }
 
-    if (BSONElement disallowNewDuplicateKeysElement =
-            _infoObj[kDisallowNewDuplicateKeysFieldName]) {
+    if (BSONElement prepareUniqueElement = _infoObj[kPrepareUniqueFieldName]) {
         uassert(
             ErrorCodes::InvalidOptions,
-            "Index does not support the 'disallowNewDuplicateKeys' field",
+            "Index does not support the 'prepareUnique' field",
             feature_flags::gCollModIndexUnique.isEnabled(serverGlobalParams.featureCompatibility));
-        _disallowNewDuplicateKeys = disallowNewDuplicateKeysElement.trueValue();
+        _prepareUnique = prepareUniqueElement.trueValue();
     }
 }
 
diff --git a/src/mongo/db/index/index_descriptor.h b/src/mongo/db/index/index_descriptor.h
index 35a005371b4..f4f48cb35b9 100644
--- a/src/mongo/db/index/index_descriptor.h
+++ b/src/mongo/db/index/index_descriptor.h
@@ -88,7 +88,7 @@ public:
     static constexpr StringData kUniqueFieldName = "unique"_sd;
     static constexpr StringData kWeightsFieldName = "weights"_sd;
     static constexpr StringData kOriginalSpecFieldName = "originalSpec"_sd;
-    static constexpr StringData kDisallowNewDuplicateKeysFieldName = "disallowNewDuplicateKeys"_sd;
+    static constexpr StringData kPrepareUniqueFieldName = "prepareUnique"_sd;
 
     /**
      * infoObj is a copy of the index-describing BSONObj contained in the catalog.
@@ -227,8 +227,8 @@ public:
         return _partialFilterExpression;
     }
 
-    bool disallowNewDuplicateKeys() const {
-        return _disallowNewDuplicateKeys;
+    bool prepareUnique() const {
+        return _prepareUnique;
     }
 
     /**
@@ -280,7 +280,7 @@ private:
     IndexVersion _version;
     BSONObj _collation;
     BSONObj _partialFilterExpression;
-    bool _disallowNewDuplicateKeys = false;
+    bool _prepareUnique = false;
 
     // Many query stages require going from an IndexDescriptor to its IndexCatalogEntry, so for
     // now we need this.
diff --git a/src/mongo/db/list_indexes.idl b/src/mongo/db/list_indexes.idl
index 5d4773d5a12..286d393998f 100644
--- a/src/mongo/db/list_indexes.idl
+++ b/src/mongo/db/list_indexes.idl
@@ -156,7 +156,7 @@ structs:
                 type: safeBool
                 optional: true
                 unstable: false
-            disallowNewDuplicateKeys:
+            prepareUnique:
                 type: safeBool
                 optional: true
                 unstable: true
diff --git a/src/mongo/db/op_observer.h b/src/mongo/db/op_observer.h
index e42f9533939..030521b9f4d 100644
--- a/src/mongo/db/op_observer.h
+++ b/src/mongo/db/op_observer.h
@@ -99,8 +99,8 @@ struct IndexCollModInfo {
     boost::optional<bool> hidden;
     boost::optional<bool> oldHidden;
     boost::optional<bool> unique;
-    boost::optional<bool> disallowNewDuplicateKeys;
-    boost::optional<bool> oldDisallowNewDuplicateKeys;
+    boost::optional<bool> prepareUnique;
+    boost::optional<bool> oldPrepareUnique;
     std::string indexName;
 };
 
diff --git a/src/mongo/db/op_observer_impl.cpp b/src/mongo/db/op_observer_impl.cpp
index b8a7b4f28e3..b05d0f6e021 100644
--- a/src/mongo/db/op_observer_impl.cpp
+++ b/src/mongo/db/op_observer_impl.cpp
@@ -1029,9 +1029,9 @@ void OpObserverImpl::onCollMod(OperationContext* opCtx,
                 auto oldHidden = indexInfo->oldHidden.get();
                 o2Builder.append("hidden_old", oldHidden);
             }
-            if (indexInfo->oldDisallowNewDuplicateKeys) {
-                auto oldDisallowNewDuplicateKeys = indexInfo->oldDisallowNewDuplicateKeys.get();
-                o2Builder.append("disallowNewDuplicates_old", oldDisallowNewDuplicateKeys);
+            if (indexInfo->oldPrepareUnique) {
+                auto oldPrepareUnique = indexInfo->oldPrepareUnique.get();
+                o2Builder.append("prepareUnique_old", oldPrepareUnique);
             }
         }
 
diff --git a/src/mongo/db/op_observer_util.cpp b/src/mongo/db/op_observer_util.cpp
index e871f7c1cb2..cd79324a2aa 100644
--- a/src/mongo/db/op_observer_util.cpp
+++ b/src/mongo/db/op_observer_util.cpp
@@ -64,9 +64,8 @@ BSONObj makeCollModCmdObj(const BSONObj& collModCmd,
             if (indexInfo->unique)
                 indexObjBuilder.append("unique", indexInfo->unique.get());
 
-            if (indexInfo->disallowNewDuplicateKeys)
-                indexObjBuilder.append("disallowNewDuplicateKeys",
-                                       indexInfo->disallowNewDuplicateKeys.get());
+            if (indexInfo->prepareUnique)
+                indexObjBuilder.append("prepareUnique", indexInfo->prepareUnique.get());
 
             cmdObjBuilder.append(indexFieldName, indexObjBuilder.obj());
         } else {
diff --git a/src/mongo/db/storage/bson_collection_catalog_entry.cpp b/src/mongo/db/storage/bson_collection_catalog_entry.cpp
index def3dc283d5..58cdc01fe39 100644
--- a/src/mongo/db/storage/bson_collection_catalog_entry.cpp
+++ b/src/mongo/db/storage/bson_collection_catalog_entry.cpp
@@ -146,20 +146,19 @@ void BSONCollectionCatalogEntry::IndexMetaData::updateUniqueSetting() {
     spec = b.obj();
 }
 
-void BSONCollectionCatalogEntry::IndexMetaData::updateDisallowNewDuplicateKeysSetting(
-    bool disallowNewDuplicateKeys) {
-    // If disallowNewDuplicateKeys == false, we remove this field from catalog rather than add a
+void BSONCollectionCatalogEntry::IndexMetaData::updatePrepareUniqueSetting(bool prepareUnique) {
+    // If prepareUnique == false, we remove this field from catalog rather than add a
     // field with false.
     BSONObjBuilder b;
     for (BSONObjIterator bi(spec); bi.more();) {
         BSONElement e = bi.next();
-        if (e.fieldNameStringData() != "disallowNewDuplicateKeys") {
+        if (e.fieldNameStringData() != "prepareUnique") {
             b.append(e);
         }
     }
 
-    if (disallowNewDuplicateKeys) {
-        b.append("disallowNewDuplicateKeys", disallowNewDuplicateKeys);
+    if (prepareUnique) {
+        b.append("prepareUnique", prepareUnique);
     }
     spec = b.obj();
 }
diff --git a/src/mongo/db/storage/bson_collection_catalog_entry.h b/src/mongo/db/storage/bson_collection_catalog_entry.h
index c85bc6755d0..18bca894a71 100644
--- a/src/mongo/db/storage/bson_collection_catalog_entry.h
+++ b/src/mongo/db/storage/bson_collection_catalog_entry.h
@@ -100,7 +100,7 @@ public:
 
         void updateUniqueSetting();
 
-        void updateDisallowNewDuplicateKeysSetting(bool disallowNewDuplicateKeys);
+        void updatePrepareUniqueSetting(bool prepareUnique);
 
         StringData nameStringData() const {
             return spec["name"].valueStringDataSafe();
diff --git a/src/mongo/dbtests/index_access_method_test.cpp b/src/mongo/dbtests/index_access_method_test.cpp
index 4d24fb5c11f..a1c20d7a5d8 100644
--- a/src/mongo/dbtests/index_access_method_test.cpp
+++ b/src/mongo/dbtests/index_access_method_test.cpp
@@ -259,15 +259,15 @@ TEST(IndexAccessMethodInsertKeys, DuplicatesCheckingOnSecondaryUniqueIndexes) {
     ASSERT_EQ(numInserted, 2);
 }
 
-TEST(IndexAccessMethodInsertKeys, InsertWhenDisallowNewDuplicateKeys) {
+TEST(IndexAccessMethodInsertKeys, InsertWhenPrepareUnique) {
     if (feature_flags::gCollModIndexUnique.isEnabled(serverGlobalParams.featureCompatibility)) {
         ServiceContext::UniqueOperationContext opCtxRaii = cc().makeOperationContext();
         OperationContext* opCtx = opCtxRaii.get();
-        NamespaceString nss("unittests.InsertWhenDisallowNewDuplicateKeys");
+        NamespaceString nss("unittests.InsertWhenPrepareUnique");
         auto indexName = "a_1";
         auto indexSpec =
-            BSON("name" << indexName << "key" << BSON("a" << 1) << "disallowNewDuplicateKeys"
-                        << true << "v" << static_cast<int>(IndexDescriptor::IndexVersion::kV2));
+            BSON("name" << indexName << "key" << BSON("a" << 1) << "prepareUnique" << true << "v"
+                        << static_cast<int>(IndexDescriptor::IndexVersion::kV2));
         ASSERT_OK(dbtests::createIndexFromSpec(opCtx, nss.ns(), indexSpec));
 
         AutoGetCollection autoColl(opCtx, nss, LockMode::MODE_X);
@@ -295,15 +295,15 @@ TEST(IndexAccessMethodInsertKeys, InsertWhenDisallowNewDuplicateKeys) {
     }
 }
 
-TEST(IndexAccessMethodUpdateKeys, UpdateWhenDisallowNewDuplicateKeys) {
+TEST(IndexAccessMethodUpdateKeys, UpdateWhenPrepareUnique) {
     if (feature_flags::gCollModIndexUnique.isEnabled(serverGlobalParams.featureCompatibility)) {
         ServiceContext::UniqueOperationContext opCtxRaii = cc().makeOperationContext();
         OperationContext* opCtx = opCtxRaii.get();
-        NamespaceString nss("unittests.UpdateWhenDisallowNewDuplicateKeys");
+        NamespaceString nss("unittests.UpdateWhenPrepareUnique");
         auto indexName = "a_1";
         auto indexSpec =
-            BSON("name" << indexName << "key" << BSON("a" << 1) << "disallowNewDuplicateKeys"
-                        << true << "v" << static_cast<int>(IndexDescriptor::IndexVersion::kV2));
+            BSON("name" << indexName << "key" << BSON("a" << 1) << "prepareUnique" << true << "v"
+                        << static_cast<int>(IndexDescriptor::IndexVersion::kV2));
         ASSERT_OK(dbtests::createIndexFromSpec(opCtx, nss.ns(), indexSpec));
 
         AutoGetCollection autoColl(opCtx, nss, LockMode::MODE_X);