SERVER-61385 Migrate callers of 'DBClientBase::query()' legacy API to the modern 'find()' API

There are a handful of remaining callers of the legacy API,
either using the exhaust option or which are involved in a
code path which still relies on the OP_QUERY-inspired BSON
format. These should be cleaned up as follow-up work.

61 files changed, 845 insertions, 869 deletions

diff --git a/src/mongo/client/dbclient_base.cpp b/src/mongo/client/dbclient_base.cpp
index a2f1bea40c5..69bb443908b 100644
--- a/src/mongo/client/dbclient_base.cpp
+++ b/src/mongo/client/dbclient_base.cpp
@@ -564,57 +564,17 @@ bool DBClientBase::exists(const string& ns) {
     return !results.empty();
 }
 
-std::pair<BSONObj, NamespaceString> DBClientBase::findOneByUUID(
-    const std::string& db,
-    UUID uuid,
-    const BSONObj& filter,
-    boost::optional<BSONObj> readConcernObj) {
-    list<BSONObj> results;
-    BSONObj res;
-
-    BSONObjBuilder cmdBuilder;
-    uuid.appendToBuilder(&cmdBuilder, "find");
-    cmdBuilder.append("filter", filter);
-    cmdBuilder.append("limit", 1);
-    cmdBuilder.append("singleBatch", true);
-    if (readConcernObj) {
-        cmdBuilder.append(repl::ReadConcernArgs::kReadConcernFieldName, *readConcernObj);
-    }
-
-    BSONObj cmd = cmdBuilder.obj();
-
-    if (runCommand(db, cmd, res, QueryOption_SecondaryOk)) {
-        BSONObj cursorObj = res.getObjectField("cursor");
-        BSONObj docs = cursorObj.getObjectField("firstBatch");
-        BSONObjIterator it(docs);
-        while (it.more()) {
-            BSONElement e = it.next();
-            results.push_back(e.Obj().getOwned());
-        }
-        invariant(results.size() <= 1);
-        NamespaceString resNss(cursorObj["ns"].valueStringData());
-        if (results.empty()) {
-            return {BSONObj(), resNss};
-        }
-        return {results.front(), resNss};
-    }
-
-    uassertStatusOKWithContext(getStatusFromCommandResult(res),
-                               str::stream() << "find command using UUID failed. Command: " << cmd);
-    MONGO_UNREACHABLE;
-}
-
 const uint64_t DBClientBase::INVALID_SOCK_CREATION_TIME = std::numeric_limits<uint64_t>::max();
 
-unique_ptr<DBClientCursor> DBClientBase::query(const NamespaceStringOrUUID& nsOrUuid,
-                                               const BSONObj& filter,
-                                               const Query& querySettings,
-                                               int limit,
-                                               int nToSkip,
-                                               const BSONObj* fieldsToReturn,
-                                               int queryOptions,
-                                               int batchSize,
-                                               boost::optional<BSONObj> readConcernObj) {
+unique_ptr<DBClientCursor> DBClientBase::query_DEPRECATED(const NamespaceStringOrUUID& nsOrUuid,
+                                                          const BSONObj& filter,
+                                                          const Query& querySettings,
+                                                          int limit,
+                                                          int nToSkip,
+                                                          const BSONObj* fieldsToReturn,
+                                                          int queryOptions,
+                                                          int batchSize,
+                                                          boost::optional<BSONObj> readConcernObj) {
     unique_ptr<DBClientCursor> c(new DBClientCursor(this,
                                                     nsOrUuid,
                                                     filter,
@@ -639,6 +599,15 @@ std::unique_ptr<DBClientCursor> DBClientBase::find(FindCommandRequest findReques
     return nullptr;
 }
 
+void DBClientBase::find(FindCommandRequest findRequest,
+                        const ReadPreferenceSetting& readPref,
+                        std::function<void(const BSONObj&)> callback) {
+    auto cursor = this->find(std::move(findRequest), readPref);
+    while (cursor->more()) {
+        callback(cursor->nextSafe());
+    }
+}
+
 BSONObj DBClientBase::findOne(FindCommandRequest findRequest,
                               const ReadPreferenceSetting& readPref) {
     tassert(5951200,
@@ -666,57 +635,28 @@ unique_ptr<DBClientCursor> DBClientBase::getMore(const string& ns, long long cur
     return nullptr;
 }
 
-struct DBClientFunConvertor {
-    void operator()(DBClientCursorBatchIterator& i) {
-        while (i.moreInCurrentBatch()) {
-            _f(i.nextSafe());
-        }
-    }
-    std::function<void(const BSONObj&)> _f;
-};
-
-unsigned long long DBClientBase::query(std::function<void(const BSONObj&)> f,
-                                       const NamespaceStringOrUUID& nsOrUuid,
-                                       const BSONObj& filter,
-                                       const Query& querySettings,
-                                       const BSONObj* fieldsToReturn,
-                                       int queryOptions,
-                                       int batchSize,
-                                       boost::optional<BSONObj> readConcernObj) {
-    DBClientFunConvertor fun;
-    fun._f = f;
-    std::function<void(DBClientCursorBatchIterator&)> ptr(fun);
-    return this->query(ptr,
-                       nsOrUuid,
-                       filter,
-                       querySettings,
-                       fieldsToReturn,
-                       queryOptions,
-                       batchSize,
-                       readConcernObj);
-}
-
-unsigned long long DBClientBase::query(std::function<void(DBClientCursorBatchIterator&)> f,
-                                       const NamespaceStringOrUUID& nsOrUuid,
-                                       const BSONObj& filter,
-                                       const Query& querySettings,
-                                       const BSONObj* fieldsToReturn,
-                                       int queryOptions,
-                                       int batchSize,
-                                       boost::optional<BSONObj> readConcernObj) {
+unsigned long long DBClientBase::query_DEPRECATED(
+    std::function<void(DBClientCursorBatchIterator&)> f,
+    const NamespaceStringOrUUID& nsOrUuid,
+    const BSONObj& filter,
+    const Query& querySettings,
+    const BSONObj* fieldsToReturn,
+    int queryOptions,
+    int batchSize,
+    boost::optional<BSONObj> readConcernObj) {
     // mask options
     queryOptions &= (int)(QueryOption_NoCursorTimeout | QueryOption_SecondaryOk);
 
-    unique_ptr<DBClientCursor> c(this->query(nsOrUuid,
-                                             filter,
-                                             querySettings,
-                                             0,
-                                             0,
-                                             fieldsToReturn,
-                                             queryOptions,
-                                             batchSize,
-                                             readConcernObj));
-    // query() throws on network error so OK to uassert with numeric code here.
+    unique_ptr<DBClientCursor> c(this->query_DEPRECATED(nsOrUuid,
+                                                        filter,
+                                                        querySettings,
+                                                        0,
+                                                        0,
+                                                        fieldsToReturn,
+                                                        queryOptions,
+                                                        batchSize,
+                                                        readConcernObj));
+    // query_DEPRECATED() throws on network error so OK to uassert with numeric code here.
     uassert(16090, "socket error for mapping query", c.get());
 
     unsigned long long n = 0;
diff --git a/src/mongo/client/dbclient_base.h b/src/mongo/client/dbclient_base.h
index f62fa148c26..d34bffd34ed 100644
--- a/src/mongo/client/dbclient_base.h
+++ b/src/mongo/client/dbclient_base.h
@@ -525,13 +525,22 @@ public:
     }
 
     /**
+     * Issues a find command described by 'findRequest' and the given read preference. Rather than
+     * returning a cursor to the caller, iterates the cursor under the hood and calls the provided
+     * 'callback' function against each of the documents produced by the cursor.
+     */
+    void find(FindCommandRequest findRequest,
+              const ReadPreferenceSetting& readPref,
+              std::function<void(const BSONObj&)> callback);
+
+    /**
      * Issues a find command describe by 'findRequest', but augments the request to have a limit of
      * 1. It is illegal for the given 'findRequest' to have a limit already set.
      *
      * Returns the document resulting from the query, or an empty document if the query has no
      * results.
      */
-    virtual BSONObj findOne(FindCommandRequest findRequest, const ReadPreferenceSetting& readPref);
+    BSONObj findOne(FindCommandRequest findRequest, const ReadPreferenceSetting& readPref);
 
     /**
      * Identical to the 'findOne()' overload above, but uses a default value of "primary" for the
@@ -549,26 +558,12 @@ public:
      * Returns the document resulting from the query, or an empty document if the query has no
      * results.
      */
-    virtual BSONObj findOne(const NamespaceStringOrUUID& nssOrUuid, BSONObj filter);
-
-    /**
-     * Returns a pair with a single object that matches the filter within the collection specified
-     * by the UUID and the namespace of that collection on the queried node.
-     *
-     * If the command fails, an assertion error is thrown. Otherwise, if no document matches
-     * the query, an empty BSONObj is returned.
-     * Throws AssertionException.
-     */
-    virtual std::pair<BSONObj, NamespaceString> findOneByUUID(
-        const std::string& db,
-        UUID uuid,
-        const BSONObj& filter,
-        boost::optional<BSONObj> readConcernObj = boost::none);
+    BSONObj findOne(const NamespaceStringOrUUID& nssOrUuid, BSONObj filter);
 
     /**
      * Legacy find API. Do not add new callers! Use the 'find*()' methods above instead.
      */
-    virtual std::unique_ptr<DBClientCursor> query(
+    virtual std::unique_ptr<DBClientCursor> query_DEPRECATED(
         const NamespaceStringOrUUID& nsOrUuid,
         const BSONObj& filter,
         const Query& querySettings = Query(),
@@ -578,22 +573,15 @@ public:
         int queryOptions = 0,
         int batchSize = 0,
         boost::optional<BSONObj> readConcernObj = boost::none);
-    unsigned long long query(std::function<void(const BSONObj&)> f,
-                             const NamespaceStringOrUUID& nsOrUuid,
-                             const BSONObj& filter,
-                             const Query& querySettings = Query(),
-                             const BSONObj* fieldsToReturn = nullptr,
-                             int queryOptions = QueryOption_Exhaust,
-                             int batchSize = 0,
-                             boost::optional<BSONObj> readConcernObj = boost::none);
-    virtual unsigned long long query(std::function<void(DBClientCursorBatchIterator&)> f,
-                                     const NamespaceStringOrUUID& nsOrUuid,
-                                     const BSONObj& filter,
-                                     const Query& querySettings = Query(),
-                                     const BSONObj* fieldsToReturn = nullptr,
-                                     int queryOptions = QueryOption_Exhaust,
-                                     int batchSize = 0,
-                                     boost::optional<BSONObj> readConcernObj = boost::none);
+    virtual unsigned long long query_DEPRECATED(
+        std::function<void(DBClientCursorBatchIterator&)> f,
+        const NamespaceStringOrUUID& nsOrUuid,
+        const BSONObj& filter,
+        const Query& querySettings = Query(),
+        const BSONObj* fieldsToReturn = nullptr,
+        int queryOptions = QueryOption_Exhaust,
+        int batchSize = 0,
+        boost::optional<BSONObj> readConcernObj = boost::none);
 
     /**
      * Don't use this - called automatically by DBClientCursor for you.
diff --git a/src/mongo/client/dbclient_connection.cpp b/src/mongo/client/dbclient_connection.cpp
index 760b060aa57..3eab2b4fab6 100644
--- a/src/mongo/client/dbclient_connection.cpp
+++ b/src/mongo/client/dbclient_connection.cpp
@@ -617,38 +617,39 @@ uint64_t DBClientConnection::getSockCreationMicroSec() const {
     }
 }
 
-unsigned long long DBClientConnection::query(std::function<void(DBClientCursorBatchIterator&)> f,
-                                             const NamespaceStringOrUUID& nsOrUuid,
-                                             const BSONObj& filter,
-                                             const Query& querySettings,
-                                             const BSONObj* fieldsToReturn,
-                                             int queryOptions,
-                                             int batchSize,
-                                             boost::optional<BSONObj> readConcernObj) {
+unsigned long long DBClientConnection::query_DEPRECATED(
+    std::function<void(DBClientCursorBatchIterator&)> f,
+    const NamespaceStringOrUUID& nsOrUuid,
+    const BSONObj& filter,
+    const Query& querySettings,
+    const BSONObj* fieldsToReturn,
+    int queryOptions,
+    int batchSize,
+    boost::optional<BSONObj> readConcernObj) {
     if (!(queryOptions & QueryOption_Exhaust)) {
-        return DBClientBase::query(f,
-                                   nsOrUuid,
-                                   filter,
-                                   querySettings,
-                                   fieldsToReturn,
-                                   queryOptions,
-                                   batchSize,
-                                   readConcernObj);
+        return DBClientBase::query_DEPRECATED(f,
+                                              nsOrUuid,
+                                              filter,
+                                              querySettings,
+                                              fieldsToReturn,
+                                              queryOptions,
+                                              batchSize,
+                                              readConcernObj);
     }
 
     // mask options
     queryOptions &=
         (int)(QueryOption_NoCursorTimeout | QueryOption_SecondaryOk | QueryOption_Exhaust);
 
-    unique_ptr<DBClientCursor> c(this->query(nsOrUuid,
-                                             filter,
-                                             querySettings,
-                                             0,
-                                             0,
-                                             fieldsToReturn,
-                                             queryOptions,
-                                             batchSize,
-                                             readConcernObj));
+    unique_ptr<DBClientCursor> c(this->query_DEPRECATED(nsOrUuid,
+                                                        filter,
+                                                        querySettings,
+                                                        0,
+                                                        0,
+                                                        fieldsToReturn,
+                                                        queryOptions,
+                                                        batchSize,
+                                                        readConcernObj));
     // Note that this->query will throw for network errors, so it is OK to return a numeric
     // error code here.
     uassert(13386, "socket error for mapping query", c.get());
diff --git a/src/mongo/client/dbclient_connection.h b/src/mongo/client/dbclient_connection.h
index 084600782c7..9187852758d 100644
--- a/src/mongo/client/dbclient_connection.h
+++ b/src/mongo/client/dbclient_connection.h
@@ -75,8 +75,6 @@ class DBClientCursorBatchIterator;
  */
 class DBClientConnection : public DBClientBase {
 public:
-    using DBClientBase::query;
-
     /**
      * A hook used to validate the reply of an 'isMaster' command during connection. If the hook
      * returns a non-OK Status, the DBClientConnection object will disconnect from the remote
@@ -145,7 +143,7 @@ public:
      */
     void logout(const std::string& dbname, BSONObj& info) override;
 
-    std::unique_ptr<DBClientCursor> query(
+    std::unique_ptr<DBClientCursor> query_DEPRECATED(
         const NamespaceStringOrUUID& nsOrUuid,
         const BSONObj& filter,
         const Query& querySettings = Query(),
@@ -156,25 +154,26 @@ public:
         int batchSize = 0,
         boost::optional<BSONObj> readConcernObj = boost::none) override {
         checkConnection();
-        return DBClientBase::query(nsOrUuid,
-                                   filter,
-                                   querySettings,
-                                   limit,
-                                   nToSkip,
-                                   fieldsToReturn,
-                                   queryOptions,
-                                   batchSize,
-                                   readConcernObj);
+        return DBClientBase::query_DEPRECATED(nsOrUuid,
+                                              filter,
+                                              querySettings,
+                                              limit,
+                                              nToSkip,
+                                              fieldsToReturn,
+                                              queryOptions,
+                                              batchSize,
+                                              readConcernObj);
     }
 
-    unsigned long long query(std::function<void(DBClientCursorBatchIterator&)>,
-                             const NamespaceStringOrUUID& nsOrUuid,
-                             const BSONObj& filter,
-                             const Query& querySettings,
-                             const BSONObj* fieldsToReturn,
-                             int queryOptions,
-                             int batchSize = 0,
-                             boost::optional<BSONObj> readConcernObj = boost::none) override;
+    unsigned long long query_DEPRECATED(
+        std::function<void(DBClientCursorBatchIterator&)>,
+        const NamespaceStringOrUUID& nsOrUuid,
+        const BSONObj& filter,
+        const Query& querySettings,
+        const BSONObj* fieldsToReturn,
+        int queryOptions,
+        int batchSize = 0,
+        boost::optional<BSONObj> readConcernObj = boost::none) override;
 
     using DBClientBase::runCommandWithTarget;
     std::pair<rpc::UniqueReply, DBClientBase*> runCommandWithTarget(OpMsgRequest request) override;
diff --git a/src/mongo/client/dbclient_rs.cpp b/src/mongo/client/dbclient_rs.cpp
index 5ee9708a9d4..bb460dffd4e 100644
--- a/src/mongo/client/dbclient_rs.cpp
+++ b/src/mongo/client/dbclient_rs.cpp
@@ -588,15 +588,16 @@ std::unique_ptr<DBClientCursor> DBClientReplicaSet::find(FindCommandRequest find
     return checkPrimary()->find(std::move(findRequest), readPref);
 }
 
-unique_ptr<DBClientCursor> DBClientReplicaSet::query(const NamespaceStringOrUUID& nsOrUuid,
-                                                     const BSONObj& filter,
-                                                     const Query& querySettings,
-                                                     int limit,
-                                                     int nToSkip,
-                                                     const BSONObj* fieldsToReturn,
-                                                     int queryOptions,
-                                                     int batchSize,
-                                                     boost::optional<BSONObj> readConcernObj) {
+unique_ptr<DBClientCursor> DBClientReplicaSet::query_DEPRECATED(
+    const NamespaceStringOrUUID& nsOrUuid,
+    const BSONObj& filter,
+    const Query& querySettings,
+    int limit,
+    int nToSkip,
+    const BSONObj* fieldsToReturn,
+    int queryOptions,
+    int batchSize,
+    boost::optional<BSONObj> readConcernObj) {
     shared_ptr<ReadPreferenceSetting> readPref(_extractReadPref(querySettings, queryOptions));
     invariant(nsOrUuid.nss());
     const string ns = nsOrUuid.nss()->ns();
@@ -625,15 +626,15 @@ unique_ptr<DBClientCursor> DBClientReplicaSet::query(const NamespaceStringOrUUID
                     break;
                 }
 
-                unique_ptr<DBClientCursor> cursor = conn->query(nsOrUuid,
-                                                                filter,
-                                                                querySettings,
-                                                                limit,
-                                                                nToSkip,
-                                                                fieldsToReturn,
-                                                                queryOptions,
-                                                                batchSize,
-                                                                readConcernObj);
+                unique_ptr<DBClientCursor> cursor = conn->query_DEPRECATED(nsOrUuid,
+                                                                           filter,
+                                                                           querySettings,
+                                                                           limit,
+                                                                           nToSkip,
+                                                                           fieldsToReturn,
+                                                                           queryOptions,
+                                                                           batchSize,
+                                                                           readConcernObj);
 
                 return checkSecondaryQueryResult(std::move(cursor));
             } catch (const DBException& ex) {
@@ -659,15 +660,15 @@ unique_ptr<DBClientCursor> DBClientReplicaSet::query(const NamespaceStringOrUUID
                 "dbclient_rs query to primary node",
                 "replicaSet"_attr = _getMonitor()->getName());
 
-    return checkPrimary()->query(nsOrUuid,
-                                 filter,
-                                 querySettings,
-                                 limit,
-                                 nToSkip,
-                                 fieldsToReturn,
-                                 queryOptions,
-                                 batchSize,
-                                 readConcernObj);
+    return checkPrimary()->query_DEPRECATED(nsOrUuid,
+                                            filter,
+                                            querySettings,
+                                            limit,
+                                            nToSkip,
+                                            fieldsToReturn,
+                                            queryOptions,
+                                            batchSize,
+                                            readConcernObj);
 }
 
 void DBClientReplicaSet::killCursor(const NamespaceString& ns, long long cursorID) {
diff --git a/src/mongo/client/dbclient_rs.h b/src/mongo/client/dbclient_rs.h
index e0b153c03c2..d31ff67f5b6 100644
--- a/src/mongo/client/dbclient_rs.h
+++ b/src/mongo/client/dbclient_rs.h
@@ -57,7 +57,7 @@ typedef std::shared_ptr<ReplicaSetMonitor> ReplicaSetMonitorPtr;
 */
 class DBClientReplicaSet : public DBClientBase {
 public:
-    using DBClientBase::query;
+    using DBClientBase::query_DEPRECATED;
 
     /** Call connect() after constructing. autoReconnect is always on for DBClientReplicaSet
      * connections. */
@@ -92,7 +92,7 @@ public:
                                          const ReadPreferenceSetting& readPref) override;
 
     /** throws userassertion "no primary found" */
-    std::unique_ptr<DBClientCursor> query(
+    std::unique_ptr<DBClientCursor> query_DEPRECATED(
         const NamespaceStringOrUUID& nsOrUuid,
         const BSONObj& filter,
         const Query& querySettings,
diff --git a/src/mongo/client/dbclient_rs_test.cpp b/src/mongo/client/dbclient_rs_test.cpp
index c7ce251a154..12503574758 100644
--- a/src/mongo/client/dbclient_rs_test.cpp
+++ b/src/mongo/client/dbclient_rs_test.cpp
@@ -147,17 +147,57 @@ void assertNodeSelected(MockReplicaSet* replSet, ReadPreference rp, StringData h
     assertOneOfNodesSelected(replSet, rp, std::vector<std::string>{host.toString()});
 }
 
+/**
+ * Runs a find operation against 'replConn' using both the modern 'find()' API and the deprecated
+ * API. In both cases, verifies the results by passing the resulting cursor to 'assertionFunc'.
+ *
+ * The operation is a simple find command against the given NamespaceString with no arguments other
+ * than 'readPref'.
+ */
+void assertWithBothQueryApis(DBClientReplicaSet& replConn,
+                             const NamespaceString& nss,
+                             ReadPreference readPref,
+                             std::function<void(std::unique_ptr<DBClientCursor>)> assertionFunc) {
+    std::unique_ptr<DBClientCursor> cursor =
+        replConn.find(FindCommandRequest{nss}, ReadPreferenceSetting{readPref});
+    assertionFunc(std::move(cursor));
+
+    Query readPrefHolder;
+    readPrefHolder.readPref(readPref, BSONArray{});
+    cursor = replConn.query_DEPRECATED(nss, BSONObj{}, readPrefHolder);
+    assertionFunc(std::move(cursor));
+}
+
+/**
+ * Runs a find operation against 'replConn' using both the modern 'find()' API and the deprecated
+ * API. In both cases, verifies that the find operation throws an exception.
+ *
+ * The operation is a simple find command against the given NamespaceString with no arguments other
+ * than 'readPref'.
+ */
+void assertBothQueryApisThrow(DBClientReplicaSet& replConn,
+                              const NamespaceString& nss,
+                              ReadPreference readPref) {
+    ASSERT_THROWS(replConn.find(FindCommandRequest{nss}, ReadPreferenceSetting{readPref}),
+                  AssertionException);
+
+    Query readPrefHolder;
+    readPrefHolder.readPref(readPref, BSONArray{});
+    ASSERT_THROWS(replConn.query_DEPRECATED(nss, BSONObj{}, readPrefHolder), AssertionException);
+}
+
 TEST_F(BasicRS, QueryPrimary) {
     MockReplicaSet* replSet = getReplSet();
     DBClientReplicaSet replConn(replSet->getSetName(), replSet->getHosts(), StringData());
 
     // Note: IdentityNS contains the name of the server.
-    unique_ptr<DBClientCursor> cursor =
-        replConn.query(NamespaceString(IdentityNS),
-                       BSONObj{},
-                       Query().readPref(mongo::ReadPreference::PrimaryOnly, BSONArray()));
-    BSONObj doc = cursor->next();
-    ASSERT_EQUALS(replSet->getPrimary(), doc[HostField.name()].str());
+    assertWithBothQueryApis(replConn,
+                            NamespaceString{IdentityNS},
+                            ReadPreference::PrimaryOnly,
+                            [&](std::unique_ptr<DBClientCursor> cursor) {
+                                BSONObj doc = cursor->next();
+                                ASSERT_EQUALS(replSet->getPrimary(), doc[HostField.name()].str());
+                            });
 }
 
 TEST_F(BasicRS, CommandPrimary) {
@@ -169,12 +209,14 @@ TEST_F(BasicRS, QuerySecondaryOnly) {
     DBClientReplicaSet replConn(replSet->getSetName(), replSet->getHosts(), StringData());
 
     // Note: IdentityNS contains the name of the server.
-    unique_ptr<DBClientCursor> cursor =
-        replConn.query(NamespaceString(IdentityNS),
-                       BSONObj{},
-                       Query().readPref(mongo::ReadPreference::SecondaryOnly, BSONArray()));
-    BSONObj doc = cursor->next();
-    ASSERT_EQUALS(replSet->getSecondaries().front(), doc[HostField.name()].str());
+    assertWithBothQueryApis(replConn,
+                            NamespaceString{IdentityNS},
+                            ReadPreference::SecondaryOnly,
+                            [&](std::unique_ptr<DBClientCursor> cursor) {
+                                BSONObj doc = cursor->next();
+                                ASSERT_EQUALS(replSet->getSecondaries().front(),
+                                              doc[HostField.name()].str());
+                            });
 }
 
 TEST_F(BasicRS, CommandSecondaryOnly) {
@@ -187,12 +229,13 @@ TEST_F(BasicRS, QueryPrimaryPreferred) {
     DBClientReplicaSet replConn(replSet->getSetName(), replSet->getHosts(), StringData());
 
     // Note: IdentityNS contains the name of the server.
-    unique_ptr<DBClientCursor> cursor =
-        replConn.query(NamespaceString(IdentityNS),
-                       BSONObj{},
-                       Query().readPref(mongo::ReadPreference::PrimaryPreferred, BSONArray()));
-    BSONObj doc = cursor->next();
-    ASSERT_EQUALS(replSet->getPrimary(), doc[HostField.name()].str());
+    assertWithBothQueryApis(replConn,
+                            NamespaceString{IdentityNS},
+                            ReadPreference::PrimaryPreferred,
+                            [&](std::unique_ptr<DBClientCursor> cursor) {
+                                BSONObj doc = cursor->next();
+                                ASSERT_EQUALS(replSet->getPrimary(), doc[HostField.name()].str());
+                            });
 }
 
 TEST_F(BasicRS, CommandPrimaryPreferred) {
@@ -204,12 +247,14 @@ TEST_F(BasicRS, QuerySecondaryPreferred) {
     DBClientReplicaSet replConn(replSet->getSetName(), replSet->getHosts(), StringData());
 
     // Note: IdentityNS contains the name of the server.
-    unique_ptr<DBClientCursor> cursor =
-        replConn.query(NamespaceString(IdentityNS),
-                       BSONObj{},
-                       Query().readPref(mongo::ReadPreference::SecondaryPreferred, BSONArray()));
-    BSONObj doc = cursor->next();
-    ASSERT_EQUALS(replSet->getSecondaries().front(), doc[HostField.name()].str());
+    assertWithBothQueryApis(replConn,
+                            NamespaceString{IdentityNS},
+                            ReadPreference::SecondaryPreferred,
+                            [&](std::unique_ptr<DBClientCursor> cursor) {
+                                BSONObj doc = cursor->next();
+                                ASSERT_EQUALS(replSet->getSecondaries().front(),
+                                              doc[HostField.name()].str());
+                            });
 }
 
 TEST_F(BasicRS, CommandSecondaryPreferred) {
@@ -269,10 +314,7 @@ TEST_F(AllNodesDown, QueryPrimary) {
     MockReplicaSet* replSet = getReplSet();
     DBClientReplicaSet replConn(replSet->getSetName(), replSet->getHosts(), StringData());
 
-    Query query;
-    query.readPref(mongo::ReadPreference::PrimaryOnly, BSONArray());
-    ASSERT_THROWS(replConn.query(NamespaceString(IdentityNS), BSONObj{}, query),
-                  AssertionException);
+    assertBothQueryApisThrow(replConn, NamespaceString{IdentityNS}, ReadPreference::PrimaryOnly);
 }
 
 TEST_F(AllNodesDown, CommandPrimary) {
@@ -283,10 +325,7 @@ TEST_F(AllNodesDown, QuerySecondaryOnly) {
     MockReplicaSet* replSet = getReplSet();
     DBClientReplicaSet replConn(replSet->getSetName(), replSet->getHosts(), StringData());
 
-    Query query;
-    query.readPref(mongo::ReadPreference::SecondaryOnly, BSONArray());
-    ASSERT_THROWS(replConn.query(NamespaceString(IdentityNS), BSONObj{}, query),
-                  AssertionException);
+    assertBothQueryApisThrow(replConn, NamespaceString{IdentityNS}, ReadPreference::SecondaryOnly);
 }
 
 TEST_F(AllNodesDown, CommandSecondaryOnly) {
@@ -297,10 +336,8 @@ TEST_F(AllNodesDown, QueryPrimaryPreferred) {
     MockReplicaSet* replSet = getReplSet();
     DBClientReplicaSet replConn(replSet->getSetName(), replSet->getHosts(), StringData());
 
-    Query query;
-    query.readPref(mongo::ReadPreference::PrimaryPreferred, BSONArray());
-    ASSERT_THROWS(replConn.query(NamespaceString(IdentityNS), BSONObj{}, query),
-                  AssertionException);
+    assertBothQueryApisThrow(
+        replConn, NamespaceString{IdentityNS}, ReadPreference::PrimaryPreferred);
 }
 
 TEST_F(AllNodesDown, CommandPrimaryPreferred) {
@@ -311,10 +348,8 @@ TEST_F(AllNodesDown, QuerySecondaryPreferred) {
     MockReplicaSet* replSet = getReplSet();
     DBClientReplicaSet replConn(replSet->getSetName(), replSet->getHosts(), StringData());
 
-    Query query;
-    query.readPref(mongo::ReadPreference::SecondaryPreferred, BSONArray());
-    ASSERT_THROWS(replConn.query(NamespaceString(IdentityNS), BSONObj{}, query),
-                  AssertionException);
+    assertBothQueryApisThrow(
+        replConn, NamespaceString{IdentityNS}, ReadPreference::SecondaryPreferred);
 }
 
 TEST_F(AllNodesDown, CommandSecondaryPreferred) {
@@ -325,10 +360,7 @@ TEST_F(AllNodesDown, QueryNearest) {
     MockReplicaSet* replSet = getReplSet();
     DBClientReplicaSet replConn(replSet->getSetName(), replSet->getHosts(), StringData());
 
-    Query query;
-    query.readPref(mongo::ReadPreference::Nearest, BSONArray());
-    ASSERT_THROWS(replConn.query(NamespaceString(IdentityNS), BSONObj{}, query),
-                  AssertionException);
+    assertBothQueryApisThrow(replConn, NamespaceString{IdentityNS}, ReadPreference::Nearest);
 }
 
 TEST_F(AllNodesDown, CommandNearest) {
@@ -372,10 +404,7 @@ TEST_F(PrimaryDown, QueryPrimary) {
     MockReplicaSet* replSet = getReplSet();
     DBClientReplicaSet replConn(replSet->getSetName(), replSet->getHosts(), StringData());
 
-    Query query;
-    query.readPref(mongo::ReadPreference::PrimaryOnly, BSONArray());
-    ASSERT_THROWS(replConn.query(NamespaceString(IdentityNS), BSONObj{}, query),
-                  AssertionException);
+    assertBothQueryApisThrow(replConn, NamespaceString{IdentityNS}, ReadPreference::PrimaryOnly);
 }
 
 TEST_F(PrimaryDown, CommandPrimary) {
@@ -386,14 +415,15 @@ TEST_F(PrimaryDown, QuerySecondaryOnly) {
     MockReplicaSet* replSet = getReplSet();
     DBClientReplicaSet replConn(replSet->getSetName(), replSet->getHosts(), StringData());
 
-    Query query;
-    query.readPref(mongo::ReadPreference::SecondaryOnly, BSONArray());
-
     // Note: IdentityNS contains the name of the server.
-    unique_ptr<DBClientCursor> cursor =
-        replConn.query(NamespaceString(IdentityNS), BSONObj{}, query);
-    BSONObj doc = cursor->next();
-    ASSERT_EQUALS(replSet->getSecondaries().front(), doc[HostField.name()].str());
+    assertWithBothQueryApis(replConn,
+                            NamespaceString{IdentityNS},
+                            ReadPreference::SecondaryOnly,
+                            [&](std::unique_ptr<DBClientCursor> cursor) {
+                                BSONObj doc = cursor->next();
+                                ASSERT_EQUALS(replSet->getSecondaries().front(),
+                                              doc[HostField.name()].str());
+                            });
 }
 
 TEST_F(PrimaryDown, CommandSecondaryOnly) {
@@ -405,14 +435,15 @@ TEST_F(PrimaryDown, QueryPrimaryPreferred) {
     MockReplicaSet* replSet = getReplSet();
     DBClientReplicaSet replConn(replSet->getSetName(), replSet->getHosts(), StringData());
 
-    Query query;
-    query.readPref(mongo::ReadPreference::PrimaryPreferred, BSONArray());
-
     // Note: IdentityNS contains the name of the server.
-    unique_ptr<DBClientCursor> cursor =
-        replConn.query(NamespaceString(IdentityNS), BSONObj{}, query);
-    BSONObj doc = cursor->next();
-    ASSERT_EQUALS(replSet->getSecondaries().front(), doc[HostField.name()].str());
+    assertWithBothQueryApis(replConn,
+                            NamespaceString{IdentityNS},
+                            ReadPreference::PrimaryPreferred,
+                            [&](std::unique_ptr<DBClientCursor> cursor) {
+                                BSONObj doc = cursor->next();
+                                ASSERT_EQUALS(replSet->getSecondaries().front(),
+                                              doc[HostField.name()].str());
+                            });
 }
 
 TEST_F(PrimaryDown, CommandPrimaryPreferred) {
@@ -424,14 +455,15 @@ TEST_F(PrimaryDown, QuerySecondaryPreferred) {
     MockReplicaSet* replSet = getReplSet();
     DBClientReplicaSet replConn(replSet->getSetName(), replSet->getHosts(), StringData());
 
-    Query query;
-    query.readPref(mongo::ReadPreference::SecondaryPreferred, BSONArray());
-
     // Note: IdentityNS contains the name of the server.
-    unique_ptr<DBClientCursor> cursor =
-        replConn.query(NamespaceString(IdentityNS), BSONObj{}, query);
-    BSONObj doc = cursor->next();
-    ASSERT_EQUALS(replSet->getSecondaries().front(), doc[HostField.name()].str());
+    assertWithBothQueryApis(replConn,
+                            NamespaceString{IdentityNS},
+                            ReadPreference::SecondaryPreferred,
+                            [&](std::unique_ptr<DBClientCursor> cursor) {
+                                BSONObj doc = cursor->next();
+                                ASSERT_EQUALS(replSet->getSecondaries().front(),
+                                              doc[HostField.name()].str());
+                            });
 }
 
 TEST_F(PrimaryDown, CommandSecondaryPreferred) {
@@ -443,12 +475,14 @@ TEST_F(PrimaryDown, Nearest) {
     MockReplicaSet* replSet = getReplSet();
     DBClientReplicaSet replConn(replSet->getSetName(), replSet->getHosts(), StringData());
 
-    Query query;
-    query.readPref(mongo::ReadPreference::Nearest, BSONArray());
-    unique_ptr<DBClientCursor> cursor =
-        replConn.query(NamespaceString(IdentityNS), BSONObj{}, query);
-    BSONObj doc = cursor->next();
-    ASSERT_EQUALS(replSet->getSecondaries().front(), doc[HostField.name()].str());
+    assertWithBothQueryApis(replConn,
+                            NamespaceString{IdentityNS},
+                            ReadPreference::Nearest,
+                            [&](std::unique_ptr<DBClientCursor> cursor) {
+                                BSONObj doc = cursor->next();
+                                ASSERT_EQUALS(replSet->getSecondaries().front(),
+                                              doc[HostField.name()].str());
+                            });
 }
 
 /**
@@ -489,14 +523,14 @@ TEST_F(SecondaryDown, QueryPrimary) {
     MockReplicaSet* replSet = getReplSet();
     DBClientReplicaSet replConn(replSet->getSetName(), replSet->getHosts(), StringData());
 
-    Query query;
-    query.readPref(mongo::ReadPreference::PrimaryOnly, BSONArray());
-
     // Note: IdentityNS contains the name of the server.
-    unique_ptr<DBClientCursor> cursor =
-        replConn.query(NamespaceString(IdentityNS), BSONObj{}, query);
-    BSONObj doc = cursor->next();
-    ASSERT_EQUALS(replSet->getPrimary(), doc[HostField.name()].str());
+    assertWithBothQueryApis(replConn,
+                            NamespaceString{IdentityNS},
+                            ReadPreference::PrimaryOnly,
+                            [&](std::unique_ptr<DBClientCursor> cursor) {
+                                BSONObj doc = cursor->next();
+                                ASSERT_EQUALS(replSet->getPrimary(), doc[HostField.name()].str());
+                            });
 }
 
 TEST_F(SecondaryDown, CommandPrimary) {
@@ -507,10 +541,7 @@ TEST_F(SecondaryDown, QuerySecondaryOnly) {
     MockReplicaSet* replSet = getReplSet();
     DBClientReplicaSet replConn(replSet->getSetName(), replSet->getHosts(), StringData());
 
-    Query query;
-    query.readPref(mongo::ReadPreference::SecondaryOnly, BSONArray());
-    ASSERT_THROWS(replConn.query(NamespaceString(IdentityNS), BSONObj{}, query),
-                  AssertionException);
+    assertBothQueryApisThrow(replConn, NamespaceString{IdentityNS}, ReadPreference::SecondaryOnly);
 }
 
 TEST_F(SecondaryDown, CommandSecondaryOnly) {
@@ -521,14 +552,14 @@ TEST_F(SecondaryDown, QueryPrimaryPreferred) {
     MockReplicaSet* replSet = getReplSet();
     DBClientReplicaSet replConn(replSet->getSetName(), replSet->getHosts(), StringData());
 
-    Query query;
-    query.readPref(mongo::ReadPreference::PrimaryPreferred, BSONArray());
-
     // Note: IdentityNS contains the name of the server.
-    unique_ptr<DBClientCursor> cursor =
-        replConn.query(NamespaceString(IdentityNS), BSONObj{}, query);
-    BSONObj doc = cursor->next();
-    ASSERT_EQUALS(replSet->getPrimary(), doc[HostField.name()].str());
+    assertWithBothQueryApis(replConn,
+                            NamespaceString{IdentityNS},
+                            ReadPreference::PrimaryPreferred,
+                            [&](std::unique_ptr<DBClientCursor> cursor) {
+                                BSONObj doc = cursor->next();
+                                ASSERT_EQUALS(replSet->getPrimary(), doc[HostField.name()].str());
+                            });
 }
 
 TEST_F(SecondaryDown, CommandPrimaryPreferred) {
@@ -539,14 +570,13 @@ TEST_F(SecondaryDown, QuerySecondaryPreferred) {
     MockReplicaSet* replSet = getReplSet();
     DBClientReplicaSet replConn(replSet->getSetName(), replSet->getHosts(), StringData());
 
-    Query query;
-    query.readPref(mongo::ReadPreference::SecondaryPreferred, BSONArray());
-
-    // Note: IdentityNS contains the name of the server.
-    unique_ptr<DBClientCursor> cursor =
-        replConn.query(NamespaceString(IdentityNS), BSONObj{}, query);
-    BSONObj doc = cursor->next();
-    ASSERT_EQUALS(replSet->getPrimary(), doc[HostField.name()].str());
+    assertWithBothQueryApis(replConn,
+                            NamespaceString{IdentityNS},
+                            ReadPreference::SecondaryPreferred,
+                            [&](std::unique_ptr<DBClientCursor> cursor) {
+                                BSONObj doc = cursor->next();
+                                ASSERT_EQUALS(replSet->getPrimary(), doc[HostField.name()].str());
+                            });
 }
 
 TEST_F(SecondaryDown, CommandSecondaryPreferred) {
@@ -557,14 +587,13 @@ TEST_F(SecondaryDown, QueryNearest) {
     MockReplicaSet* replSet = getReplSet();
     DBClientReplicaSet replConn(replSet->getSetName(), replSet->getHosts(), StringData());
 
-    Query query;
-    query.readPref(mongo::ReadPreference::Nearest, BSONArray());
-
-    // Note: IdentityNS contains the name of the server.
-    unique_ptr<DBClientCursor> cursor =
-        replConn.query(NamespaceString(IdentityNS), BSONObj{}, query);
-    BSONObj doc = cursor->next();
-    ASSERT_EQUALS(replSet->getPrimary(), doc[HostField.name()].str());
+    assertWithBothQueryApis(replConn,
+                            NamespaceString{IdentityNS},
+                            ReadPreference::Nearest,
+                            [&](std::unique_ptr<DBClientCursor> cursor) {
+                                BSONObj doc = cursor->next();
+                                ASSERT_EQUALS(replSet->getPrimary(), doc[HostField.name()].str());
+                            });
 }
 
 TEST_F(SecondaryDown, CommandNearest) {
@@ -709,21 +738,18 @@ TEST_F(TaggedFiveMemberRS, ConnShouldPinIfSameSettings) {
 
     string dest;
     {
-        Query query;
-        query.readPref(mongo::ReadPreference::PrimaryPreferred, BSONArray());
-
         // Note: IdentityNS contains the name of the server.
-        unique_ptr<DBClientCursor> cursor =
-            replConn.query(NamespaceString(IdentityNS), BSONObj{}, query);
+        std::unique_ptr<DBClientCursor> cursor =
+            replConn.find(FindCommandRequest{NamespaceString{IdentityNS}},
+                          ReadPreferenceSetting{ReadPreference::PrimaryPreferred});
         BSONObj doc = cursor->next();
         dest = doc[HostField.name()].str();
     }
 
     {
-        Query query;
-        query.readPref(mongo::ReadPreference::PrimaryPreferred, BSONArray());
-        unique_ptr<DBClientCursor> cursor =
-            replConn.query(NamespaceString(IdentityNS), BSONObj{}, query);
+        std::unique_ptr<DBClientCursor> cursor =
+            replConn.find(FindCommandRequest{NamespaceString{IdentityNS}},
+                          ReadPreferenceSetting{ReadPreference::PrimaryPreferred});
         BSONObj doc = cursor->next();
         const string newDest = doc[HostField.name()].str();
         ASSERT_EQUALS(dest, newDest);
@@ -739,12 +765,10 @@ TEST_F(TaggedFiveMemberRS, ConnShouldNotPinIfHostMarkedAsFailed) {
 
     string dest;
     {
-        Query query;
-        query.readPref(mongo::ReadPreference::PrimaryPreferred, BSONArray());
-
         // Note: IdentityNS contains the name of the server.
-        unique_ptr<DBClientCursor> cursor =
-            replConn.query(NamespaceString(IdentityNS), BSONObj{}, query);
+        std::unique_ptr<DBClientCursor> cursor =
+            replConn.find(FindCommandRequest{NamespaceString{IdentityNS}},
+                          ReadPreferenceSetting{ReadPreference::PrimaryPreferred});
         BSONObj doc = cursor->next();
         dest = doc[HostField.name()].str();
     }
@@ -756,10 +780,9 @@ TEST_F(TaggedFiveMemberRS, ConnShouldNotPinIfHostMarkedAsFailed) {
     getTopologyManager()->setTopologyDescription(getReplSet()->getTopologyDescription(clock()));
 
     {
-        Query query;
-        query.readPref(mongo::ReadPreference::PrimaryPreferred, BSONArray());
-        unique_ptr<DBClientCursor> cursor =
-            replConn.query(NamespaceString(IdentityNS), BSONObj{}, query);
+        std::unique_ptr<DBClientCursor> cursor =
+            replConn.find(FindCommandRequest{NamespaceString{IdentityNS}},
+                          ReadPreferenceSetting{ReadPreference::PrimaryPreferred});
         BSONObj doc = cursor->next();
         const string newDest = doc[HostField.name()].str();
         ASSERT_NOT_EQUALS(dest, newDest);
@@ -774,13 +797,13 @@ TEST_F(TaggedFiveMemberRS, SecondaryConnReturnsSecConn) {
 
     DBClientReplicaSet replConn(replSet->getSetName(), seedList, StringData());
 
-    string dest;
     mongo::DBClientConnection& secConn = replConn.secondaryConn();
 
     // Note: IdentityNS contains the name of the server.
-    unique_ptr<DBClientCursor> cursor = secConn.query(NamespaceString(IdentityNS), BSONObj{});
+    std::unique_ptr<DBClientCursor> cursor =
+        secConn.find(FindCommandRequest{NamespaceString{IdentityNS}});
     BSONObj doc = cursor->next();
-    dest = doc[HostField.name()].str();
+    std::string dest = doc[HostField.name()].str();
     ASSERT_NOT_EQUALS(dest, replSet->getPrimary());
 }
 
diff --git a/src/mongo/client/query.h b/src/mongo/client/query.h
index c4153099d65..af85022fb07 100644
--- a/src/mongo/client/query.h
+++ b/src/mongo/client/query.h
@@ -36,9 +36,9 @@
 namespace mongo {
 
 /**
- * Represents a subset query settings, such as sort, hint, etc. and might also contain a query
- * filter. The class is being evolved into statically checkable QueryOptions type that won't include
- * the filter and will encompass all relevant query settings.
+ * Represents a subset of query settings, such as sort, hint, etc. It is only used in the context of
+ * the deprecated query API in 'DBClientBase', which has been superseded by `DBClientBase::find()`
+ * and friends. Additional uses of this class should not be added to the code base!
  */
 class Query {
 public:
@@ -69,16 +69,6 @@ public:
     */
     Query& sort(const BSONObj& sortPattern);
 
-    /** Add a sort (ORDER BY) criteria to the query expression.
-        This version of sort() assumes you want to sort on a single field.
-        @param asc = 1 for ascending order
-        asc = -1 for descending order
-    */
-    Query& sort(const std::string& field, int asc = 1) {
-        sort(BSON(field << asc));
-        return *this;
-    }
-
     /** Provide a hint to the query.
         @param keyPattern Key pattern for the index to use.
         Example:
diff --git a/src/mongo/db/auth/authz_manager_external_state_d.cpp b/src/mongo/db/auth/authz_manager_external_state_d.cpp
index e8dc4cdda7a..2f0618a200b 100644
--- a/src/mongo/db/auth/authz_manager_external_state_d.cpp
+++ b/src/mongo/db/auth/authz_manager_external_state_d.cpp
@@ -65,7 +65,10 @@ Status AuthzManagerExternalStateMongod::query(
     const std::function<void(const BSONObj&)>& resultProcessor) {
     try {
         DBDirectClient client(opCtx);
-        client.query(resultProcessor, collectionName, filter, Query(), &projection);
+        FindCommandRequest findRequest{collectionName};
+        findRequest.setFilter(filter);
+        findRequest.setProjection(projection);
+        client.find(std::move(findRequest), ReadPreferenceSetting{}, resultProcessor);
         return Status::OK();
     } catch (const DBException& e) {
         return e.toStatus();
diff --git a/src/mongo/db/cloner.cpp b/src/mongo/db/cloner.cpp
index 47a52d59dcd..0f3aabee49a 100644
--- a/src/mongo/db/cloner.cpp
+++ b/src/mongo/db/cloner.cpp
@@ -250,14 +250,14 @@ void Cloner::_copy(OperationContext* opCtx,
 
     int options = QueryOption_NoCursorTimeout | QueryOption_Exhaust;
 
-    conn->query(std::function<void(DBClientCursorBatchIterator&)>(f),
-                nss,
-                BSONObj{} /* filter */,
-                Query() /* querySettings */,
-                nullptr,
-                options,
-                0 /* batchSize */,
-                repl::ReadConcernArgs::kImplicitDefault);
+    conn->query_DEPRECATED(std::function<void(DBClientCursorBatchIterator&)>(f),
+                           nss,
+                           BSONObj{} /* filter */,
+                           Query() /* querySettings */,
+                           nullptr,
+                           options,
+                           0 /* batchSize */,
+                           repl::ReadConcernArgs::kImplicitDefault);
 }
 
 void Cloner::_copyIndexes(OperationContext* opCtx,
diff --git a/src/mongo/db/commands/dbcommands_d.cpp b/src/mongo/db/commands/dbcommands_d.cpp
index c2ae35541ea..4bcc4350455 100644
--- a/src/mongo/db/commands/dbcommands_d.cpp
+++ b/src/mongo/db/commands/dbcommands_d.cpp
@@ -411,8 +411,10 @@ public:
                     const BSONObj& query,
                     const BSONObj& sort) {
         DBDirectClient client(opCtx);
-        std::unique_ptr<DBClientCursor> c =
-            client.query(NamespaceString(ns), query, Query().sort(sort));
+        FindCommandRequest findRequest{NamespaceString{ns}};
+        findRequest.setFilter(query);
+        findRequest.setSort(sort);
+        std::unique_ptr<DBClientCursor> c = client.find(std::move(findRequest));
         while (c->more()) {
             LOGV2(20454, "Chunk: {chunk}", "Dumping chunks", "chunk"_attr = c->nextSafe());
         }
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 0afc4dd5348..828d1857c8a 100644
--- a/src/mongo/db/commands/set_feature_compatibility_version_command.cpp
+++ b/src/mongo/db/commands/set_feature_compatibility_version_command.cpp
@@ -780,13 +780,10 @@ private:
         DBDirectClient client(opCtx);
 
         LogicalSessionIdMap<TxnNumber> parentLsidToTxnNum;
-        auto projection = BSON("_id" << 1 << "parentLsid" << 1);
-        auto cursor = client.query(NamespaceString::kSessionTransactionsTableNamespace,
-                                   BSON("parentLsid" << BSON("$exists" << true)),
-                                   {},
-                                   0,
-                                   0,
-                                   &projection);
+        FindCommandRequest findRequest{NamespaceString::kSessionTransactionsTableNamespace};
+        findRequest.setFilter(BSON("parentLsid" << BSON("$exists" << true)));
+        findRequest.setProjection(BSON("_id" << 1 << "parentLsid" << 1));
+        auto cursor = client.find(std::move(findRequest));
 
         while (cursor->more()) {
             auto doc = cursor->next();
@@ -823,8 +820,9 @@ private:
         for (const auto& [lsid, txnNumber] : parentLsidToTxnNum) {
             SessionTxnRecord modifiedDoc;
             bool parentSessionExists = false;
-            auto cursor = client.query(NamespaceString::kSessionTransactionsTableNamespace,
-                                       BSON("_id" << lsid.toBSON()));
+            FindCommandRequest findRequest{NamespaceString::kSessionTransactionsTableNamespace};
+            findRequest.setFilter(BSON("_id" << lsid.toBSON()));
+            auto cursor = client.find(std::move(findRequest));
             if ((parentSessionExists = cursor->more())) {
                 modifiedDoc = SessionTxnRecord::parse(
                     IDLParserErrorContext("parse transaction document to modify"), cursor->next());
diff --git a/src/mongo/db/commands/user_management_commands.cpp b/src/mongo/db/commands/user_management_commands.cpp
index 178bd5c27f5..2a5f37ae267 100644
--- a/src/mongo/db/commands/user_management_commands.cpp
+++ b/src/mongo/db/commands/user_management_commands.cpp
@@ -229,7 +229,10 @@ Status queryAuthzDocument(OperationContext* opCtx,
                           const std::function<void(const BSONObj&)>& resultProcessor) {
     try {
         DBDirectClient client(opCtx);
-        client.query(resultProcessor, collectionName, query, Query(), &projection);
+        FindCommandRequest findRequest{collectionName};
+        findRequest.setFilter(query);
+        findRequest.setProjection(projection);
+        client.find(std::move(findRequest), ReadPreferenceSetting{}, resultProcessor);
         return Status::OK();
     } catch (const DBException& e) {
         return e.toStatus();
diff --git a/src/mongo/db/dbdirectclient.cpp b/src/mongo/db/dbdirectclient.cpp
index 580104f1c48..479557afc7e 100644
--- a/src/mongo/db/dbdirectclient.cpp
+++ b/src/mongo/db/dbdirectclient.cpp
@@ -145,18 +145,11 @@ void DBDirectClient::say(Message& toSend, bool isRetry, string* actualServer) {
     invariant(dbResponse.response.empty());
 }
 
-unique_ptr<DBClientCursor> DBDirectClient::query(const NamespaceStringOrUUID& nsOrUuid,
-                                                 const BSONObj& filter,
-                                                 const Query& querySettings,
-                                                 int limit,
-                                                 int nToSkip,
-                                                 const BSONObj* fieldsToReturn,
-                                                 int queryOptions,
-                                                 int batchSize,
-                                                 boost::optional<BSONObj> readConcernObj) {
-    invariant(!readConcernObj, "passing readConcern to DBDirectClient functions is not supported");
-    return DBClientBase::query(
-        nsOrUuid, filter, querySettings, limit, nToSkip, fieldsToReturn, queryOptions, batchSize);
+std::unique_ptr<DBClientCursor> DBDirectClient::find(FindCommandRequest findRequest,
+                                                     const ReadPreferenceSetting& readPref) {
+    invariant(!findRequest.getReadConcern(),
+              "passing readConcern to DBDirectClient::find() is not supported");
+    return DBClientBase::find(std::move(findRequest), readPref);
 }
 
 write_ops::FindAndModifyCommandReply DBDirectClient::findAndModify(
diff --git a/src/mongo/db/dbdirectclient.h b/src/mongo/db/dbdirectclient.h
index b0f8a74f09f..7c8e89d0bc2 100644
--- a/src/mongo/db/dbdirectclient.h
+++ b/src/mongo/db/dbdirectclient.h
@@ -52,21 +52,13 @@ class DBDirectClient : public DBClientBase {
 public:
     DBDirectClient(OperationContext* opCtx);
 
+    using DBClientBase::find;
     using DBClientBase::insert;
-    using DBClientBase::query;
     using DBClientBase::remove;
     using DBClientBase::update;
 
-    std::unique_ptr<DBClientCursor> query(
-        const NamespaceStringOrUUID& nsOrUuid,
-        const BSONObj& filter,
-        const Query& querySettings = Query(),
-        int limit = 0,
-        int nToSkip = 0,
-        const BSONObj* fieldsToReturn = nullptr,
-        int queryOptions = 0,
-        int batchSize = 0,
-        boost::optional<BSONObj> readConcernObj = boost::none) override;
+    std::unique_ptr<DBClientCursor> find(FindCommandRequest findRequest,
+                                         const ReadPreferenceSetting& readPref) override;
 
     write_ops::FindAndModifyCommandReply findAndModify(
         const write_ops::FindAndModifyCommandRequest& findAndModify);
diff --git a/src/mongo/db/dbdirectclient_test.cpp b/src/mongo/db/dbdirectclient_test.cpp
index 9b94c094aa2..f46097d4004 100644
--- a/src/mongo/db/dbdirectclient_test.cpp
+++ b/src/mongo/db/dbdirectclient_test.cpp
@@ -172,7 +172,7 @@ TEST_F(DBDirectClientTest, ExhaustQuery) {
 
     // The query should work even though exhaust mode is requested.
     int batchSize = 2;
-    auto cursor = client.query(
+    auto cursor = client.query_DEPRECATED(
         kNs, BSONObj{}, Query{}, 0 /*limit*/, 0 /*skip*/, nullptr, QueryOption_Exhaust, batchSize);
     ASSERT_EQ(cursor->itcount(), numDocs);
 }
diff --git a/src/mongo/db/exhaust_cursor_currentop_integration_test.cpp b/src/mongo/db/exhaust_cursor_currentop_integration_test.cpp
index 897cdc62e2b..168107cb11d 100644
--- a/src/mongo/db/exhaust_cursor_currentop_integration_test.cpp
+++ b/src/mongo/db/exhaust_cursor_currentop_integration_test.cpp
@@ -153,7 +153,7 @@ auto startExhaustQuery(
                         // Issue the initial 'find' with a batchSize of 2 and the exhaust flag set.
                         // We then iterate through the first batch and confirm that the results are
                         // as expected.
-                        queryCursor = queryConnection->query(
+                        queryCursor = queryConnection->query_DEPRECATED(
                             testNSS, BSONObj{}, Query(), 0, 0, &projSpec, queryOptions, 2);
                         for (int i = 0; i < 2; ++i) {
                             ASSERT_BSONOBJ_EQ(queryCursor->nextSafe(), BSON("a" << i));
diff --git a/src/mongo/db/op_observer_impl_test.cpp b/src/mongo/db/op_observer_impl_test.cpp
index 5e6f0231db5..fabf4919dbb 100644
--- a/src/mongo/db/op_observer_impl_test.cpp
+++ b/src/mongo/db/op_observer_impl_test.cpp
@@ -906,8 +906,9 @@ protected:
                          repl::OpTime opTime,
                          boost::optional<DurableTxnStateEnum> txnState) {
         DBDirectClient client(opCtx());
-        auto cursor = client.query(NamespaceString::kSessionTransactionsTableNamespace,
-                                   BSON("_id" << session()->getSessionId().toBSON()));
+        FindCommandRequest findRequest{NamespaceString::kSessionTransactionsTableNamespace};
+        findRequest.setFilter(BSON("_id" << session()->getSessionId().toBSON()));
+        auto cursor = client.find(std::move(findRequest));
         ASSERT(cursor);
         ASSERT(cursor->more());
 
@@ -932,16 +933,18 @@ protected:
 
     void assertNoTxnRecord() {
         DBDirectClient client(opCtx());
-        auto cursor = client.query(NamespaceString::kSessionTransactionsTableNamespace,
-                                   BSON("_id" << session()->getSessionId().toBSON()));
+        FindCommandRequest findRequest{NamespaceString::kSessionTransactionsTableNamespace};
+        findRequest.setFilter(BSON("_id" << session()->getSessionId().toBSON()));
+        auto cursor = client.find(std::move(findRequest));
         ASSERT(cursor);
         ASSERT(!cursor->more());
     }
 
     void assertTxnRecordStartOpTime(boost::optional<repl::OpTime> startOpTime) {
         DBDirectClient client(opCtx());
-        auto cursor = client.query(NamespaceString::kSessionTransactionsTableNamespace,
-                                   BSON("_id" << session()->getSessionId().toBSON()));
+        FindCommandRequest findRequest{NamespaceString::kSessionTransactionsTableNamespace};
+        findRequest.setFilter(BSON("_id" << session()->getSessionId().toBSON()));
+        auto cursor = client.find(std::move(findRequest));
         ASSERT(cursor);
         ASSERT(cursor->more());
 
diff --git a/src/mongo/db/persistent_task_store.h b/src/mongo/db/persistent_task_store.h
index 34ae3164004..9db4a12186b 100644
--- a/src/mongo/db/persistent_task_store.h
+++ b/src/mongo/db/persistent_task_store.h
@@ -141,7 +141,9 @@ public:
                  std::function<bool(const T&)> handler) {
         DBDirectClient dbClient(opCtx);
 
-        auto cursor = dbClient.query(_storageNss, filter);
+        FindCommandRequest findRequest{_storageNss};
+        findRequest.setFilter(filter);
+        auto cursor = dbClient.find(std::move(findRequest));
 
         while (cursor->more()) {
             auto bson = cursor->next();
@@ -159,8 +161,10 @@ public:
     size_t count(OperationContext* opCtx, const BSONObj& filter = BSONObj{}) {
         DBDirectClient client(opCtx);
 
-        auto projection = BSON("_id" << 1);
-        auto cursor = client.query(_storageNss, filter, Query(), 0, 0, &projection);
+        FindCommandRequest findRequest{_storageNss};
+        findRequest.setFilter(filter);
+        findRequest.setProjection(BSON("_id" << 1));
+        auto cursor = client.find(std::move(findRequest));
 
         return cursor->itcount();
     }
diff --git a/src/mongo/db/repl/apply_ops.cpp b/src/mongo/db/repl/apply_ops.cpp
index 50d012ab6c8..65b533ba218 100644
--- a/src/mongo/db/repl/apply_ops.cpp
+++ b/src/mongo/db/repl/apply_ops.cpp
@@ -291,7 +291,8 @@ Status _checkPrecondition(OperationContext* opCtx,
         // legacy API from 'DBDirectClient' in order to parse this format and convert it into the
         // corresponding find command.
         auto preconditionQuery = Query::fromBSONDeprecated(preCondition["q"].Obj());
-        auto cursor = db.query(nss, preconditionQuery.getFilter(), preconditionQuery, 1 /*limit*/);
+        auto cursor =
+            db.query_DEPRECATED(nss, preconditionQuery.getFilter(), preconditionQuery, 1 /*limit*/);
         BSONObj realres = cursor->more() ? cursor->nextSafe() : BSONObj{};
 
         // Get collection default collation.
diff --git a/src/mongo/db/repl/collection_cloner.cpp b/src/mongo/db/repl/collection_cloner.cpp
index 00c817a5b32..08701e697f6 100644
--- a/src/mongo/db/repl/collection_cloner.cpp
+++ b/src/mongo/db/repl/collection_cloner.cpp
@@ -339,15 +339,16 @@ void CollectionCloner::runQuery() {
     _firstBatchOfQueryRound = true;
 
     try {
-        getClient()->query([this](DBClientCursorBatchIterator& iter) { handleNextBatch(iter); },
-                           _sourceDbAndUuid,
-                           BSONObj{},
-                           query,
-                           nullptr /* fieldsToReturn */,
-                           QueryOption_NoCursorTimeout | QueryOption_SecondaryOk |
-                               (collectionClonerUsesExhaust ? QueryOption_Exhaust : 0),
-                           _collectionClonerBatchSize,
-                           ReadConcernArgs::kImplicitDefault);
+        getClient()->query_DEPRECATED(
+            [this](DBClientCursorBatchIterator& iter) { handleNextBatch(iter); },
+            _sourceDbAndUuid,
+            BSONObj{},
+            query,
+            nullptr /* fieldsToReturn */,
+            QueryOption_NoCursorTimeout | QueryOption_SecondaryOk |
+                (collectionClonerUsesExhaust ? QueryOption_Exhaust : 0),
+            _collectionClonerBatchSize,
+            ReadConcernArgs::kImplicitDefault);
     } catch (...) {
         auto status = exceptionToStatus();
 
diff --git a/src/mongo/db/repl/oplog_interface_remote.cpp b/src/mongo/db/repl/oplog_interface_remote.cpp
index 1a9e3e6a180..45e9e3df190 100644
--- a/src/mongo/db/repl/oplog_interface_remote.cpp
+++ b/src/mongo/db/repl/oplog_interface_remote.cpp
@@ -81,18 +81,13 @@ std::string OplogInterfaceRemote::toString() const {
 }
 
 std::unique_ptr<OplogInterface::Iterator> OplogInterfaceRemote::makeIterator() const {
-    const Query query = Query().sort(BSON("$natural" << -1));
-    const BSONObj fields = BSON("ts" << 1 << "t" << 1LL);
+    FindCommandRequest findRequest{NamespaceString{_collectionName}};
+    findRequest.setProjection(BSON("ts" << 1 << "t" << 1LL));
+    findRequest.setSort(BSON("$natural" << -1));
+    findRequest.setBatchSize(_batchSize);
+    findRequest.setReadConcern(ReadConcernArgs::kImplicitDefault);
     return std::unique_ptr<OplogInterface::Iterator>(
-        new OplogIteratorRemote(_getConnection()->query(NamespaceString(_collectionName),
-                                                        BSONObj{},
-                                                        query,
-                                                        0,
-                                                        0,
-                                                        &fields,
-                                                        0,
-                                                        _batchSize,
-                                                        ReadConcernArgs::kImplicitDefault)));
+        new OplogIteratorRemote(_getConnection()->find(std::move(findRequest))));
 }
 
 std::unique_ptr<TransactionHistoryIteratorBase>
diff --git a/src/mongo/db/repl/primary_only_service.cpp b/src/mongo/db/repl/primary_only_service.cpp
index 55b6490470f..485f08028d1 100644
--- a/src/mongo/db/repl/primary_only_service.cpp
+++ b/src/mongo/db/repl/primary_only_service.cpp
@@ -667,7 +667,8 @@ void PrimaryOnlyService::_rebuildInstances(long long term) noexcept {
                     Status(ErrorCodes::InternalError, "Querying state documents failed"));
             }
 
-            auto cursor = client.query(ns, BSONObj{});
+            FindCommandRequest findRequest{ns};
+            auto cursor = client.find(std::move(findRequest));
             while (cursor->more()) {
                 stateDocuments.push_back(cursor->nextSafe().getOwned());
             }
diff --git a/src/mongo/db/repl/replication_recovery.cpp b/src/mongo/db/repl/replication_recovery.cpp
index 84323838172..afecf8da4f5 100644
--- a/src/mongo/db/repl/replication_recovery.cpp
+++ b/src/mongo/db/repl/replication_recovery.cpp
@@ -144,14 +144,9 @@ public:
         BSONObj predicate = _oplogApplicationEndPoint
             ? BSON("$gte" << _oplogApplicationStartPoint << "$lte" << *_oplogApplicationEndPoint)
             : BSON("$gte" << _oplogApplicationStartPoint);
-        _cursor = _client->query(NamespaceString::kRsOplogNamespace,
-                                 BSON("ts" << predicate),
-                                 /*querySettings*/ Query(),
-                                 /*limit*/ 0,
-                                 /*skip*/ 0,
-                                 /*projection*/ nullptr,
-                                 /*options*/ 0,
-                                 /*batchSize*/ 0);
+        FindCommandRequest findRequest{NamespaceString::kRsOplogNamespace};
+        findRequest.setFilter(BSON("ts" << predicate));
+        _cursor = _client->find(std::move(findRequest));
 
         // Check that the first document matches our appliedThrough point then skip it since it's
         // already been applied.
diff --git a/src/mongo/db/repl/roll_back_local_operations_test.cpp b/src/mongo/db/repl/roll_back_local_operations_test.cpp
index 6a4b3ea84c9..16e0ccdd678 100644
--- a/src/mongo/db/repl/roll_back_local_operations_test.cpp
+++ b/src/mongo/db/repl/roll_back_local_operations_test.cpp
@@ -318,28 +318,18 @@ class DBClientConnectionForTest : public DBClientConnection {
 public:
     DBClientConnectionForTest(int numInitFailures) : _initFailuresLeft(numInitFailures) {}
 
-    using DBClientConnection::query;
-
-    std::unique_ptr<DBClientCursor> query(const NamespaceStringOrUUID& nsOrUuid,
-                                          const BSONObj& filter,
-                                          const Query& querySettings,
-                                          int limit,
-                                          int nToSkip,
-                                          const BSONObj* fieldsToReturn,
-                                          int queryOptions,
-                                          int batchSize,
-                                          boost::optional<BSONObj> readConcernObj) override {
+    std::unique_ptr<DBClientCursor> find(FindCommandRequest findRequest,
+                                         const ReadPreferenceSetting& readPref) override {
         if (_initFailuresLeft > 0) {
             _initFailuresLeft--;
             LOGV2(21657,
-                  "Throwing DBException on DBClientCursorForTest::query(). Failures left: "
-                  "{initFailuresLeft}",
+                  "Throwing DBException on DBClientCursorForTest::find()",
                   "initFailuresLeft"_attr = _initFailuresLeft);
             uasserted(50852, "Simulated network error");
             MONGO_UNREACHABLE;
         }
 
-        LOGV2(21658, "Returning success on DBClientCursorForTest::query()");
+        LOGV2(21658, "Returning success on DBClientCursorForTest::find()");
 
         BSONArrayBuilder builder;
         builder.append(makeOp(1));
diff --git a/src/mongo/db/repl/rollback_impl.cpp b/src/mongo/db/repl/rollback_impl.cpp
index a03e6793ea0..70d2bb88940 100644
--- a/src/mongo/db/repl/rollback_impl.cpp
+++ b/src/mongo/db/repl/rollback_impl.cpp
@@ -475,12 +475,13 @@ void RollbackImpl::_restoreTxnsTableEntryFromRetryableWrites(OperationContext* o
     const auto filterFromMigration = BSON("op"
                                           << "n"
                                           << "fromMigrate" << true);
-    auto cursor = client->query(
-        NamespaceString::kRsOplogNamespace,
-        BSON("ts" << BSON("$gt" << stableTimestamp) << "txnNumber" << BSON("$exists" << true)
-                  << "stmtId" << BSON("$exists" << true) << "prevOpTime.ts"
-                  << BSON("$gte" << Timestamp(1, 0) << "$lte" << stableTimestamp) << "$or"
-                  << BSON_ARRAY(filter << filterFromMigration)));
+    FindCommandRequest findRequest{NamespaceString::kRsOplogNamespace};
+    findRequest.setFilter(BSON("ts" << BSON("$gt" << stableTimestamp) << "txnNumber"
+                                    << BSON("$exists" << true) << "stmtId"
+                                    << BSON("$exists" << true) << "prevOpTime.ts"
+                                    << BSON("$gte" << Timestamp(1, 0) << "$lte" << stableTimestamp)
+                                    << "$or" << BSON_ARRAY(filter << filterFromMigration)));
+    auto cursor = client->find(std::move(findRequest));
     while (cursor->more()) {
         auto doc = cursor->next();
         auto swEntry = OplogEntry::parse(doc);
diff --git a/src/mongo/db/repl/rollback_source_impl.cpp b/src/mongo/db/repl/rollback_source_impl.cpp
index f174d3c718c..4b7c7e2fff1 100644
--- a/src/mongo/db/repl/rollback_source_impl.cpp
+++ b/src/mongo/db/repl/rollback_source_impl.cpp
@@ -85,7 +85,19 @@ BSONObj RollbackSourceImpl::findOne(const NamespaceString& nss, const BSONObj& f
 std::pair<BSONObj, NamespaceString> RollbackSourceImpl::findOneByUUID(const std::string& db,
                                                                       UUID uuid,
                                                                       const BSONObj& filter) const {
-    return _getConnection()->findOneByUUID(db, uuid, filter, ReadConcernArgs::kImplicitDefault);
+    FindCommandRequest findRequest{NamespaceStringOrUUID{db, uuid}};
+    findRequest.setFilter(filter);
+    findRequest.setReadConcern(ReadConcernArgs::kImplicitDefault);
+    findRequest.setLimit(1);
+    findRequest.setSingleBatch(true);
+
+    auto cursor =
+        std::make_unique<DBClientCursor>(_getConnection(),
+                                         std::move(findRequest),
+                                         ReadPreferenceSetting{ReadPreference::SecondaryPreferred});
+    BSONObj result = cursor->more() ? cursor->nextSafe() : BSONObj{};
+    NamespaceString nss = cursor->getNamespaceString();
+    return {std::move(result), std::move(nss)};
 }
 
 StatusWith<BSONObj> RollbackSourceImpl::getCollectionInfoByUUID(const std::string& db,
diff --git a/src/mongo/db/repl/tenant_collection_cloner.cpp b/src/mongo/db/repl/tenant_collection_cloner.cpp
index c468a466db5..4e391644b5a 100644
--- a/src/mongo/db/repl/tenant_collection_cloner.cpp
+++ b/src/mongo/db/repl/tenant_collection_cloner.cpp
@@ -210,17 +210,13 @@ BaseCloner::AfterStageBehavior TenantCollectionCloner::countStage() {
 // Note we cannot simply use the count() above, because that checks metadata which may not be 100%
 // accurate.
 BaseCloner::AfterStageBehavior TenantCollectionCloner::checkIfDonorCollectionIsEmptyStage() {
-    auto fieldsToReturn = BSON("_id" << 1);
-    auto cursor =
-        getClient()->query(_sourceDbAndUuid,
-                           BSONObj{} /* filter */,
-                           Query() /* querySettings */,
-                           1 /* limit */,
-                           0 /* skip */,
-                           &fieldsToReturn,
-                           QueryOption_SecondaryOk,
-                           0 /* batchSize */,
-                           ReadConcernArgs(ReadConcernLevel::kMajorityReadConcern).toBSONInner());
+    FindCommandRequest findRequest{_sourceDbAndUuid};
+    findRequest.setProjection(BSON("_id" << 1));
+    findRequest.setLimit(1);
+    findRequest.setReadConcern(
+        ReadConcernArgs(ReadConcernLevel::kMajorityReadConcern).toBSONInner());
+    auto cursor = getClient()->find(std::move(findRequest),
+                                    ReadPreferenceSetting{ReadPreference::SecondaryPreferred});
     _donorCollectionWasEmptyBeforeListIndexes = !cursor->more();
     LOGV2_DEBUG(5368500,
                 1,
@@ -480,15 +476,16 @@ void TenantCollectionCloner::runQuery() {
 
     // Any errors that are thrown here (including NamespaceNotFound) will be handled on the stage
     // level.
-    getClient()->query([this](DBClientCursorBatchIterator& iter) { handleNextBatch(iter); },
-                       _sourceDbAndUuid,
-                       filter,
-                       query,
-                       nullptr /* fieldsToReturn */,
-                       QueryOption_NoCursorTimeout | QueryOption_SecondaryOk |
-                           (collectionClonerUsesExhaust ? QueryOption_Exhaust : 0),
-                       _collectionClonerBatchSize,
-                       ReadConcernArgs(ReadConcernLevel::kMajorityReadConcern).toBSONInner());
+    getClient()->query_DEPRECATED(
+        [this](DBClientCursorBatchIterator& iter) { handleNextBatch(iter); },
+        _sourceDbAndUuid,
+        filter,
+        query,
+        nullptr /* fieldsToReturn */,
+        QueryOption_NoCursorTimeout | QueryOption_SecondaryOk |
+            (collectionClonerUsesExhaust ? QueryOption_Exhaust : 0),
+        _collectionClonerBatchSize,
+        ReadConcernArgs(ReadConcernLevel::kMajorityReadConcern).toBSONInner());
 }
 
 void TenantCollectionCloner::handleNextBatch(DBClientCursorBatchIterator& iter) {
diff --git a/src/mongo/db/repl/tenant_migration_recipient_service.cpp b/src/mongo/db/repl/tenant_migration_recipient_service.cpp
index 700f33d6972..6911f5509ba 100644
--- a/src/mongo/db/repl/tenant_migration_recipient_service.cpp
+++ b/src/mongo/db/repl/tenant_migration_recipient_service.cpp
@@ -2229,10 +2229,8 @@ SemiFuture<void> TenantMigrationRecipientService::Instance::_updateStateDocForMa
 void TenantMigrationRecipientService::Instance::_fetchAndStoreDonorClusterTimeKeyDocs(
     const CancellationToken& token) {
     std::vector<ExternalKeysCollectionDocument> keyDocs;
-    auto cursor =
-        _client->query(NamespaceString::kKeysCollectionNamespace,
-                       BSONObj{},
-                       Query().readPref(_readPreference.pref, _readPreference.tags.getTagBSON()));
+    FindCommandRequest findRequest{NamespaceString::kKeysCollectionNamespace};
+    auto cursor = _client->find(std::move(findRequest), _readPreference);
     while (cursor->more()) {
         const auto doc = cursor->nextSafe().getOwned();
         keyDocs.push_back(
diff --git a/src/mongo/db/repl/transaction_oplog_application.cpp b/src/mongo/db/repl/transaction_oplog_application.cpp
index a838e8566f6..a44f8380f1c 100644
--- a/src/mongo/db/repl/transaction_oplog_application.cpp
+++ b/src/mongo/db/repl/transaction_oplog_application.cpp
@@ -574,9 +574,10 @@ void reconstructPreparedTransactions(OperationContext* opCtx, repl::OplogApplica
               opCtx->recoveryUnit()->getTimestampReadSource());
 
     DBDirectClient client(opCtx);
-    const auto cursor = client.query(NamespaceString::kSessionTransactionsTableNamespace,
-                                     BSON("state"
-                                          << "prepared"));
+    FindCommandRequest findRequest{NamespaceString::kSessionTransactionsTableNamespace};
+    findRequest.setFilter(BSON("state"
+                               << "prepared"));
+    const auto cursor = client.find(std::move(findRequest));
 
     // Iterate over each entry in the transactions table that has a prepared transaction.
     while (cursor->more()) {
diff --git a/src/mongo/db/rs_local_client.cpp b/src/mongo/db/rs_local_client.cpp
index 6fdc49907f3..65cf9a284fa 100644
--- a/src/mongo/db/rs_local_client.cpp
+++ b/src/mongo/db/rs_local_client.cpp
@@ -139,18 +139,20 @@ StatusWith<Shard::QueryResponse> RSLocalClient::queryOnce(
     }
 
     DBDirectClient client(opCtx);
-    Query querySettings;
+    FindCommandRequest findRequest{nss};
+    findRequest.setFilter(query);
     if (!sort.isEmpty()) {
-        querySettings.sort(sort);
+        findRequest.setSort(sort);
     }
     if (hint) {
-        querySettings.hint(*hint);
+        findRequest.setHint(*hint);
+    }
+    if (limit) {
+        findRequest.setLimit(*limit);
     }
-    querySettings.readPref(readPref.pref, BSONArray());
 
     try {
-        std::unique_ptr<DBClientCursor> cursor =
-            client.query(nss, query, querySettings, limit.get_value_or(0));
+        std::unique_ptr<DBClientCursor> cursor = client.find(std::move(findRequest), readPref);
 
         if (!cursor) {
             return {ErrorCodes::OperationFailed,
diff --git a/src/mongo/db/s/balancer/balancer_commands_scheduler_impl.cpp b/src/mongo/db/s/balancer/balancer_commands_scheduler_impl.cpp
index 3d98bcb8499..41e4269e295 100644
--- a/src/mongo/db/s/balancer/balancer_commands_scheduler_impl.cpp
+++ b/src/mongo/db/s/balancer/balancer_commands_scheduler_impl.cpp
@@ -121,7 +121,8 @@ std::vector<RequestData> rebuildRequestsFromRecoveryInfo(
     };
     DBDirectClient dbClient(opCtx);
     try {
-        dbClient.query(documentProcessor, MigrationType::ConfigNS, BSONObj());
+        FindCommandRequest findRequest{MigrationType::ConfigNS};
+        dbClient.find(std::move(findRequest), ReadPreferenceSetting{}, documentProcessor);
     } catch (const DBException& e) {
         LOGV2_ERROR(5847215, "Failed to load requests to recover", "error"_attr = redact(e));
     }
diff --git a/src/mongo/db/s/balancer/balancer_defragmentation_policy_test.cpp b/src/mongo/db/s/balancer/balancer_defragmentation_policy_test.cpp
index 2446042021c..206f40f870a 100644
--- a/src/mongo/db/s/balancer/balancer_defragmentation_policy_test.cpp
+++ b/src/mongo/db/s/balancer/balancer_defragmentation_policy_test.cpp
@@ -100,9 +100,9 @@ protected:
 
     BSONObj getConfigCollectionEntry() {
         DBDirectClient client(operationContext());
-        auto cursor = client.query(NamespaceStringOrUUID(CollectionType::ConfigNS),
-                                   BSON(CollectionType::kUuidFieldName << kUuid),
-                                   {});
+        FindCommandRequest findRequest{NamespaceStringOrUUID{CollectionType::ConfigNS}};
+        findRequest.setFilter(BSON(CollectionType::kUuidFieldName << kUuid));
+        auto cursor = client.find(std::move(findRequest));
         if (!cursor || !cursor->more())
             return BSONObj();
         else
diff --git a/src/mongo/db/s/persistent_task_queue.h b/src/mongo/db/s/persistent_task_queue.h
index 25736e6d6ba..0c7e873786d 100644
--- a/src/mongo/db/s/persistent_task_queue.h
+++ b/src/mongo/db/s/persistent_task_queue.h
@@ -109,8 +109,9 @@ PersistentTaskQueue<T>::PersistentTaskQueue(OperationContext* opCtx, NamespaceSt
 
     DBDirectClient client(opCtx);
 
-    auto projection = BSON("_id" << 1);
-    auto cursor = client.query(_storageNss, BSONObj{}, Query(), 0, 0, &projection);
+    FindCommandRequest findRequest{_storageNss};
+    findRequest.setProjection(BSON("_id" << 1));
+    auto cursor = client.find(std::move(findRequest));
     _count = cursor->itcount();
 
     if (_count > 0)
diff --git a/src/mongo/db/s/recoverable_critical_section_service.cpp b/src/mongo/db/s/recoverable_critical_section_service.cpp
index 9864779bf31..dbfcd529035 100644
--- a/src/mongo/db/s/recoverable_critical_section_service.cpp
+++ b/src/mongo/db/s/recoverable_critical_section_service.cpp
@@ -85,9 +85,10 @@ void RecoverableCriticalSectionService::acquireRecoverableCriticalSectionBlockWr
         AutoGetCollection cCollLock(opCtx, nss, MODE_S);
 
         DBDirectClient dbClient(opCtx);
-        auto cursor = dbClient.query(
-            NamespaceString::kCollectionCriticalSectionsNamespace,
+        FindCommandRequest findRequest{NamespaceString::kCollectionCriticalSectionsNamespace};
+        findRequest.setFilter(
             BSON(CollectionCriticalSectionDocument::kNssFieldName << nss.toString()));
+        auto cursor = dbClient.find(std::move(findRequest));
 
         // if there is a doc with the same nss -> in order to not fail it must have the same reason
         if (cursor->more()) {
@@ -170,9 +171,10 @@ void RecoverableCriticalSectionService::promoteRecoverableCriticalSectionToBlock
         AutoGetCollection cCollLock(opCtx, nss, MODE_X);
 
         DBDirectClient dbClient(opCtx);
-        auto cursor = dbClient.query(
-            NamespaceString::kCollectionCriticalSectionsNamespace,
+        FindCommandRequest findRequest{NamespaceString::kCollectionCriticalSectionsNamespace};
+        findRequest.setFilter(
             BSON(CollectionCriticalSectionDocument::kNssFieldName << nss.toString()));
+        auto cursor = dbClient.find(std::move(findRequest));
 
         invariant(
             cursor->more(),
@@ -272,8 +274,9 @@ void RecoverableCriticalSectionService::releaseRecoverableCriticalSection(
 
         const auto queryNss =
             BSON(CollectionCriticalSectionDocument::kNssFieldName << nss.toString());
-        auto cursor =
-            dbClient.query(NamespaceString::kCollectionCriticalSectionsNamespace, queryNss);
+        FindCommandRequest findRequest{NamespaceString::kCollectionCriticalSectionsNamespace};
+        findRequest.setFilter(queryNss);
+        auto cursor = dbClient.find(std::move(findRequest));
 
         // if there is no document with the same nss -> do nothing!
         if (!cursor->more()) {
diff --git a/src/mongo/db/s/resharding/resharding_coordinator_service_test.cpp b/src/mongo/db/s/resharding/resharding_coordinator_service_test.cpp
index 06231a28ae2..5d1ff6ef471 100644
--- a/src/mongo/db/s/resharding/resharding_coordinator_service_test.cpp
+++ b/src/mongo/db/s/resharding/resharding_coordinator_service_test.cpp
@@ -862,9 +862,10 @@ TEST_F(ReshardingCoordinatorServiceTest, StepDownStepUpEachTransition) {
         DBDirectClient client(opCtx);
 
         // config.chunks should have been moved to the new UUID
+        FindCommandRequest findRequest{ChunkType::ConfigNS};
+        findRequest.setFilter(BSON(ChunkType::collectionUUID() << doc.getReshardingUUID()));
+        auto chunkCursor = client.find(std::move(findRequest));
         std::vector<ChunkType> foundChunks;
-        auto chunkCursor = client.query(
-            ChunkType::ConfigNS, BSON(ChunkType::collectionUUID() << doc.getReshardingUUID()));
         while (chunkCursor->more()) {
             auto d = uassertStatusOK(ChunkType::fromConfigBSON(
                 chunkCursor->nextSafe().getOwned(), _originalEpoch, _originalTimestamp));
diff --git a/src/mongo/db/s/resharding/resharding_coordinator_test.cpp b/src/mongo/db/s/resharding/resharding_coordinator_test.cpp
index 9116e731841..a1ef35222f3 100644
--- a/src/mongo/db/s/resharding/resharding_coordinator_test.cpp
+++ b/src/mongo/db/s/resharding/resharding_coordinator_test.cpp
@@ -422,8 +422,11 @@ protected:
                                                        const OID& collEpoch,
                                                        const Timestamp& collTimestamp) {
         DBDirectClient client(opCtx);
+        FindCommandRequest findRequest{ChunkType::ConfigNS};
+        findRequest.setFilter(BSON("uuid" << uuid));
+        auto cursor = client.find(std::move(findRequest));
+
         std::vector<ChunkType> foundChunks;
-        auto cursor = client.query(ChunkType::ConfigNS, BSON("uuid" << uuid));
         while (cursor->more()) {
             auto d = uassertStatusOK(
                 ChunkType::fromConfigBSON(cursor->nextSafe().getOwned(), collEpoch, collTimestamp));
@@ -448,8 +451,11 @@ protected:
         auto nss = expectedZones[0].getNS();
 
         DBDirectClient client(opCtx);
+        FindCommandRequest findRequest{TagsType::ConfigNS};
+        findRequest.setFilter(BSON("ns" << nss.ns()));
+        auto cursor = client.find(std::move(findRequest));
+
         std::vector<TagsType> foundZones;
-        auto cursor = client.query(TagsType::ConfigNS, BSON("ns" << nss.ns()));
         while (cursor->more()) {
             foundZones.push_back(
                 uassertStatusOK(TagsType::fromBSON(cursor->nextSafe().getOwned())));
diff --git a/src/mongo/db/s/resharding/resharding_donor_service_test.cpp b/src/mongo/db/s/resharding/resharding_donor_service_test.cpp
index 47e35c202e7..2359d85009a 100644
--- a/src/mongo/db/s/resharding/resharding_donor_service_test.cpp
+++ b/src/mongo/db/s/resharding/resharding_donor_service_test.cpp
@@ -269,8 +269,9 @@ TEST_F(ReshardingDonorServiceTest, WritesNoOpOplogEntryOnReshardingBegin) {
 
     DBDirectClient client(opCtx.get());
     NamespaceString sourceNss("sourcedb", "sourcecollection");
-    auto cursor = client.query(NamespaceString(NamespaceString::kRsOplogNamespace.ns()),
-                               BSON("ns" << sourceNss.toString()));
+    FindCommandRequest findRequest{NamespaceString::kRsOplogNamespace};
+    findRequest.setFilter(BSON("ns" << sourceNss.toString()));
+    auto cursor = client.find(std::move(findRequest));
 
     ASSERT_TRUE(cursor->more()) << "Found no oplog entries for source collection";
     repl::OplogEntry op(cursor->next());
@@ -308,9 +309,9 @@ TEST_F(ReshardingDonorServiceTest, WritesNoOpOplogEntryToGenerateMinFetchTimesta
               ErrorCodes::InterruptedDueToReplStateChange);
 
     DBDirectClient client(opCtx.get());
-    auto cursor =
-        client.query(NamespaceString(NamespaceString::kRsOplogNamespace.ns()),
-                     BSON("ns" << NamespaceString::kForceOplogBatchBoundaryNamespace.ns()));
+    FindCommandRequest findRequest{NamespaceString::kRsOplogNamespace};
+    findRequest.setFilter(BSON("ns" << NamespaceString::kForceOplogBatchBoundaryNamespace.ns()));
+    auto cursor = client.find(std::move(findRequest));
 
     ASSERT_TRUE(cursor->more()) << "Found no oplog entries for source collection";
     repl::OplogEntry op(cursor->next());
@@ -345,8 +346,9 @@ TEST_F(ReshardingDonorServiceTest, WritesFinalReshardOpOplogEntriesWhileWritesBl
               ErrorCodes::InterruptedDueToReplStateChange);
 
     DBDirectClient client(opCtx.get());
-    auto cursor = client.query(NamespaceString(NamespaceString::kRsOplogNamespace.ns()),
-                               BSON("o2.type" << kReshardFinalOpLogType));
+    FindCommandRequest findRequest{NamespaceString::kRsOplogNamespace};
+    findRequest.setFilter(BSON("o2.type" << kReshardFinalOpLogType));
+    auto cursor = client.find(std::move(findRequest));
 
     ASSERT_TRUE(cursor->more()) << "Found no oplog entries for source collection";
 
diff --git a/src/mongo/db/s/resharding/resharding_recipient_service_test.cpp b/src/mongo/db/s/resharding/resharding_recipient_service_test.cpp
index 22a9840a450..43ccab32bec 100644
--- a/src/mongo/db/s/resharding/resharding_recipient_service_test.cpp
+++ b/src/mongo/db/s/resharding/resharding_recipient_service_test.cpp
@@ -621,8 +621,9 @@ TEST_F(ReshardingRecipientServiceTest, WritesNoopOplogEntryOnReshardDoneCatchUp)
     DBDirectClient client(opCtx.get());
     NamespaceString sourceNss = constructTemporaryReshardingNss("sourcedb", doc.getSourceUUID());
 
-    auto cursor = client.query(NamespaceString(NamespaceString::kRsOplogNamespace.ns()),
-                               BSON("ns" << sourceNss.toString()));
+    FindCommandRequest findRequest{NamespaceString::kRsOplogNamespace};
+    findRequest.setFilter(BSON("ns" << sourceNss.toString()));
+    auto cursor = client.find(std::move(findRequest));
 
     ASSERT_TRUE(cursor->more()) << "Found no oplog entries for source collection";
     repl::OplogEntry op(cursor->next());
diff --git a/src/mongo/db/s/session_catalog_migration_source.cpp b/src/mongo/db/s/session_catalog_migration_source.cpp
index 31f006da764..746fa785d77 100644
--- a/src/mongo/db/s/session_catalog_migration_source.cpp
+++ b/src/mongo/db/s/session_catalog_migration_source.cpp
@@ -193,9 +193,9 @@ SessionCatalogMigrationSource::SessionCatalogMigrationSource(OperationContext* o
     // Sort is not needed for correctness. This is just for making it easier to write deterministic
     // tests.
     DBDirectClient client(opCtx);
-    auto cursor = client.query(NamespaceString::kSessionTransactionsTableNamespace,
-                               BSONObj{},
-                               Query().sort(BSON("_id" << 1)));
+    FindCommandRequest findRequest{NamespaceString::kSessionTransactionsTableNamespace};
+    findRequest.setSort(BSON("_id" << 1));
+    auto cursor = client.find(std::move(findRequest));
 
     while (cursor->more()) {
         auto nextSession = SessionTxnRecord::parse(
diff --git a/src/mongo/db/s/shard_metadata_util.cpp b/src/mongo/db/s/shard_metadata_util.cpp
index fe9e22f715b..fa829fe2270 100644
--- a/src/mongo/db/s/shard_metadata_util.cpp
+++ b/src/mongo/db/s/shard_metadata_util.cpp
@@ -162,11 +162,10 @@ StatusWith<ShardCollectionType> readShardCollectionsEntry(OperationContext* opCt
 
     try {
         DBDirectClient client(opCtx);
-        std::unique_ptr<DBClientCursor> cursor =
-            client.query(NamespaceString::kShardConfigCollectionsNamespace,
-                         BSON(ShardCollectionType::kNssFieldName << nss.ns()),
-                         Query(),
-                         1);
+        FindCommandRequest findRequest{NamespaceString::kShardConfigCollectionsNamespace};
+        findRequest.setFilter(BSON(ShardCollectionType::kNssFieldName << nss.ns()));
+        findRequest.setLimit(1);
+        std::unique_ptr<DBClientCursor> cursor = client.find(std::move(findRequest));
         if (!cursor) {
             return Status(ErrorCodes::OperationFailed,
                           str::stream() << "Failed to establish a cursor for reading "
@@ -191,11 +190,10 @@ StatusWith<ShardCollectionType> readShardCollectionsEntry(OperationContext* opCt
 StatusWith<ShardDatabaseType> readShardDatabasesEntry(OperationContext* opCtx, StringData dbName) {
     try {
         DBDirectClient client(opCtx);
-        std::unique_ptr<DBClientCursor> cursor =
-            client.query(NamespaceString::kShardConfigDatabasesNamespace,
-                         BSON(ShardDatabaseType::name() << dbName.toString()),
-                         Query(),
-                         1);
+        FindCommandRequest findRequest{NamespaceString::kShardConfigDatabasesNamespace};
+        findRequest.setFilter(BSON(ShardDatabaseType::name() << dbName.toString()));
+        findRequest.setLimit(1);
+        std::unique_ptr<DBClientCursor> cursor = client.find(std::move(findRequest));
         if (!cursor) {
             return Status(ErrorCodes::OperationFailed,
                           str::stream() << "Failed to establish a cursor for reading "
@@ -313,8 +311,13 @@ StatusWith<std::vector<ChunkType>> readShardChunks(OperationContext* opCtx,
     try {
         DBDirectClient client(opCtx);
 
-        std::unique_ptr<DBClientCursor> cursor =
-            client.query(chunksNss, query, Query().sort(sort), limit.get_value_or(0));
+        FindCommandRequest findRequest{chunksNss};
+        findRequest.setFilter(query);
+        findRequest.setSort(sort);
+        if (limit) {
+            findRequest.setLimit(*limit);
+        }
+        std::unique_ptr<DBClientCursor> cursor = client.find(std::move(findRequest));
         uassert(ErrorCodes::OperationFailed,
                 str::stream() << "Failed to establish a cursor for reading " << chunksNss.ns()
                               << " from local storage",
diff --git a/src/mongo/db/s/shard_metadata_util_test.cpp b/src/mongo/db/s/shard_metadata_util_test.cpp
index bfd1b812f27..7effa87f13c 100644
--- a/src/mongo/db/s/shard_metadata_util_test.cpp
+++ b/src/mongo/db/s/shard_metadata_util_test.cpp
@@ -141,12 +141,13 @@ struct ShardMetadataUtilTest : public ShardServerTestFixture {
             DBDirectClient client(operationContext());
             for (auto& chunk : chunks) {
                 NamespaceString chunkMetadataNss{ChunkType::ShardNSPrefix + uuid.toString()};
-                std::unique_ptr<DBClientCursor> cursor =
-                    client.query(chunkMetadataNss,
-                                 BSON(ChunkType::minShardID()
-                                      << chunk.getMin() << ChunkType::max() << chunk.getMax()),
-                                 Query().readPref(ReadPreference::Nearest, BSONArray()),
-                                 1);
+                FindCommandRequest findRequest{chunkMetadataNss};
+                findRequest.setFilter(BSON(ChunkType::minShardID()
+                                           << chunk.getMin() << ChunkType::max()
+                                           << chunk.getMax()));
+                findRequest.setLimit(1);
+                std::unique_ptr<DBClientCursor> cursor = client.find(
+                    std::move(findRequest), ReadPreferenceSetting{ReadPreference::Nearest});
                 ASSERT(cursor);
 
                 ASSERT(cursor->more());
diff --git a/src/mongo/db/s/sharding_ddl_util_test.cpp b/src/mongo/db/s/sharding_ddl_util_test.cpp
index 052f683fbec..eacd1372f5f 100644
--- a/src/mongo/db/s/sharding_ddl_util_test.cpp
+++ b/src/mongo/db/s/sharding_ddl_util_test.cpp
@@ -82,21 +82,12 @@ const NamespaceString kToNss("test.to");
 
 // Query 'limit' objects from the database into an array.
 void findN(DBClientBase& client,
-           const std::string& ns,
-           const BSONObj& filter,
-           const Query& querySettings,
+           FindCommandRequest findRequest,
            int limit,
            std::vector<BSONObj>& out) {
     out.reserve(limit);
-    std::unique_ptr<DBClientCursor> c = client.query(NamespaceString(ns),
-                                                     filter,
-                                                     querySettings,
-                                                     limit,
-                                                     0 /*nToSkip*/,
-                                                     nullptr /*fieldsToReturn*/,
-                                                     0 /*queryOptions*/,
-                                                     0 /* batchSize */,
-                                                     boost::none);
+    findRequest.setLimit(limit);
+    std::unique_ptr<DBClientCursor> c = client.find(std::move(findRequest));
     ASSERT(c.get());
 
     while (c->more()) {
@@ -158,13 +149,13 @@ TEST_F(ShardingDDLUtilTest, ShardedRenameMetadata) {
     // Get FROM collection document and chunks
     auto fromDoc = client.findOne(CollectionType::ConfigNS, fromCollQuery);
     CollectionType fromCollection(fromDoc);
+
+    FindCommandRequest fromChunksRequest{ChunkType::ConfigNS};
+    fromChunksRequest.setFilter(BSON(ChunkType::collectionUUID << collUUID));
+    fromChunksRequest.setSort(BSON("_id" << 1));
+
     std::vector<BSONObj> fromChunks;
-    findN(client,
-          ChunkType::ConfigNS.ns(),
-          BSON(ChunkType::collectionUUID << collUUID) /*filter*/,
-          Query().sort(BSON("_id" << 1)),
-          nChunks,
-          fromChunks);
+    findN(client, std::move(fromChunksRequest), nChunks, fromChunks);
 
     auto fromCollType = Grid::get(opCtx)->catalogClient()->getCollection(opCtx, fromNss);
     // Perform the metadata rename
@@ -177,13 +168,13 @@ TEST_F(ShardingDDLUtilTest, ShardedRenameMetadata) {
     // Get TO collection document and chunks
     auto toDoc = client.findOne(CollectionType::ConfigNS, toCollQuery);
     CollectionType toCollection(toDoc);
+
+    FindCommandRequest toChunksRequest{ChunkType::ConfigNS};
+    toChunksRequest.setFilter(BSON(ChunkType::collectionUUID << collUUID));
+    toChunksRequest.setSort(BSON("_id" << 1));
+
     std::vector<BSONObj> toChunks;
-    findN(client,
-          ChunkType::ConfigNS.ns(),
-          BSON(ChunkType::collectionUUID << collUUID) /*filter*/,
-          Query().sort(BSON("_id" << 1)),
-          nChunks,
-          toChunks);
+    findN(client, std::move(toChunksRequest), nChunks, toChunks);
 
     // Check that original epoch/timestamp are changed in config.collections entry
     ASSERT(fromCollection.getEpoch() != toCollection.getEpoch());
diff --git a/src/mongo/db/s/transaction_coordinator_util.cpp b/src/mongo/db/s/transaction_coordinator_util.cpp
index cce0095f044..7132b090f24 100644
--- a/src/mongo/db/s/transaction_coordinator_util.cpp
+++ b/src/mongo/db/s/transaction_coordinator_util.cpp
@@ -650,8 +650,8 @@ std::vector<TransactionCoordinatorDocument> readAllCoordinatorDocs(OperationCont
     std::vector<TransactionCoordinatorDocument> allCoordinatorDocs;
 
     DBDirectClient client(opCtx);
-    auto coordinatorDocsCursor =
-        client.query(NamespaceString::kTransactionCoordinatorsNamespace, BSONObj{});
+    FindCommandRequest findRequest{NamespaceString::kTransactionCoordinatorsNamespace};
+    auto coordinatorDocsCursor = client.find(std::move(findRequest));
 
     while (coordinatorDocsCursor->more()) {
         // TODO (SERVER-38307): Try/catch around parsing the document and skip the document if it
diff --git a/src/mongo/db/session_catalog_mongod.cpp b/src/mongo/db/session_catalog_mongod.cpp
index 1d9f6bdb586..937596991b3 100644
--- a/src/mongo/db/session_catalog_mongod.cpp
+++ b/src/mongo/db/session_catalog_mongod.cpp
@@ -260,9 +260,11 @@ void createRetryableFindAndModifyTable(OperationContext* opCtx) {
 
 void abortInProgressTransactions(OperationContext* opCtx) {
     DBDirectClient client(opCtx);
-    auto cursor = client.query(NamespaceString::kSessionTransactionsTableNamespace,
-                               BSON(SessionTxnRecord::kStateFieldName << DurableTxnState_serializer(
-                                        DurableTxnStateEnum::kInProgress)));
+    FindCommandRequest findRequest{NamespaceString::kSessionTransactionsTableNamespace};
+    findRequest.setFilter(BSON(SessionTxnRecord::kStateFieldName
+                               << DurableTxnState_serializer(DurableTxnStateEnum::kInProgress)));
+    auto cursor = client.find(std::move(findRequest));
+
     if (cursor->more()) {
         LOGV2_DEBUG(21977, 3, "Aborting in-progress transactions on stepup.");
     }
@@ -450,12 +452,11 @@ int MongoDSessionCatalog::reapSessionsOlderThan(OperationContext* opCtx,
 
     // Scan for records older than the minimum lifetime and uses a sort to walk the '_id' index
     DBDirectClient client(opCtx);
-    auto cursor = client.query(NamespaceString::kSessionTransactionsTableNamespace,
-                               BSON(kLastWriteDateFieldName << LT << possiblyExpired),
-                               Query().sort(kSortById),
-                               0,
-                               0,
-                               &kIdProjection);
+    FindCommandRequest findRequest{NamespaceString::kSessionTransactionsTableNamespace};
+    findRequest.setFilter(BSON(kLastWriteDateFieldName << LT << possiblyExpired));
+    findRequest.setSort(kSortById);
+    findRequest.setProjection(kIdProjection);
+    auto cursor = client.find(std::move(findRequest));
 
     // The max batch size is chosen so that a single batch won't exceed the 16MB BSON object size
     // limit
diff --git a/src/mongo/db/transaction_participant_retryable_writes_test.cpp b/src/mongo/db/transaction_participant_retryable_writes_test.cpp
index 508f1033814..d0349dbf092 100644
--- a/src/mongo/db/transaction_participant_retryable_writes_test.cpp
+++ b/src/mongo/db/transaction_participant_retryable_writes_test.cpp
@@ -259,8 +259,9 @@ protected:
         const auto session = OperationContextSession::get(opCtx());
 
         DBDirectClient client(opCtx());
-        auto cursor = client.query(NamespaceString::kSessionTransactionsTableNamespace,
-                                   BSON("_id" << session->getSessionId().toBSON()));
+        FindCommandRequest findRequest{NamespaceString::kSessionTransactionsTableNamespace};
+        findRequest.setFilter(BSON("_id" << session->getSessionId().toBSON()));
+        auto cursor = client.find(std::move(findRequest));
         ASSERT(cursor);
         ASSERT(cursor->more());
 
@@ -298,8 +299,9 @@ TEST_F(TransactionParticipantRetryableWritesTest, SessionEntryNotWrittenOnBegin)
     ASSERT(txnParticipant.getLastWriteOpTime().isNull());
 
     DBDirectClient client(opCtx());
-    auto cursor = client.query(NamespaceString::kSessionTransactionsTableNamespace,
-                               BSON("_id" << sessionId.toBSON()));
+    FindCommandRequest findRequest{NamespaceString::kSessionTransactionsTableNamespace};
+    findRequest.setFilter(BSON("_id" << sessionId.toBSON()));
+    auto cursor = client.find(std::move(findRequest));
     ASSERT(cursor);
     ASSERT(!cursor->more());
 }
@@ -316,8 +318,9 @@ TEST_F(TransactionParticipantRetryableWritesTest, SessionEntryWrittenAtFirstWrit
     const auto opTime = writeTxnRecord(txnNum, {0}, {}, boost::none);
 
     DBDirectClient client(opCtx());
-    auto cursor = client.query(NamespaceString::kSessionTransactionsTableNamespace,
-                               BSON("_id" << sessionId.toBSON()));
+    FindCommandRequest findRequest{NamespaceString::kSessionTransactionsTableNamespace};
+    findRequest.setFilter(BSON("_id" << sessionId.toBSON()));
+    auto cursor = client.find(std::move(findRequest));
     ASSERT(cursor);
     ASSERT(cursor->more());
 
@@ -342,8 +345,9 @@ TEST_F(TransactionParticipantRetryableWritesTest,
     const auto secondOpTime = writeTxnRecord(200, {1}, firstOpTime, boost::none);
 
     DBDirectClient client(opCtx());
-    auto cursor = client.query(NamespaceString::kSessionTransactionsTableNamespace,
-                               BSON("_id" << sessionId.toBSON()));
+    FindCommandRequest findRequest{NamespaceString::kSessionTransactionsTableNamespace};
+    findRequest.setFilter(BSON("_id" << sessionId.toBSON()));
+    auto cursor = client.find(std::move(findRequest));
     ASSERT(cursor);
     ASSERT(cursor->more());
 
diff --git a/src/mongo/dbtests/clienttests.cpp b/src/mongo/dbtests/clienttests.cpp
index c595aa018c7..9bebe9f636e 100644
--- a/src/mongo/dbtests/clienttests.cpp
+++ b/src/mongo/dbtests/clienttests.cpp
@@ -158,8 +158,9 @@ public:
 
         ASSERT_OK(dbtests::createIndex(&opCtx, ns(), BSON("a" << 1 << "b" << 1)));
 
-        unique_ptr<DBClientCursor> c =
-            db.query(NamespaceString(ns()), BSONObj{}, Query().sort(BSON("a" << 1 << "b" << 1)));
+        FindCommandRequest findRequest{NamespaceString{ns()}};
+        findRequest.setSort(BSON("a" << 1 << "b" << 1));
+        unique_ptr<DBClientCursor> c = db.find(std::move(findRequest));
         ASSERT_EQUALS(1111, c->itcount());
     }
 };
@@ -176,8 +177,9 @@ public:
             db.insert(ns(), BSON("i" << i));
         }
 
-        unique_ptr<DBClientCursor> c =
-            db.query(NamespaceString(ns()), BSONObj{}, Query().sort(BSON("i" << 1)));
+        FindCommandRequest findRequest{NamespaceString{ns()}};
+        findRequest.setSort(BSON("i" << 1));
+        std::unique_ptr<DBClientCursor> c = db.find(std::move(findRequest));
 
         BSONObj o = c->next();
         ASSERT(c->more());
diff --git a/src/mongo/dbtests/dbhelper_tests.cpp b/src/mongo/dbtests/dbhelper_tests.cpp
index dada7c09da1..04dee799791 100644
--- a/src/mongo/dbtests/dbhelper_tests.cpp
+++ b/src/mongo/dbtests/dbhelper_tests.cpp
@@ -83,8 +83,9 @@ private:
 
     BSONArray docs(OperationContext* opCtx) const {
         DBDirectClient client(opCtx);
-        unique_ptr<DBClientCursor> cursor =
-            client.query(NamespaceString(ns), BSONObj{}, Query().hint(BSON("_id" << 1)));
+        FindCommandRequest findRequest{NamespaceString{ns}};
+        findRequest.setHint(BSON("_id" << 1));
+        std::unique_ptr<DBClientCursor> cursor = client.find(std::move(findRequest));
         BSONArrayBuilder bab;
         while (cursor->more()) {
             bab << cursor->next();
diff --git a/src/mongo/dbtests/directclienttests.cpp b/src/mongo/dbtests/directclienttests.cpp
index f3337944b76..588fc68d820 100644
--- a/src/mongo/dbtests/directclienttests.cpp
+++ b/src/mongo/dbtests/directclienttests.cpp
@@ -93,7 +93,9 @@ public:
         OperationContext& opCtx = *opCtxPtr;
         DBDirectClient client(&opCtx);
 
-        ASSERT_THROWS_CODE(client.query(NamespaceString(), BSONObj{}, Query(), 1)->nextSafe(),
+        FindCommandRequest findRequest{NamespaceString{}};
+        findRequest.setLimit(1);
+        ASSERT_THROWS_CODE(client.find(std::move(findRequest))->nextSafe(),
                            AssertionException,
                            ErrorCodes::InvalidNamespace);
     }
diff --git a/src/mongo/dbtests/logical_sessions_tests.cpp b/src/mongo/dbtests/logical_sessions_tests.cpp
index 335485881e7..28f1699e071 100644
--- a/src/mongo/dbtests/logical_sessions_tests.cpp
+++ b/src/mongo/dbtests/logical_sessions_tests.cpp
@@ -60,10 +60,10 @@ Status insertRecord(OperationContext* opCtx, LogicalSessionRecord record) {
 StatusWith<LogicalSessionRecord> fetchRecord(OperationContext* opCtx,
                                              const LogicalSessionId& lsid) {
     DBDirectClient client(opCtx);
-    auto cursor = client.query(NamespaceString(kTestNS),
-                               BSON(LogicalSessionRecord::kIdFieldName << lsid.toBSON()),
-                               Query(),
-                               1);
+    FindCommandRequest findRequest{NamespaceString{kTestNS}};
+    findRequest.setFilter(BSON(LogicalSessionRecord::kIdFieldName << lsid.toBSON()));
+    findRequest.setLimit(1);
+    auto cursor = client.find(std::move(findRequest));
     if (!cursor->more()) {
         return {ErrorCodes::NoSuchSession, "No matching record in the sessions collection"};
     }
diff --git a/src/mongo/dbtests/mock/mock_dbclient_connection.cpp b/src/mongo/dbtests/mock/mock_dbclient_connection.cpp
index fb71b3fd24e..122dd397a2d 100644
--- a/src/mongo/dbtests/mock/mock_dbclient_connection.cpp
+++ b/src/mongo/dbtests/mock/mock_dbclient_connection.cpp
@@ -158,7 +158,7 @@ std::unique_ptr<DBClientCursor> MockDBClientConnection::find(
     return nullptr;
 }
 
-std::unique_ptr<mongo::DBClientCursor> MockDBClientConnection::query(
+std::unique_ptr<mongo::DBClientCursor> MockDBClientConnection::query_DEPRECATED(
     const NamespaceStringOrUUID& nsOrUuid,
     const BSONObj& filter,
     const Query& querySettings,
@@ -211,25 +211,6 @@ mongo::ConnectionString::ConnectionType MockDBClientConnection::type() const {
     return mongo::ConnectionString::ConnectionType::kCustom;
 }
 
-unsigned long long MockDBClientConnection::query(
-    std::function<void(mongo::DBClientCursorBatchIterator&)> f,
-    const NamespaceStringOrUUID& nsOrUuid,
-    const BSONObj& filter,
-    const Query& querySettings,
-    const mongo::BSONObj* fieldsToReturn,
-    int queryOptions,
-    int batchSize,
-    boost::optional<BSONObj> readConcernObj) {
-    return DBClientBase::query(f,
-                               nsOrUuid,
-                               filter,
-                               querySettings,
-                               fieldsToReturn,
-                               queryOptions,
-                               batchSize,
-                               readConcernObj);
-}
-
 uint64_t MockDBClientConnection::getSockCreationMicroSec() const {
     return _sockCreationTime;
 }
diff --git a/src/mongo/dbtests/mock/mock_dbclient_connection.h b/src/mongo/dbtests/mock/mock_dbclient_connection.h
index 4c44296d045..349ca7478cc 100644
--- a/src/mongo/dbtests/mock/mock_dbclient_connection.h
+++ b/src/mongo/dbtests/mock/mock_dbclient_connection.h
@@ -103,7 +103,8 @@ public:
     //
     // DBClientBase methods
     //
-    using DBClientBase::query;
+    using DBClientBase::find;
+    using DBClientBase::query_DEPRECATED;
 
     bool connect(const char* hostName, StringData applicationName, std::string& errmsg);
 
@@ -123,7 +124,7 @@ public:
     std::unique_ptr<DBClientCursor> find(FindCommandRequest findRequest,
                                          const ReadPreferenceSetting& readPref) override;
 
-    std::unique_ptr<mongo::DBClientCursor> query(
+    std::unique_ptr<mongo::DBClientCursor> query_DEPRECATED(
         const NamespaceStringOrUUID& nsOrUuid,
         const BSONObj& filter = BSONObj{},
         const Query& querySettings = Query(),
@@ -182,19 +183,6 @@ public:
     }
 
     //
-    // Unsupported methods (defined to get rid of virtual function was hidden error)
-    //
-
-    unsigned long long query(std::function<void(mongo::DBClientCursorBatchIterator&)> f,
-                             const NamespaceStringOrUUID& nsOrUuid,
-                             const BSONObj& filter,
-                             const Query& querySettings,
-                             const mongo::BSONObj* fieldsToReturn = nullptr,
-                             int queryOptions = 0,
-                             int batchSize = 0,
-                             boost::optional<BSONObj> readConcernObj = boost::none) override;
-
-    //
     // Unsupported methods (these are pure virtuals in the base class)
     //
 
diff --git a/src/mongo/dbtests/mock_dbclient_conn_test.cpp b/src/mongo/dbtests/mock_dbclient_conn_test.cpp
index 0aeedceb720..a0da2e717ea 100644
--- a/src/mongo/dbtests/mock_dbclient_conn_test.cpp
+++ b/src/mongo/dbtests/mock_dbclient_conn_test.cpp
@@ -43,17 +43,10 @@
 #include <string>
 #include <vector>
 
-using mongo::BSONObj;
-using mongo::ConnectionString;
-using mongo::MockDBClientConnection;
-using mongo::MockRemoteDBServer;
-using mongo::NamespaceString;
-using mongo::Query;
-
 using std::string;
 using std::vector;
 
-namespace mongo_test {
+namespace mongo {
 
 TEST(MockDBClientConnTest, ServerAddress) {
     MockRemoteDBServer server("test");
@@ -72,25 +65,111 @@ TEST(MockDBClientConnTest, QueryCount) {
         MockDBClientConnection conn(&server);
 
         ASSERT_EQUALS(0U, server.getQueryCount());
-        conn.query(NamespaceString("foo.bar"));
+        conn.find(FindCommandRequest(NamespaceString("foo.bar")));
     }
 
     ASSERT_EQUALS(1U, server.getQueryCount());
 
     {
         MockDBClientConnection conn(&server);
-        conn.query(NamespaceString("foo.bar"));
+        conn.find(FindCommandRequest(NamespaceString("foo.bar")));
         ASSERT_EQUALS(2U, server.getQueryCount());
     }
 }
 
+// This test should be removed when the legacy query API is removed.
+TEST(MockDBClientConnTest, LegacyQueryApiBumpsQueryCount) {
+    MockRemoteDBServer server("test");
+    MockDBClientConnection conn(&server);
+    ASSERT_EQUALS(0U, server.getQueryCount());
+    conn.query_DEPRECATED(NamespaceString("foo.bar"));
+    ASSERT_EQUALS(1U, server.getQueryCount());
+}
+
+// This test should be removed when the legacy query API is removed.
+TEST(MockDBClientConnTest, LegacyQueryApiReturnsInsertedDocuments) {
+    MockRemoteDBServer server("test");
+    const std::string ns("test.user");
+
+    {
+        MockDBClientConnection conn(&server);
+        std::unique_ptr<mongo::DBClientCursor> cursor = conn.query_DEPRECATED(NamespaceString(ns));
+        ASSERT(!cursor->more());
+
+        server.insert(ns, BSON("x" << 1));
+        server.insert(ns, BSON("y" << 2));
+    }
+
+    {
+        MockDBClientConnection conn(&server);
+        std::unique_ptr<mongo::DBClientCursor> cursor = conn.query_DEPRECATED(NamespaceString(ns));
+
+        ASSERT(cursor->more());
+        BSONObj firstDoc = cursor->next();
+        ASSERT_EQUALS(1, firstDoc["x"].numberInt());
+
+        ASSERT(cursor->more());
+        BSONObj secondDoc = cursor->next();
+        ASSERT_EQUALS(2, secondDoc["y"].numberInt());
+
+        ASSERT(!cursor->more());
+    }
+}
+
+TEST(MockDBClientConnTest, SkipBasedOnResumeAfter) {
+    MockRemoteDBServer server{"test"};
+    const std::string ns{"test.user"};
+
+    {
+        MockDBClientConnection conn{&server};
+        server.insert(ns, BSON("x" << 1));
+        server.insert(ns, BSON("y" << 2));
+        server.insert(ns, BSON("z" << 3));
+    }
+
+    {
+        MockDBClientConnection conn{&server};
+        FindCommandRequest findRequest{FindCommandRequest{NamespaceString{ns}}};
+        findRequest.setResumeAfter(BSON("n" << 2));
+
+        auto cursor = conn.find(std::move(findRequest));
+        ASSERT_EQ(1, cursor->itcount());
+    }
+}
+
+TEST(MockDBClientConnTest, RequestResumeToken) {
+    MockRemoteDBServer server{"test"};
+    const std::string ns{"test.user"};
+
+    {
+        MockDBClientConnection conn{&server};
+        server.insert(ns, BSON("_id" << 1));
+        server.insert(ns, BSON("_id" << 2));
+        server.insert(ns, BSON("_id" << 3));
+    }
+
+    {
+        MockDBClientConnection conn{&server};
+        FindCommandRequest findRequest{FindCommandRequest{NamespaceString{ns}}};
+        findRequest.setRequestResumeToken(true);
+        findRequest.setBatchSize(2);
+
+        auto cursor = conn.find(std::move(findRequest));
+        ASSERT(cursor->more());
+        auto pbrt = cursor->getPostBatchResumeToken();
+        ASSERT(pbrt);
+        ASSERT_BSONOBJ_EQ(*pbrt, BSON("n" << 2));
+    }
+}
+
 TEST(MockDBClientConnTest, InsertAndQuery) {
     MockRemoteDBServer server("test");
     const string ns("test.user");
 
     {
         MockDBClientConnection conn(&server);
-        std::unique_ptr<mongo::DBClientCursor> cursor = conn.query(NamespaceString(ns));
+        std::unique_ptr<mongo::DBClientCursor> cursor =
+            conn.find(FindCommandRequest(NamespaceString(ns)));
         ASSERT(!cursor->more());
 
         server.insert(ns, BSON("x" << 1));
@@ -99,7 +178,8 @@ TEST(MockDBClientConnTest, InsertAndQuery) {
 
     {
         MockDBClientConnection conn(&server);
-        std::unique_ptr<mongo::DBClientCursor> cursor = conn.query(NamespaceString(ns));
+        std::unique_ptr<mongo::DBClientCursor> cursor =
+            conn.find(FindCommandRequest(NamespaceString(ns)));
 
         ASSERT(cursor->more());
         BSONObj firstDoc = cursor->next();
@@ -115,7 +195,8 @@ TEST(MockDBClientConnTest, InsertAndQuery) {
     // Make sure that repeated calls will still give you the same result
     {
         MockDBClientConnection conn(&server);
-        std::unique_ptr<mongo::DBClientCursor> cursor = conn.query(NamespaceString(ns));
+        std::unique_ptr<mongo::DBClientCursor> cursor =
+            conn.find(FindCommandRequest(NamespaceString(ns)));
 
         ASSERT(cursor->more());
         BSONObj firstDoc = cursor->next();
@@ -137,7 +218,8 @@ TEST(MockDBClientConnTest, InsertAndQueryTwice) {
 
     {
         MockDBClientConnection conn(&server);
-        std::unique_ptr<mongo::DBClientCursor> cursor = conn.query(NamespaceString(ns));
+        std::unique_ptr<mongo::DBClientCursor> cursor =
+            conn.find(FindCommandRequest(NamespaceString(ns)));
 
         ASSERT(cursor->more());
         BSONObj firstDoc = cursor->next();
@@ -148,7 +230,8 @@ TEST(MockDBClientConnTest, InsertAndQueryTwice) {
 
     {
         MockDBClientConnection conn(&server);
-        std::unique_ptr<mongo::DBClientCursor> cursor = conn.query(NamespaceString(ns));
+        std::unique_ptr<mongo::DBClientCursor> cursor =
+            conn.find(FindCommandRequest(NamespaceString(ns)));
 
         ASSERT(cursor->more());
         BSONObj firstDoc = cursor->next();
@@ -168,7 +251,8 @@ TEST(MockDBClientConnTest, QueryWithNoResults) {
 
     server.insert(ns, BSON("x" << 1));
     MockDBClientConnection conn(&server);
-    std::unique_ptr<mongo::DBClientCursor> cursor = conn.query(NamespaceString("other.ns"));
+    std::unique_ptr<mongo::DBClientCursor> cursor =
+        conn.find(FindCommandRequest(NamespaceString("other.ns")));
 
     ASSERT(!cursor->more());
 }
@@ -199,7 +283,8 @@ TEST(MockDBClientConnTest, MultiNSInsertAndQuery) {
 
     {
         MockDBClientConnection conn(&server);
-        std::unique_ptr<mongo::DBClientCursor> cursor = conn.query(NamespaceString(ns1));
+        std::unique_ptr<mongo::DBClientCursor> cursor =
+            conn.find(FindCommandRequest(NamespaceString(ns1)));
 
         ASSERT(cursor->more());
         BSONObj firstDoc = cursor->next();
@@ -214,7 +299,8 @@ TEST(MockDBClientConnTest, MultiNSInsertAndQuery) {
 
     {
         MockDBClientConnection conn(&server);
-        std::unique_ptr<mongo::DBClientCursor> cursor = conn.query(NamespaceString(ns2));
+        std::unique_ptr<mongo::DBClientCursor> cursor =
+            conn.find(FindCommandRequest(NamespaceString(ns2)));
 
         ASSERT(cursor->more());
         BSONObj firstDoc = cursor->next();
@@ -233,7 +319,8 @@ TEST(MockDBClientConnTest, MultiNSInsertAndQuery) {
 
     {
         MockDBClientConnection conn(&server);
-        std::unique_ptr<mongo::DBClientCursor> cursor = conn.query(NamespaceString(ns3));
+        std::unique_ptr<mongo::DBClientCursor> cursor =
+            conn.find(FindCommandRequest(NamespaceString(ns3)));
 
         ASSERT(cursor->more());
         BSONObj firstDoc = cursor->next();
@@ -249,7 +336,8 @@ TEST(MockDBClientConnTest, SimpleRemove) {
 
     {
         MockDBClientConnection conn(&server);
-        std::unique_ptr<mongo::DBClientCursor> cursor = conn.query(NamespaceString(ns));
+        std::unique_ptr<mongo::DBClientCursor> cursor =
+            conn.find(FindCommandRequest(NamespaceString(ns)));
         ASSERT(!cursor->more());
 
         conn.insert(ns, BSON("x" << 1));
@@ -263,7 +351,8 @@ TEST(MockDBClientConnTest, SimpleRemove) {
 
     {
         MockDBClientConnection conn(&server);
-        std::unique_ptr<mongo::DBClientCursor> cursor = conn.query(NamespaceString(ns));
+        std::unique_ptr<mongo::DBClientCursor> cursor =
+            conn.find(FindCommandRequest(NamespaceString(ns)));
 
         ASSERT(!cursor->more());
     }
@@ -271,7 +360,8 @@ TEST(MockDBClientConnTest, SimpleRemove) {
     // Make sure that repeated calls will still give you the same result
     {
         MockDBClientConnection conn(&server);
-        std::unique_ptr<mongo::DBClientCursor> cursor = conn.query(NamespaceString(ns));
+        std::unique_ptr<mongo::DBClientCursor> cursor =
+            conn.find(FindCommandRequest(NamespaceString(ns)));
 
         ASSERT(!cursor->more());
     }
@@ -305,13 +395,15 @@ TEST(MockDBClientConnTest, MultiNSRemove) {
         MockDBClientConnection conn(&server);
         conn.remove(ns2, BSONObj{} /*filter*/);
 
-        std::unique_ptr<mongo::DBClientCursor> cursor = conn.query(NamespaceString(ns2));
+        std::unique_ptr<mongo::DBClientCursor> cursor =
+            conn.find(FindCommandRequest(NamespaceString(ns2)));
         ASSERT(!cursor->more());
     }
 
     {
         MockDBClientConnection conn(&server);
-        std::unique_ptr<mongo::DBClientCursor> cursor = conn.query(NamespaceString(ns1));
+        std::unique_ptr<mongo::DBClientCursor> cursor =
+            conn.find(FindCommandRequest(NamespaceString(ns1)));
 
         ASSERT(cursor->more());
         BSONObj firstDoc = cursor->next();
@@ -326,7 +418,8 @@ TEST(MockDBClientConnTest, MultiNSRemove) {
 
     {
         MockDBClientConnection conn(&server);
-        std::unique_ptr<mongo::DBClientCursor> cursor = conn.query(NamespaceString(ns3));
+        std::unique_ptr<mongo::DBClientCursor> cursor =
+            conn.find(FindCommandRequest(NamespaceString(ns3)));
 
         ASSERT(cursor->more());
         BSONObj firstDoc = cursor->next();
@@ -361,7 +454,8 @@ TEST(MockDBClientConnTest, InsertAfterRemove) {
 
     {
         MockDBClientConnection conn(&server);
-        std::unique_ptr<mongo::DBClientCursor> cursor = conn.query(NamespaceString(ns));
+        std::unique_ptr<mongo::DBClientCursor> cursor =
+            conn.find(FindCommandRequest(NamespaceString(ns)));
 
         ASSERT(cursor->more());
         BSONObj firstDoc = cursor->next();
@@ -510,7 +604,8 @@ TEST(MockDBClientConnTest, Shutdown) {
         server.shutdown();
         ASSERT(!server.isRunning());
 
-        ASSERT_THROWS(conn.query(NamespaceString("test.user")), mongo::NetworkException);
+        ASSERT_THROWS(conn.find(FindCommandRequest(NamespaceString("test.user"))),
+                      mongo::NetworkException);
     }
 
     {
@@ -532,16 +627,18 @@ TEST(MockDBClientConnTest, Restart) {
 
     // Do some queries and commands then check the counters later that
     // new instance still has it
-    conn1.query(NamespaceString("test.user"));
+    conn1.find(FindCommandRequest(NamespaceString("test.user")));
     BSONObj response;
     conn1.runCommand("test.user", BSON("serverStatus" << 1), response);
 
     server.shutdown();
-    ASSERT_THROWS(conn1.query(NamespaceString("test.user")), mongo::NetworkException);
+    ASSERT_THROWS(conn1.find(FindCommandRequest(NamespaceString("test.user"))),
+                  mongo::NetworkException);
 
     // New connections shouldn't work either
     MockDBClientConnection conn2(&server);
-    ASSERT_THROWS(conn2.query(NamespaceString("test.user")), mongo::NetworkException);
+    ASSERT_THROWS(conn2.find(FindCommandRequest(NamespaceString("test.user"))),
+                  mongo::NetworkException);
 
     ASSERT_EQUALS(1U, server.getQueryCount());
     ASSERT_EQUALS(1U, server.getCmdCount());
@@ -551,12 +648,14 @@ TEST(MockDBClientConnTest, Restart) {
 
     {
         MockDBClientConnection conn(&server);
-        conn.query(NamespaceString("test.user"));
+        conn.find(FindCommandRequest(NamespaceString("test.user")));
     }
 
     // Old connections still shouldn't work
-    ASSERT_THROWS(conn1.query(NamespaceString("test.user")), mongo::NetworkException);
-    ASSERT_THROWS(conn2.query(NamespaceString("test.user")), mongo::NetworkException);
+    ASSERT_THROWS(conn1.find(FindCommandRequest(NamespaceString("test.user"))),
+                  mongo::NetworkException);
+    ASSERT_THROWS(conn2.find(FindCommandRequest(NamespaceString("test.user"))),
+                  mongo::NetworkException);
 
     ASSERT_EQUALS(2U, server.getQueryCount());
     ASSERT_EQUALS(1U, server.getCmdCount());
@@ -567,7 +666,7 @@ TEST(MockDBClientConnTest, ClearCounter) {
     server.setCommandReply("serverStatus", BSON("ok" << 1));
 
     MockDBClientConnection conn(&server);
-    conn.query(NamespaceString("test.user"));
+    conn.find(FindCommandRequest(FindCommandRequest(NamespaceString("test.user"))));
     BSONObj response;
     conn.runCommand("test.user", BSON("serverStatus" << 1), response);
 
@@ -585,7 +684,7 @@ TEST(MockDBClientConnTest, Delay) {
 
     {
         mongo::Timer timer;
-        conn.query(NamespaceString("x.x"));
+        conn.find(FindCommandRequest(NamespaceString("x.x")));
         const int nowInMilliSec = timer.millis();
         // Use a more lenient lower bound since some platforms like Windows
         // don't guarantee that sleeps will not wake up earlier (unlike
@@ -990,4 +1089,4 @@ TEST(MockDBClientConnTest, ShutdownServerAfterRecv) {
 
     cursorThread.join();
 }
-}  // namespace mongo_test
+}  // namespace mongo
diff --git a/src/mongo/dbtests/querytests.cpp b/src/mongo/dbtests/querytests.cpp
index 4fa533f350a..5eb9adce27f 100644
--- a/src/mongo/dbtests/querytests.cpp
+++ b/src/mongo/dbtests/querytests.cpp
@@ -467,14 +467,13 @@ public:
         insert(ns, BSON("a" << 0));
         insert(ns, BSON("a" << 1));
         insert(ns, BSON("a" << 2));
-        unique_ptr<DBClientCursor> c = _client.query(NamespaceString(ns),
-                                                     BSONObj{},
-                                                     Query().hint(BSON("$natural" << 1)),
-                                                     0,
-                                                     0,
-                                                     nullptr,
-                                                     QueryOption_CursorTailable,
-                                                     2);
+
+        FindCommandRequest findRequest{NamespaceString{ns}};
+        findRequest.setHint(BSON("$natural" << 1));
+        findRequest.setTailable(true);
+        findRequest.setBatchSize(2);
+        std::unique_ptr<DBClientCursor> c = _client.find(std::move(findRequest));
+
         ASSERT(0 != c->getCursorId());
         while (c->more())
             c->next();
@@ -501,23 +500,19 @@ public:
 
         const char* ns = "unittests.querytests.EmptyTail";
         _client.createCollection(ns, 1900, true);
-        unique_ptr<DBClientCursor> c = _client.query(NamespaceString(ns),
-                                                     BSONObj{},
-                                                     Query().hint(BSON("$natural" << 1)),
-                                                     2,
-                                                     0,
-                                                     nullptr,
-                                                     QueryOption_CursorTailable);
+
+        FindCommandRequest findRequest{NamespaceString{ns}};
+        findRequest.setHint(BSON("$natural" << 1));
+        findRequest.setTailable(true);
+        findRequest.setBatchSize(2);
+
+        std::unique_ptr<DBClientCursor> c = _client.find(findRequest);
         ASSERT_EQUALS(0, c->getCursorId());
         ASSERT(c->isDead());
+
         insert(ns, BSON("a" << 0));
-        c = _client.query(NamespaceString(ns),
-                          BSON("a" << 1),
-                          Query().hint(BSON("$natural" << 1)),
-                          2,
-                          0,
-                          nullptr,
-                          QueryOption_CursorTailable);
+        findRequest.setFilter(BSON("a" << 1));
+        c = _client.find(findRequest);
         ASSERT(0 != c->getCursorId());
         ASSERT(!c->isDead());
     }
@@ -538,13 +533,12 @@ public:
         _client.createCollection(ns, 8192, true, 2);
         insert(ns, BSON("a" << 0));
         insert(ns, BSON("a" << 1));
-        unique_ptr<DBClientCursor> c = _client.query(NamespaceString(ns),
-                                                     BSONObj{},
-                                                     Query().hint(BSON("$natural" << 1)),
-                                                     2,
-                                                     0,
-                                                     nullptr,
-                                                     QueryOption_CursorTailable);
+
+        FindCommandRequest findRequest{NamespaceString{ns}};
+        findRequest.setHint(BSON("$natural" << 1));
+        findRequest.setTailable(true);
+        findRequest.setBatchSize(2);
+        std::unique_ptr<DBClientCursor> c = _client.find(std::move(findRequest));
         c->next();
         c->next();
         ASSERT(!c->more());
@@ -571,13 +565,12 @@ public:
         _client.createCollection(ns, 8192, true, 2);
         insert(ns, BSON("a" << 0));
         insert(ns, BSON("a" << 1));
-        unique_ptr<DBClientCursor> c = _client.query(NamespaceString(ns),
-                                                     BSONObj{},
-                                                     Query().hint(BSON("$natural" << 1)),
-                                                     2,
-                                                     0,
-                                                     nullptr,
-                                                     QueryOption_CursorTailable);
+
+        FindCommandRequest findRequest{NamespaceString{ns}};
+        findRequest.setHint(BSON("$natural" << 1));
+        findRequest.setTailable(true);
+        findRequest.setBatchSize(2);
+        std::unique_ptr<DBClientCursor> c = _client.find(std::move(findRequest));
         c->next();
         c->next();
         ASSERT(!c->more());
@@ -606,14 +599,13 @@ public:
         _client.createCollection(ns, 1330, true);
         insert(ns, BSON("a" << 0));
         insert(ns, BSON("a" << 1));
-        unique_ptr<DBClientCursor> c = _client.query(NamespaceString(ns),
-                                                     BSONObj{},
-                                                     Query().hint(BSON("$natural" << 1)),
-                                                     0,
-                                                     0,
-                                                     nullptr,
-                                                     QueryOption_CursorTailable,
-                                                     2);
+
+        FindCommandRequest findRequest{NamespaceString{ns}};
+        findRequest.setHint(BSON("$natural" << 1));
+        findRequest.setTailable(true);
+        findRequest.setBatchSize(2);
+        std::unique_ptr<DBClientCursor> c = _client.find(std::move(findRequest));
+
         c->next();
         c->next();
         ASSERT(!c->more());
@@ -632,10 +624,9 @@ public:
     void run() {
         const char* ns = "unittests.querytests.TailCappedOnly";
         _client.insert(ns, BSONObj());
-        ASSERT_THROWS(
-            _client.query(
-                NamespaceString(ns), BSONObj{}, Query(), 0, 0, nullptr, QueryOption_CursorTailable),
-            AssertionException);
+        FindCommandRequest findRequest{NamespaceString{ns}};
+        findRequest.setTailable(true);
+        ASSERT_THROWS(_client.find(std::move(findRequest)), AssertionException);
     }
 };
 
@@ -668,22 +659,14 @@ public:
                            info);
         insertA(ns, 0);
         insertA(ns, 1);
-        unique_ptr<DBClientCursor> c1 = _client.query(NamespaceString(ns),
-                                                      BSON("a" << GT << -1),
-                                                      Query(),
-                                                      0,
-                                                      0,
-                                                      nullptr,
-                                                      QueryOption_CursorTailable);
+        FindCommandRequest findRequest{NamespaceString{ns}};
+        findRequest.setFilter(BSON("a" << GT << -1));
+        findRequest.setTailable(true);
+        std::unique_ptr<DBClientCursor> c1 = _client.find(findRequest);
         OID id;
         id.init("000000000000000000000000");
-        unique_ptr<DBClientCursor> c2 = _client.query(NamespaceString(ns),
-                                                      BSON("value" << GT << id),
-                                                      Query(),
-                                                      0,
-                                                      0,
-                                                      nullptr,
-                                                      QueryOption_CursorTailable);
+        findRequest.setFilter(BSON("value" << GT << id));
+        std::unique_ptr<DBClientCursor> c2 = _client.find(findRequest);
         c1->next();
         c1->next();
         ASSERT(!c1->more());
@@ -732,23 +715,16 @@ public:
         insert(ns, BSON("ts" << Timestamp(1000, 0)));
         insert(ns, BSON("ts" << Timestamp(1000, 1)));
         insert(ns, BSON("ts" << Timestamp(1000, 2)));
-        unique_ptr<DBClientCursor> c = _client.query(NamespaceString(ns),
-                                                     BSON("ts" << GT << Timestamp(1000, 1)),
-                                                     Query().hint(BSON("$natural" << 1)),
-                                                     0,
-                                                     0,
-                                                     nullptr);
+        FindCommandRequest findRequest{NamespaceString{ns}};
+        findRequest.setFilter(BSON("ts" << GT << Timestamp(1000, 1)));
+        findRequest.setHint(BSON("$natural" << 1));
+        std::unique_ptr<DBClientCursor> c = _client.find(findRequest);
         ASSERT(c->more());
         ASSERT_EQUALS(2u, c->next()["ts"].timestamp().getInc());
         ASSERT(!c->more());
 
         insert(ns, BSON("ts" << Timestamp(1000, 3)));
-        c = _client.query(NamespaceString(ns),
-                          BSON("ts" << GT << Timestamp(1000, 1)),
-                          Query().hint(BSON("$natural" << 1)),
-                          0,
-                          0,
-                          nullptr);
+        c = _client.find(findRequest);
         ASSERT(c->more());
         ASSERT_EQUALS(2u, c->next()["ts"].timestamp().getInc());
         ASSERT(c->more());
@@ -1021,11 +997,10 @@ public:
         const char* ns = "unittests.querytests.Size";
         _client.insert(ns, fromjson("{a:[1,2,3]}"));
         ASSERT_OK(dbtests::createIndex(&_opCtx, ns, BSON("a" << 1)));
-        ASSERT(_client
-                   .query(NamespaceString(ns),
-                          BSON("a" << mongo::BSIZE << 3),
-                          Query().hint(BSON("a" << 1)))
-                   ->more());
+        FindCommandRequest findRequest{NamespaceString{ns}};
+        findRequest.setFilter(BSON("a" << mongo::BSIZE << 3));
+        findRequest.setHint(BSON("a" << 1));
+        ASSERT(_client.find(std::move(findRequest))->more());
     }
 };
 
@@ -1037,17 +1012,15 @@ public:
     void run() {
         const char* ns = "unittests.querytests.IndexedArray";
         _client.insert(ns, fromjson("{a:[1,2,3]}"));
-        ASSERT(_client.query(NamespaceString(ns), fromjson("{a:[1,2,3]}"))->more());
+        FindCommandRequest findRequest{NamespaceString{ns}};
+        findRequest.setFilter(fromjson("{a:[1,2,3]}"));
+        ASSERT(_client.find(findRequest)->more());
         ASSERT_OK(dbtests::createIndex(&_opCtx, ns, BSON("a" << 1)));
-        ASSERT(_client
-                   .query(NamespaceString(ns),
-                          fromjson("{a:{$in:[1,[1,2,3]]}}"),
-                          Query().hint(BSON("a" << 1)))
-                   ->more());
-        ASSERT(
-            _client
-                .query(NamespaceString(ns), fromjson("{a:[1,2,3]}"), Query().hint(BSON("a" << 1)))
-                ->more());
+        findRequest.setFilter(fromjson("{a:{$in:[1,[1,2,3]]}}"));
+        findRequest.setHint(BSON("a" << 1));
+        ASSERT(_client.find(findRequest)->more());
+        findRequest.setFilter(fromjson("{a:[1,2,3]}"));
+        ASSERT(_client.find(findRequest)->more());
     }
 };
 
@@ -1067,23 +1040,16 @@ public:
 private:
     void check(const string& hintField) {
         const char* ns = "unittests.querytests.InsideArray";
-        ASSERT(_client
-                   .query(NamespaceString(ns),
-                          fromjson("{a:[[1],2]}"),
-                          Query().hint(BSON(hintField << 1)))
-                   ->more());
-        ASSERT(
-            _client
-                .query(NamespaceString(ns), fromjson("{a:[1]}"), Query().hint(BSON(hintField << 1)))
-                ->more());
-        ASSERT(
-            _client
-                .query(NamespaceString(ns), fromjson("{a:2}"), Query().hint(BSON(hintField << 1)))
-                ->more());
-        ASSERT(
-            !_client
-                 .query(NamespaceString(ns), fromjson("{a:1}"), Query().hint(BSON(hintField << 1)))
-                 ->more());
+        FindCommandRequest findRequest{NamespaceString{ns}};
+        findRequest.setHint(BSON(hintField << 1));
+        findRequest.setFilter(fromjson("{a:[[1],2]}"));
+        ASSERT(_client.find(findRequest)->more());
+        findRequest.setFilter(fromjson("{a:[1]}"));
+        ASSERT(_client.find(findRequest)->more());
+        findRequest.setFilter(fromjson("{a:2}"));
+        ASSERT(_client.find(findRequest)->more());
+        findRequest.setFilter(fromjson("{a:1}"));
+        ASSERT(!_client.find(findRequest)->more());
     }
 };
 
@@ -1097,11 +1063,10 @@ public:
         _client.insert(ns, fromjson("{'_id':1,a:[1]}"));
         _client.insert(ns, fromjson("{'_id':2,a:[[1]]}"));
         ASSERT_OK(dbtests::createIndex(&_opCtx, ns, BSON("a" << 1)));
-        ASSERT_EQUALS(
-            1,
-            _client.query(NamespaceString(ns), fromjson("{a:[1]}"), Query().hint(BSON("a" << 1)))
-                ->next()
-                .getIntField("_id"));
+        FindCommandRequest findRequest{NamespaceString{ns}};
+        findRequest.setFilter(fromjson("{a:[1]}"));
+        findRequest.setHint(BSON("a" << 1));
+        ASSERT_EQUALS(1, _client.find(std::move(findRequest))->next().getIntField("_id"));
     }
 };
 
@@ -1121,16 +1086,12 @@ public:
 private:
     void check(const string& hintField) {
         const char* ns = "unittests.querytests.SubobjArr";
-        ASSERT(_client
-                   .query(NamespaceString(ns),
-                          fromjson("{'a.b':1}"),
-                          Query().hint(BSON(hintField << 1)))
-                   ->more());
-        ASSERT(_client
-                   .query(NamespaceString(ns),
-                          fromjson("{'a.b':[1]}"),
-                          Query().hint(BSON(hintField << 1)))
-                   ->more());
+        FindCommandRequest findRequest{NamespaceString{ns}};
+        findRequest.setFilter(fromjson("{'a.b':1}"));
+        findRequest.setHint(BSON(hintField << 1));
+        ASSERT(_client.find(findRequest)->more());
+        findRequest.setFilter(fromjson("{'a.b':[1]}"));
+        ASSERT(_client.find(findRequest)->more());
     }
 };
 
@@ -1256,8 +1217,9 @@ public:
         _client.dropCollection("unittests.querytests.DifferentNumbers");
     }
     void t(const char* ns) {
-        unique_ptr<DBClientCursor> cursor =
-            _client.query(NamespaceString(ns), BSONObj{}, Query().sort("7"));
+        FindCommandRequest findRequest{NamespaceString{ns}};
+        findRequest.setSort(BSON("7" << 1));
+        std::unique_ptr<DBClientCursor> cursor = _client.find(std::move(findRequest));
         while (cursor->more()) {
             BSONObj o = cursor->next();
             verify(o.valid());
@@ -1401,13 +1363,11 @@ public:
 
         int a = count();
 
-        unique_ptr<DBClientCursor> c = _client.query(NamespaceString(ns()),
-                                                     BSON("i" << GT << 0),
-                                                     Query().hint(BSON("$natural" << 1)),
-                                                     0,
-                                                     0,
-                                                     nullptr,
-                                                     QueryOption_CursorTailable);
+        FindCommandRequest findRequest{NamespaceString{ns()}};
+        findRequest.setFilter(BSON("i" << GT << 0));
+        findRequest.setHint(BSON("$natural" << 1));
+        findRequest.setTailable(true);
+        std::unique_ptr<DBClientCursor> c = _client.find(std::move(findRequest));
         int n = 0;
         while (c->more()) {
             BSONObj z = c->next();
@@ -1570,20 +1530,13 @@ public:
 
         for (int k = 0; k < 5; ++k) {
             _client.insert(ns(), BSON("ts" << Timestamp(1000, i++)));
-            unsigned min =
-                _client
-                    .query(NamespaceString(ns()), BSONObj{}, Query().sort(BSON("$natural" << 1)))
-                    ->next()["ts"]
-                    .timestamp()
-                    .getInc();
+            FindCommandRequest findRequest{NamespaceString{ns()}};
+            findRequest.setSort(BSON("$natural" << 1));
+            unsigned min = _client.find(findRequest)->next()["ts"].timestamp().getInc();
             for (unsigned j = -1; j < i; ++j) {
-                unique_ptr<DBClientCursor> c =
-                    _client.query(NamespaceString(ns()),
-                                  BSON("ts" << GTE << Timestamp(1000, j)),
-                                  Query(),
-                                  0,
-                                  0,
-                                  nullptr);
+                FindCommandRequest findRequestInner{NamespaceString{ns()}};
+                findRequestInner.setFilter(BSON("ts" << GTE << Timestamp(1000, j)));
+                std::unique_ptr<DBClientCursor> c = _client.find(findRequestInner);
                 ASSERT(c->more());
                 BSONObj next = c->next();
                 ASSERT(!next["ts"].eoo());
@@ -1635,20 +1588,13 @@ public:
 
         for (int k = 0; k < 5; ++k) {
             _client.insert(ns(), BSON("ts" << Timestamp(1000, i++)));
-            unsigned min =
-                _client
-                    .query(NamespaceString(ns()), BSONObj{}, Query().sort(BSON("$natural" << 1)))
-                    ->next()["ts"]
-                    .timestamp()
-                    .getInc();
+            FindCommandRequest findRequest{NamespaceString{ns()}};
+            findRequest.setSort(BSON("$natural" << 1));
+            unsigned min = _client.find(findRequest)->next()["ts"].timestamp().getInc();
             for (unsigned j = -1; j < i; ++j) {
-                unique_ptr<DBClientCursor> c =
-                    _client.query(NamespaceString(ns()),
-                                  BSON("ts" << GTE << Timestamp(1000, j)),
-                                  Query(),
-                                  0,
-                                  0,
-                                  nullptr);
+                FindCommandRequest findRequestInner{NamespaceString{ns()}};
+                findRequestInner.setFilter(BSON("ts" << GTE << Timestamp(1000, j)));
+                std::unique_ptr<DBClientCursor> c = _client.find(findRequestInner);
                 ASSERT(c->more());
                 BSONObj next = c->next();
                 ASSERT(!next["ts"].eoo());
@@ -1681,13 +1627,10 @@ public:
         size_t startNumCursors = numCursorsOpen();
 
         // Check oplog replay mode with missing collection.
-        unique_ptr<DBClientCursor> c0 =
-            _client.query(NamespaceString("local.oplog.querytests.missing"),
-                          BSON("ts" << GTE << Timestamp(1000, 50)),
-                          Query(),
-                          0,
-                          0,
-                          nullptr);
+        FindCommandRequest findRequestMissingColl{
+            NamespaceString{"local.oplog.querytests.missing"}};
+        findRequestMissingColl.setFilter(BSON("ts" << GTE << Timestamp(1000, 50)));
+        std::unique_ptr<DBClientCursor> c0 = _client.find(std::move(findRequestMissingColl));
         ASSERT(!c0->more());
 
         BSONObj info;
@@ -1711,23 +1654,15 @@ public:
         }
 
         // Check oplog replay mode with empty collection.
-        unique_ptr<DBClientCursor> c = _client.query(NamespaceString(ns()),
-                                                     BSON("ts" << GTE << Timestamp(1000, 50)),
-                                                     Query(),
-                                                     0,
-                                                     0,
-                                                     nullptr);
+        FindCommandRequest findRequest{NamespaceString{ns()}};
+        findRequest.setFilter(BSON("ts" << GTE << Timestamp(1000, 50)));
+        std::unique_ptr<DBClientCursor> c = _client.find(findRequest);
         ASSERT(!c->more());
 
         // Check with some docs in the collection.
         for (int i = 100; i < 150; _client.insert(ns(), BSON("ts" << Timestamp(1000, i++))))
             ;
-        c = _client.query(NamespaceString(ns()),
-                          BSON("ts" << GTE << Timestamp(1000, 50)),
-                          Query(),
-                          0,
-                          0,
-                          nullptr);
+        c = _client.find(findRequest);
         ASSERT(c->more());
         ASSERT_EQUALS(100u, c->next()["ts"].timestamp().getInc());
 
@@ -1775,8 +1710,8 @@ public:
         insert(ns(), BSON("a" << 1));
         insert(ns(), BSON("a" << 2));
         insert(ns(), BSON("a" << 3));
-        unique_ptr<DBClientCursor> cursor =
-            _client.query(NamespaceStringOrUUID("unittests", *coll_opts.uuid), BSONObj{});
+        std::unique_ptr<DBClientCursor> cursor =
+            _client.find(FindCommandRequest{NamespaceStringOrUUID{"unittests", *coll_opts.uuid}});
         ASSERT_EQUALS(string(ns()), cursor->getns());
         for (int i = 1; i <= 3; ++i) {
             ASSERT(cursor->more());
@@ -1926,8 +1861,9 @@ public:
         {
             // With five results and a batch size of 5, a cursor is created since we don't know
             // there are no more results.
-            std::unique_ptr<DBClientCursor> c =
-                _client.query(NamespaceString(ns()), BSONObj{}, Query(), 0, 0, nullptr, 0, 5);
+            FindCommandRequest findRequest{NamespaceString{ns()}};
+            findRequest.setBatchSize(5);
+            std::unique_ptr<DBClientCursor> c = _client.find(std::move(findRequest));
             ASSERT(c->more());
             ASSERT_NE(0, c->getCursorId());
             for (int i = 0; i < 5; ++i) {
@@ -1939,8 +1875,9 @@ public:
         {
             // With a batchsize of 6 we know there are no more results so we don't create a
             // cursor.
-            std::unique_ptr<DBClientCursor> c =
-                _client.query(NamespaceString(ns()), BSONObj{}, Query(), 6);
+            FindCommandRequest findRequest{NamespaceString{ns()}};
+            findRequest.setBatchSize(6);
+            std::unique_ptr<DBClientCursor> c = _client.find(std::move(findRequest));
             ASSERT(c->more());
             ASSERT_EQ(0, c->getCursorId());
         }
diff --git a/src/mongo/dbtests/repltests.cpp b/src/mongo/dbtests/repltests.cpp
index a2b97472963..b42439d2b57 100644
--- a/src/mongo/dbtests/repltests.cpp
+++ b/src/mongo/dbtests/repltests.cpp
@@ -212,14 +212,16 @@ protected:
         return count;
     }
     int opCount() {
-        return DBDirectClient(&_opCtx).query(NamespaceString(cllNS()), BSONObj{})->itcount();
+        return DBDirectClient(&_opCtx)
+            .find(FindCommandRequest{NamespaceString{cllNS()}})
+            ->itcount();
     }
     void applyAllOperations() {
         Lock::GlobalWrite lk(&_opCtx);
         vector<BSONObj> ops;
         {
             DBDirectClient db(&_opCtx);
-            auto cursor = db.query(NamespaceString(cllNS()), BSONObj{});
+            auto cursor = db.find(FindCommandRequest{NamespaceString{cllNS()}});
             while (cursor->more()) {
                 ops.push_back(cursor->nextSafe());
             }
@@ -771,8 +773,9 @@ class MultiInc : public Recovering {
 public:
     string s() const {
         StringBuilder ss;
-        unique_ptr<DBClientCursor> cc =
-            _client.query(NamespaceString(ns()), BSONObj{}, Query().sort(BSON("_id" << 1)));
+        FindCommandRequest findRequest{NamespaceString{ns()}};
+        findRequest.setSort(BSON("_id" << 1));
+        std::unique_ptr<DBClientCursor> cc = _client.find(std::move(findRequest));
         bool first = true;
         while (cc->more()) {
             if (first)
diff --git a/src/mongo/dbtests/updatetests.cpp b/src/mongo/dbtests/updatetests.cpp
index 713f58e0d39..42e03ace033 100644
--- a/src/mongo/dbtests/updatetests.cpp
+++ b/src/mongo/dbtests/updatetests.cpp
@@ -420,8 +420,9 @@ class MultiInc : public SetBase {
 public:
     string s() {
         stringstream ss;
-        unique_ptr<DBClientCursor> cc = _client.query(
-            NamespaceString(ns()), BSONObj{} /*filter*/, Query().sort(BSON("_id" << 1)));
+        FindCommandRequest findRequest{NamespaceString{ns()}};
+        findRequest.setSort(BSON("_id" << 1));
+        std::unique_ptr<DBClientCursor> cc = _client.find(std::move(findRequest));
         bool first = true;
         while (cc->more()) {
             if (first)
diff --git a/src/mongo/rpc/op_msg_integration_test.cpp b/src/mongo/rpc/op_msg_integration_test.cpp
index 9d119c391f6..3f235f58388 100644
--- a/src/mongo/rpc/op_msg_integration_test.cpp
+++ b/src/mongo/rpc/op_msg_integration_test.cpp
@@ -1165,8 +1165,14 @@ TEST(OpMsg, ExhaustWithDBClientCursorBehavesCorrectly) {
 
     // Open an exhaust cursor.
     int batchSize = 2;
-    auto cursor = conn->query(
-        nss, BSONObj{}, Query().sort("_id", 1), 0, 0, nullptr, QueryOption_Exhaust, batchSize);
+    auto cursor = conn->query_DEPRECATED(nss,
+                                         BSONObj{},
+                                         Query().sort(BSON("_id" << 1)),
+                                         0,
+                                         0,
+                                         nullptr,
+                                         QueryOption_Exhaust,
+                                         batchSize);
 
     // Verify that the documents are returned properly. Exhaust cursors should still receive results
     // in batches, so we check that these batches correspond to the given specified batch size.
diff --git a/src/mongo/scripting/engine.cpp b/src/mongo/scripting/engine.cpp
index cc85b2f0f99..c7808f1a9f5 100644
--- a/src/mongo/scripting/engine.cpp
+++ b/src/mongo/scripting/engine.cpp
@@ -225,8 +225,8 @@ void Scope::loadStored(OperationContext* opCtx, bool ignoreNotConnected) {
 
     auto directDBClient = DBDirectClientFactory::get(opCtx).create(opCtx);
 
-    unique_ptr<DBClientCursor> c =
-        directDBClient->query(coll, BSONObj{}, Query(), 0, 0, nullptr, QueryOption_SecondaryOk, 0);
+    std::unique_ptr<DBClientCursor> c = directDBClient->find(
+        FindCommandRequest{coll}, ReadPreferenceSetting{ReadPreference::SecondaryPreferred});
     massert(16669, "unable to get db client cursor from query", c.get());
 
     set<string> thisTime;
diff --git a/src/mongo/scripting/mozjs/mongo.cpp b/src/mongo/scripting/mozjs/mongo.cpp
index c519d55ed24..0c758aab00a 100644
--- a/src/mongo/scripting/mozjs/mongo.cpp
+++ b/src/mongo/scripting/mozjs/mongo.cpp
@@ -368,14 +368,14 @@ void MongoBase::Functions::find::call(JSContext* cx, JS::CallArgs args) {
     int options = ValueWriter(cx, args.get(6)).toInt32();
 
     const Query query = Query::fromBSONDeprecated(q);
-    std::unique_ptr<DBClientCursor> cursor(conn->query(NamespaceString(ns),
-                                                       query.getFilter(),
-                                                       query,
-                                                       limit,
-                                                       nToSkip,
-                                                       haveFields ? &fields : nullptr,
-                                                       options,
-                                                       batchSize));
+    std::unique_ptr<DBClientCursor> cursor(conn->query_DEPRECATED(NamespaceString(ns),
+                                                                  query.getFilter(),
+                                                                  query,
+                                                                  limit,
+                                                                  nToSkip,
+                                                                  haveFields ? &fields : nullptr,
+                                                                  options,
+                                                                  batchSize));
     if (!cursor.get()) {
         uasserted(ErrorCodes::InternalError, "error doing query: failed");
     }
diff --git a/src/mongo/shell/encrypted_dbclient_base.cpp b/src/mongo/shell/encrypted_dbclient_base.cpp
index e27b0e40a75..71de4965e2a 100644
--- a/src/mongo/shell/encrypted_dbclient_base.cpp
+++ b/src/mongo/shell/encrypted_dbclient_base.cpp
@@ -505,8 +505,12 @@ JS::Value EncryptedDBClientBase::getCollection() const {
     return _collection.get();
 }
 
+std::unique_ptr<DBClientCursor> EncryptedDBClientBase::find(FindCommandRequest findRequest,
+                                                            const ReadPreferenceSetting& readPref) {
+    return _conn->find(std::move(findRequest), readPref);
+}
 
-std::unique_ptr<DBClientCursor> EncryptedDBClientBase::query(
+std::unique_ptr<DBClientCursor> EncryptedDBClientBase::query_DEPRECATED(
     const NamespaceStringOrUUID& nsOrUuid,
     const BSONObj& filter,
     const Query& querySettings,
@@ -516,15 +520,15 @@ std::unique_ptr<DBClientCursor> EncryptedDBClientBase::query(
     int queryOptions,
     int batchSize,
     boost::optional<BSONObj> readConcernObj) {
-    return _conn->query(nsOrUuid,
-                        filter,
-                        querySettings,
-                        limit,
-                        nToSkip,
-                        fieldsToReturn,
-                        queryOptions,
-                        batchSize,
-                        readConcernObj);
+    return _conn->query_DEPRECATED(nsOrUuid,
+                                   filter,
+                                   querySettings,
+                                   limit,
+                                   nToSkip,
+                                   fieldsToReturn,
+                                   queryOptions,
+                                   batchSize,
+                                   readConcernObj);
 }
 
 bool EncryptedDBClientBase::isFailed() const {
diff --git a/src/mongo/shell/encrypted_dbclient_base.h b/src/mongo/shell/encrypted_dbclient_base.h
index eaa496834da..6ad4bf74a3d 100644
--- a/src/mongo/shell/encrypted_dbclient_base.h
+++ b/src/mongo/shell/encrypted_dbclient_base.h
@@ -80,14 +80,14 @@ constexpr std::array<StringData, 11> kEncryptedCommands = {"aggregate"_sd,
 
 class EncryptedDBClientBase : public DBClientBase, public mozjs::EncryptionCallbacks {
 public:
-    using DBClientBase::query;
+    using DBClientBase::find;
+    using DBClientBase::query_DEPRECATED;
 
     EncryptedDBClientBase(std::unique_ptr<DBClientBase> conn,
                           ClientSideFLEOptions encryptionOptions,
                           JS::HandleValue collection,
                           JSContext* cx);
 
-
     std::string getServerAddress() const final;
 
     bool call(Message& toSend, Message& response, bool assertOk, std::string* actualServer) final;
@@ -118,7 +118,10 @@ public:
     using EncryptionCallbacks::trace;
     void trace(JSTracer* trc) final;
 
-    std::unique_ptr<DBClientCursor> query(
+    std::unique_ptr<DBClientCursor> find(FindCommandRequest findRequest,
+                                         const ReadPreferenceSetting& readPref) final;
+
+    std::unique_ptr<DBClientCursor> query_DEPRECATED(
         const NamespaceStringOrUUID& nsOrUuid,
         const BSONObj& filter,
         const Query& querySettings,