SERVER-78140 Allow updateOne to supply a sort option

GitOrigin-RevId: 879b5da

Author: lynne-wang

buildscripts/resmokeconfig/suites/timeseries_crud_jscore_passthrough.yml

@@ -48,6 +48,8 @@ selector:
   - jstests/core/write/find_and_modify/find_and_modify_empty_update.js
   - jstests/core/write/find_and_modify/find_and_modify_invalid_query_params.js
   - jstests/core/write/find_and_modify/find_and_modify_server7660.js
+  # updateOne sort.
+  - jstests/core/write/update/updateOne_sort.js
   # Incompatible find command option.
   - jstests/core/min_max_hashed_index.js # min
   - jstests/core/query/expr/expr.js # divide

jstests/concurrency/fsm_workloads/updateOne_update_with_sort.js

@@ -0,0 +1,71 @@
+/**
+ * updateOne_update_with_sort.js
+ *
+ * Ensures that updateOne will not apply an update to a document which, due to a concurrent
+ * modification, no longer matches the query predicate. At the end of the workload, the contents of
+ * the database are checked for whether the correct number of documents were updated.
+ *
+ * @tags: [
+ *   # PM-1632 was delivered in 7.1, resolving the issue about assumes_unsharded_collection.
+ *   requires_fcv_80,
+ * ]
+ */
+import {extendWorkload} from "jstests/concurrency/fsm_libs/extend_workload.js";
+import {isMongod} from "jstests/concurrency/fsm_workload_helpers/server_types.js";
+import {
+    $config as $baseConfig
+} from "jstests/concurrency/fsm_workloads/updateOne_with_sort_update_queue.js";
+
+export const $config = extendWorkload($baseConfig, function($config, $super) {
+    // Use the same workload name as the database name, since the workload
+    // name is assumed to be unique.
+    $config.data.uniqueDBName = jsTestName();
+
+    $config.iterations = 1;
+
+    $config.states.updateOne = function(db, collName) {
+        const updateCmd = {
+            update: collName,
+            updates: [{q: {a: 1, b: 1}, u: {$inc: {a: 1}}, multi: false, sort: {a: -1}}]
+        };
+
+        // Update field 'a' to avoid matching the same document again.
+        var res = db.runCommand(updateCmd);
+        if (isMongod(db)) {
+            assert.contains(res.nModified, [0, 1], tojson(res));
+        }
+    };
+
+    $config.setup = function(db, collName) {
+        var bulk = db[collName].initializeUnorderedBulkOp();
+        var doc = this.newDocForInsert(0);
+        // Require that documents inserted by this workload use _id values that can be compared
+        // using the default JS comparator.
+        assert.neq(typeof doc._id,
+                   'object',
+                   'default comparator of' +
+                       ' Array.prototype.sort() is not well-ordered for JS objects');
+        bulk.insert(doc);
+        var res = bulk.execute();
+        assert.commandWorked(res);
+        // Insert a single document into the collection.
+        assert.eq(1, res.nInserted);
+
+        this.getIndexSpecs().forEach(function createIndex(indexSpec) {
+            assert.commandWorked(db[collName].createIndex(indexSpec));
+        });
+    };
+
+    $config.teardown = function(db, collName) {
+        var docs = db[collName].find().toArray();
+        // Assert that while 10 threads attempted an updateOne on a single matching document, it was
+        // only updated once with the correct update. All updateOne operations look for a document
+        // with a==1, and then increment 'a' by 1. One should win the race and set a=2. The others
+        // should fail to find a match. The assertion is that 'a' got incremented once (not zero
+        // times and not twice).
+        assert.eq(docs.length, 1);
+        assert.eq(docs[0].a, 2);
+    };
+
+    return $config;
+});

jstests/concurrency/fsm_workloads/updateOne_update_with_sort_and_upsert.js

@@ -0,0 +1,87 @@
+/**
+ * updateOne_update_with_sort_and_upsert.js
+ *
+ * Ensures that updateOne with a sort and {upsert: true} will perform an upsert when, due to a
+ * concurrent modification, no documents match the query predicate. At the end of the workload, the
+ * contents of the database are checked for whether the correct number of documents were updated.
+ *
+ * @tags: [
+ *   # PM-1632 was delivered in 7.1, resolving the issue about assumes_unsharded_collection.
+ *   requires_fcv_80,
+ * ]
+ */
+import {extendWorkload} from "jstests/concurrency/fsm_libs/extend_workload.js";
+import {isMongod} from "jstests/concurrency/fsm_workload_helpers/server_types.js";
+import {
+    $config as $baseConfig
+} from "jstests/concurrency/fsm_workloads/updateOne_with_sort_update_queue.js";
+
+export const $config = extendWorkload($baseConfig, function($config, $super) {
+    // Use the same workload name as the database name, since the workload
+    // name is assumed to be unique.
+    $config.data.uniqueDBName = jsTestName();
+
+    $config.iterations = 1;
+
+    $config.states.updateOne = function(db, collName) {
+        const updateCmd = {
+            update: collName,
+            updates:
+                [{q: {a: 1, b: 1}, u: {$inc: {a: 1}}, multi: false, sort: {a: -1}, upsert: true}]
+        };
+
+        // Update field 'a' to avoid matching the same document again.
+        var res = db.runCommand(updateCmd);
+        if (isMongod(db)) {
+            if (res.hasOwnProperty('upserted') && res.upserted.length != 0) {
+                assert.eq(res.nModified, 0, tojson(res));
+            } else {
+                assert.eq(res.nModified, 1, tojson(res));
+            }
+        }
+    };
+
+    $config.setup = function(db, collName) {
+        this.numDocs = this.iterations * this.threadCount;
+
+        var bulk = db[collName].initializeUnorderedBulkOp();
+        var doc = this.newDocForInsert(0);
+        // Require that documents inserted by this workload use _id values that can be compared
+        // using the default JS comparator.
+        assert.neq(typeof doc._id,
+                   'object',
+                   'default comparator of' +
+                       ' Array.prototype.sort() is not well-ordered for JS objects');
+        bulk.insert(doc);
+        var res = bulk.execute();
+        assert.commandWorked(res);
+        // Insert a single document into the collection.
+        assert.eq(1, res.nInserted);
+
+        this.getIndexSpecs().forEach(function createIndex(indexSpec) {
+            assert.commandWorked(db[collName].createIndex(indexSpec));
+        });
+    };
+
+    $config.teardown = function(db, collName) {
+        var docs = db[collName].find().toArray();
+        // Assert that while 10 threads attempted an updateOne on a single matching document, it was
+        // only updated once with the correct update. All updateOne operations look for a document
+        // with a==1, and then increment 'a' by 1. One should win the race and set a=2. The others
+        // should fail to find a match and will insert a new document instead. The assertion is that
+        // 'a' got incremented once in the original document that was in the collection (not zero
+        // times and not twice). The additional documents are the product of upserts and have unique
+        // _id values.
+        assert.eq(docs.length, this.numDocs);
+
+        var seenIds = new Set();
+        for (var i = 0; i < docs.length; i++) {
+            assert.eq(docs[i].a, 2);
+            assert.eq(seenIds.has(docs[i]._id), false);
+            seenIds.add(docs[i]._id);
+        }
+        assert(seenIds.has(0));
+    };
+
+    return $config;
+});

jstests/concurrency/fsm_workloads/updateOne_update_with_sort_upsert_dupkey.js

@@ -0,0 +1,67 @@
+/**
+ * updateOne_update_with_sort_upsert_dupkey.js
+ *
+ * Ensures that updateOne with a sort, {upsert: true}, and a predicate on the same _id value will
+ * perform an upsert when no documents match the query predicate. Verify that when there is a
+ * WriteConflict, the update command is retried, and the document with the matching _id value is
+ * updated. At the end of the workload, the contents of the database are checked for whether the
+ * documents were updated correctly.
+ *
+ * @tags: [
+ *   # PM-1632 was delivered in 7.1, resolving the issue about assumes_unsharded_collection.
+ *   requires_fcv_80,
+ * ]
+ */
+import {extendWorkload} from "jstests/concurrency/fsm_libs/extend_workload.js";
+import {isMongod} from "jstests/concurrency/fsm_workload_helpers/server_types.js";
+import {
+    $config as $baseConfig
+} from "jstests/concurrency/fsm_workloads/updateOne_update_with_sort_and_upsert.js";
+
+export const $config = extendWorkload($baseConfig, function($config, $super) {
+    // Use the same workload name as the database name, since the workload
+    // name is assumed to be unique.
+    $config.data.uniqueDBName = jsTestName();
+
+    $config.data.getIndexSpecs = function getIndexSpecs() {
+        return [];
+    };
+
+    $config.threadCount = 2;
+
+    // The query predicate is on the _id unique index so that we
+    $config.states.updateOne = function(db, collName) {
+        const updateCmd = {
+            update: collName,
+            updates: [{q: {_id: 1}, u: {$inc: {a: 1}}, multi: false, sort: {a: -1}, upsert: true}]
+        };
+
+        var res = db.runCommand(updateCmd);
+        if (isMongod(db)) {
+            if (res.hasOwnProperty('upserted') && res.upserted.length != 0) {
+                // Case 1: The _id value is not yet present, so a new document is added to the
+                // collection.
+                assert.eq(res.nModified, 0, tojson(res));
+            } else {
+                // Case 2: The _id value matches an existing document in the collection, so it
+                // modifies that document.
+                assert.eq(res.nModified, 1, tojson(res));
+            }
+        }
+    };
+
+    $config.teardown = function(db, collName) {
+        var docs = db[collName].find().toArray();
+
+        // Assert that when 2 threads attempt an updateOne with an upsert on a query with the same
+        // _id value (unique key), the earlier thread successfully upserts the document when it is
+        // not found. Since the query predicate contains no initial value for 'a', it adds the
+        // document {_id: 1, a: 1}. The second thread then finds the newly upserted document and
+        // updates the field 'a', updating the document to {_id: 1, a: 2}.
+        assert.eq(docs.length, 2);
+        var modifiedDoc = db[collName].find({_id: 1}).toArray();
+        assert.eq(modifiedDoc[0].a, this.numDocs);
+    };
+
+    return $config;
+});

jstests/concurrency/fsm_workloads/updateOne_with_sort_update_queue.js

@@ -0,0 +1,106 @@
+/**
+ * updateOne_update_queue.js
+ *
+ * A large number of documents are inserted during the workload setup. Each thread repeatedly
+ * updates a document from the collection using the updateOne command with a sort. At the end of the
+ * workload, the contents of the database are checked for whether the correct number of documents
+ * were updated.
+ *
+ * This test is modeled off of findAndModify_update_queue.js, but instead of storing the _id field
+ * of the updated document in another database and ensuring that every thread updated a different
+ * document from the other threads, we check that the correct number of documents were updated
+ * because updateOne doesn't return the modified document (and its _id value) unless upsert is true.
+ *
+ * @tags: [
+ *   # PM-1632 was delivered in 7.1, resolving the issue about assumes_unsharded_collection.
+ *   requires_fcv_80,
+ * ]
+ */
+import {isMongod} from "jstests/concurrency/fsm_workload_helpers/server_types.js";
+
+export const $config = (function() {
+    var data = {
+        // Use the workload name as the database name, since the workload name is assumed to be
+        // unique.
+        uniqueDBName: jsTestName(),
+
+        newDocForInsert: function newDocForInsert(i) {
+            return {_id: i, a: 1, b: 1};
+        },
+
+        getIndexSpecs: function getIndexSpecs() {
+            return [{a: 1}, {b: 1}];
+        },
+
+        opName: 'updated'
+    };
+
+    var states = (function() {
+        function updateOne(db, collName) {
+            const updateCmd = {
+                update: collName,
+                updates: [{q: {a: 1, b: 1}, u: {$inc: {a: 1}}, multi: false, sort: {a: -1}}]
+            };
+
+            // Update field 'a' to avoid matching the same document again.
+            var res = db.runCommand(updateCmd);
+
+            if (isMongod(db)) {
+                // Storage engines should automatically retry the operation, and thus should never
+                // return 0.
+                // In the rare case that the retry limit is exceeded, a document may not be matched.
+                assert.neq(
+                    res.nModified,
+                    0,
+                    'updateOne should have found and updated a matching document, returned ' +
+                        tojson(res));
+            }
+        }
+
+        return {updateOne: updateOne};
+    })();
+
+    var transitions = {updateOne: {updateOne: 1}};
+
+    function setup(db, collName) {
+        // Each thread should update exactly one document per iteration.
+        this.numDocs = this.iterations * this.threadCount;
+
+        var bulk = db[collName].initializeUnorderedBulkOp();
+        for (var i = 0; i < this.numDocs; ++i) {
+            var doc = this.newDocForInsert(i);
+            // Require that documents inserted by this workload use _id values that can be compared
+            // using the default JS comparator.
+            assert.neq(typeof doc._id,
+                       'object',
+                       'default comparator of' +
+                           ' Array.prototype.sort() is not well-ordered for JS objects');
+            bulk.insert(doc);
+        }
+        var res = bulk.execute();
+        assert.commandWorked(res);
+        assert.eq(this.numDocs, res.nInserted);
+
+        this.getIndexSpecs().forEach(function createIndex(indexSpec) {
+            assert.commandWorked(db[collName].createIndex(indexSpec));
+        });
+    }
+
+    function teardown(db, collName) {
+        var numOldDocs = db[collName].countDocuments({a: 1, b: 1});
+        assert.eq(numOldDocs, 0);
+        var numNewDocs = db[collName].countDocuments({a: 2, b: 1});
+        assert.eq(numNewDocs, this.numDocs);
+    }
+
+    return {
+        threadCount: 10,
+        iterations: 100,
+        data: data,
+        startState: 'updateOne',
+        states: states,
+        transitions: transitions,
+        setup: setup,
+        teardown: teardown
+    };
+})();

jstests/concurrency/fsm_workloads/updateOne_with_sort_update_queue_unindexed.js

@@ -0,0 +1,37 @@
+/**
+ * updateOne_update_queue_unindexed.js
+ *
+ * This is the same workload as updateOne_update_queue.js, but without the relevant index.
+ *
+ * The lack of an index that could satisfy the sort forces the updateOne operations to scan all
+ * the matching documents in order to find the relevant document. This increases the amount of work
+ * each updateOne operation has to do before getting to the matching document, and thus
+ * increases the chance of a write conflict because each concurrent updateOne operation is
+ * trying to update the same document from the queue.
+ *
+ * This test is modeled off of findAndModify_update_queue.js, but instead of storing the _id field
+ * of the updated document in another database and ensuring that every thread updated a different
+ * document from the other threads, we check that the correct number of documents were updated
+ * because updateOne doesn't return the modified document (and its _id value) unless upsert is true.
+ *
+ * @tags: [
+ *   # PM-1632 was delivered in 7.1, resolving the issue about assumes_unsharded_collection.
+ *   requires_fcv_80,
+ * ]
+ */
+import {extendWorkload} from "jstests/concurrency/fsm_libs/extend_workload.js";
+import {
+    $config as $baseConfig
+} from "jstests/concurrency/fsm_workloads/updateOne_with_sort_update_queue.js";
+
+export const $config = extendWorkload($baseConfig, function($config, $super) {
+    // Use the same workload name as the database name, since the workload
+    // name is assumed to be unique.
+    $config.data.uniqueDBName = jsTestName();
+
+    $config.data.getIndexSpecs = function getIndexSpecs() {
+        return [];
+    };
+
+    return $config;
+});