SERVER-58670 Modernize DBClientBase query interface to avoid OP_QUERY-derived characteristics

1 files changed, 282 insertions, 357 deletions

diff --git a/src/mongo/client/dbclient_base.h b/src/mongo/client/dbclient_base.h
index f29037b04c0..56227d92b40 100644
--- a/src/mongo/client/dbclient_base.h
+++ b/src/mongo/client/dbclient_base.h
@@ -63,53 +63,26 @@ namespace executor {
 struct RemoteCommandResponse;
 }
 
-// Useful utilities for namespaces
-/** @return the database name portion of an ns std::string */
+/**
+ * Returns the database name portion of an ns std::string.
+ */
 std::string nsGetDB(const std::string& ns);
 
-/** @return the collection name portion of an ns std::string */
-std::string nsGetCollection(const std::string& ns);
-
 /**
- * This class pre-declares all the "query()" methods for DBClient so the subclasses can mark
- * them as "final" or "override" as appropriate.
+ * Returns the collection name portion of an ns std::string.
  */
-class DBClientQueryInterface {
-    virtual std::unique_ptr<DBClientCursor> query(
-        const NamespaceStringOrUUID& nsOrUuid,
-        Query query,
-        int limit = 0,
-        int nToSkip = 0,
-        const BSONObj* fieldsToReturn = nullptr,
-        int queryOptions = 0,
-        int batchSize = 0,
-        boost::optional<BSONObj> readConcernObj = boost::none) = 0;
-
-    virtual unsigned long long query(std::function<void(const BSONObj&)> f,
-                                     const NamespaceStringOrUUID& nsOrUuid,
-                                     Query query,
-                                     const BSONObj* fieldsToReturn = nullptr,
-                                     int queryOptions = 0,
-                                     int batchSize = 0,
-                                     boost::optional<BSONObj> readConcernObj = boost::none) = 0;
-
-    virtual unsigned long long query(std::function<void(DBClientCursorBatchIterator&)> f,
-                                     const NamespaceStringOrUUID& nsOrUuid,
-                                     Query query,
-                                     const BSONObj* fieldsToReturn = nullptr,
-                                     int queryOptions = 0,
-                                     int batchSize = 0,
-                                     boost::optional<BSONObj> readConcernObj = boost::none) = 0;
-};
+std::string nsGetCollection(const std::string& ns);
 
 /**
- abstract class that implements the core db operations
+ * Abstract class that implements the core db operations.
  */
-class DBClientBase : public DBClientQueryInterface {
+class DBClientBase {
     DBClientBase(const DBClientBase&) = delete;
     DBClientBase& operator=(const DBClientBase&) = delete;
 
 public:
+    static const uint64_t INVALID_SOCK_CREATION_TIME;
+
     DBClientBase(const ClientAPIVersionParameters* apiParameters = nullptr)
         : _logLevel(logv2::LogSeverity::Log()),
           _connectionId(ConnectionIdSequence.fetchAndAdd(1)),
@@ -122,86 +95,69 @@ public:
 
     virtual ~DBClientBase() {}
 
-    /**
-       @return a single object that matches the query.  if none do, then the object is empty
-       @throws AssertionException
-    */
-    virtual BSONObj findOne(const std::string& ns,
-                            const Query& query,
-                            const BSONObj* fieldsToReturn = nullptr,
-                            int queryOptions = 0,
-                            boost::optional<BSONObj> readConcernObj = boost::none);
+    virtual std::string toString() const = 0;
 
-    /** query N objects from the database into an array.  makes sense mostly when you want a small
-     * number of results.  if a huge number, use query() and iterate the cursor.
+    virtual std::string getServerAddress() const = 0;
+
+    rpc::ProtocolSet getClientRPCProtocols() const;
+    rpc::ProtocolSet getServerRPCProtocols() const;
+
+    /**
+     * Reconnect if needed and allowed.
      */
-    void findN(std::vector<BSONObj>& out,
-               const std::string& ns,
-               Query query,
-               int limit,
-               int nToSkip = 0,
-               const BSONObj* fieldsToReturn = nullptr,
-               int queryOptions = 0,
-               boost::optional<BSONObj> readConcernObj = boost::none);
+    virtual void checkConnection() {}
 
     /**
-     * @return 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
+     * If not checked recently, checks whether the underlying socket/sockets are still valid.
      */
-    virtual std::pair<BSONObj, NamespaceString> findOneByUUID(
-        const std::string& db,
-        UUID uuid,
-        const BSONObj& filter,
-        boost::optional<BSONObj> readConcernObj = boost::none);
+    virtual bool isStillConnected() = 0;
 
-    virtual std::string getServerAddress() const = 0;
+    long long getConnectionId() const {
+        return _connectionId;
+    }
 
-    /** helper function.  run a simple command where the command expression is simply
-          { command : 1 }
-        @param info -- where to put result object.  may be null if caller doesn't need that info
-        @param command -- command name
-        @return true if the command returned "ok".
+    /**
+     * Returns true if this connection is currently in a failed state.
      */
-    bool simpleCommand(const std::string& dbname, BSONObj* info, const std::string& command);
+    virtual bool isFailed() const = 0;
 
-    rpc::ProtocolSet getClientRPCProtocols() const;
-    rpc::ProtocolSet getServerRPCProtocols() const;
+    virtual ConnectionString::ConnectionType type() const = 0;
+
+    virtual double getSoTimeout() const = 0;
+
+    virtual uint64_t getSockCreationMicroSec() const {
+        return INVALID_SOCK_CREATION_TIME;
+    }
+
+    virtual void reset() {}
 
     /**
-     * actualServer is set to the actual server where they call went if there was a choice (for
-     * example SecondaryOk).
+     * Returns true in isPrimary param if this db is the current primary of a replica pair.
+     *
+     * Pass in info for more details e.g.:
+     *   { "isprimary" : 1.0 , "msg" : "not paired" , "ok" : 1.0  }
+     *
+     * Returns true if command invoked successfully.
      */
-    virtual bool call(Message& toSend,
-                      Message& response,
-                      bool assertOk = true,
-                      std::string* actualServer = nullptr) = 0;
+    virtual bool isPrimary(bool& isPrimary, BSONObj* info = nullptr);
 
-    virtual void say(Message& toSend,
-                     bool isRetry = false,
-                     std::string* actualServer = nullptr) = 0;
+    virtual bool isReplicaSetMember() const = 0;
 
-    /* used by QueryOption_Exhaust.  To use that your subclass must implement this. */
-    virtual Status recv(Message& m, int lastRequestId) {
-        verify(false);
-        return {ErrorCodes::NotImplemented, "recv() not implemented"};
-    }
+    virtual bool isMongos() const = 0;
 
-    // In general, for lazy queries, we'll need to say, recv, then checkResponse
-    virtual void checkResponse(const std::vector<BSONObj>& batch,
-                               bool networkError,
-                               bool* retry = nullptr,
-                               std::string* targetHost = nullptr) {
-        if (retry)
-            *retry = false;
-        if (targetHost)
-            *targetHost = "";
+    virtual int getMinWireVersion() = 0;
+    virtual int getMaxWireVersion() = 0;
+
+    const std::vector<std::string>& getIsPrimarySaslMechanisms() const {
+        return _saslMechsForAuth;
     }
 
-    virtual bool lazySupported() const = 0;
+    /**
+     * Returns the latest operationTime tracked on this client.
+     */
+    Timestamp getOperationTime();
+
+    void setOperationTime(Timestamp operationTime);
 
     /**
      * Sets a RequestMetadataWriter on this connection.
@@ -211,9 +167,8 @@ public:
     virtual void setRequestMetadataWriter(rpc::RequestMetadataWriter writer);
 
     /**
-     * Gets the RequestMetadataWriter that is set on this connection. This may
-     * be an uninitialized std::function, so it should be checked for validity
-     * with operator bool() first.
+     * Gets the RequestMetadataWriter that is set on this connection. This may be an uninitialized
+     * std::function, so it should be checked for validity with operator bool() first.
      */
     const rpc::RequestMetadataWriter& getRequestMetadataWriter();
 
@@ -225,20 +180,26 @@ public:
     virtual void setReplyMetadataReader(rpc::ReplyMetadataReader reader);
 
     /**
-     * Gets the ReplyMetadataReader that is set on this connection. This may
-     * be an uninitialized std::function, so it should be checked for validity
-     * with operator bool() first.
+     * Gets the ReplyMetadataReader that is set on this connection. This may be an uninitialized
+     * std::function, so it should be checked for validity with operator bool() first.
      */
     const rpc::ReplyMetadataReader& getReplyMetadataReader();
 
     /**
+     * Parses command replies and runs them through the metadata reader.
+     * This is virtual and non-const to allow subclasses to act on failures.
+     */
+    virtual rpc::UniqueReply parseCommandReplyMessage(const std::string& host,
+                                                      const Message& replyMsg);
+
+    /**
      * Runs the specified command request.
      */
     virtual std::pair<rpc::UniqueReply, DBClientBase*> runCommandWithTarget(OpMsgRequest request);
 
     /**
      * This shared_ptr overload is used to possibly return a shared_ptr to the replica set member
-     * that the command was dispatched to.  It's needed if the caller needs a lifetime for that
+     * that the command was dispatched to. It's needed if the caller needs a lifetime for that
      * connection that extends beyond the lifetime, or subsequent calls, against the top level
      * client.
      *
@@ -267,25 +228,25 @@ public:
      */
     virtual DBClientBase* runFireAndForgetCommand(OpMsgRequest request);
 
-    /** Run a database command.  Database commands are represented as BSON objects.  Common database
-        commands have prebuilt helper functions -- see below.  If a helper is not available you can
-        directly call runCommand.
-
-        @param dbname database name.  Use "admin" for global administrative commands.
-        @param cmd  the command object to execute.  For example, { hello : 1 }
-        @param info the result object the database returns. Typically has { ok : ..., errmsg : ... }
-                    fields set.
-        @param options see enum QueryOptions - normally not needed to run a command
-        @param auth if set, the BSONObj representation will be appended to the command object sent
-
-        @return true if the command returned "ok".
-    */
+    /**
+     * Runs a database command. Database commands are represented as BSON objects. Common database
+     * commands have prebuilt helper functions -- see below. If a helper is not available you can
+     * directly call runCommand.
+     *
+     *  'dbname': Database name. Use "admin" for global administrative commands.
+     *  'cmd': The command object to execute. For example, { hello : 1 }.
+     *  'info': The result object the database returns. Typically has { ok : ..., errmsg : ... }
+     *          fields set.
+     *  'options': See enum QueryOptions - normally not needed to run a command.
+     *
+     *  Returns true if the command returned "ok".
+     */
     bool runCommand(const std::string& dbname, BSONObj cmd, BSONObj& info, int options = 0);
 
     /*
-     * This wraps up the runCommand function avove, but returns the DBClient that actually ran
-     * the command. When called against a replica set, this will return the specific
-     * replica set member the command ran against.
+     * Wraps up the runCommand function avove, but returns the DBClient that actually ran the
+     * command. When called against a replica set, this will return the specific replica set member
+     * the command ran against.
      *
      * This is used in the shell so that cursors can send getMore through the correct connection.
      */
@@ -306,46 +267,47 @@ public:
 
     /**
      * Authenticates to another cluster member using appropriate authentication data.
-     * @return true if the authentication was successful
+     * Returns true if the authentication was successful.
      */
     virtual Status authenticateInternalUser(
         auth::StepDownBehavior stepDownBehavior = auth::StepDownBehavior::kKillConnection);
 
     /**
-     * Authenticate a user.
+     * Authenticates a user.
      *
-     * The "params" BSONObj should be initialized with some of the fields below.  Which fields
+     * The 'params' BSONObj should be initialized with some of the fields below. Which fields
      * are required depends on the mechanism, which is mandatory.
      *
-     *     "mechanism": The std::string name of the sasl mechanism to use.  Mandatory.
-     *     "user": The std::string name of the user to authenticate.  Mandatory.
-     *     "db": The database target of the auth command, which identifies the location
-     *         of the credential information for the user.  May be "$external" if
-     *         credential information is stored outside of the mongo cluster.  Mandatory.
-     *     "pwd": The password data.
-     *     "digestPassword": Boolean, set to true if the "pwd" is undigested (default).
-     *     "serviceName": The GSSAPI service name to use.  Defaults to "mongodb".
-     *     "serviceHostname": The GSSAPI hostname to use.  Defaults to the name of the remote
-     *          host.
-     *
-     * Other fields in "params" are silently ignored.
-     *
-     * Returns normally on success, and throws on error.  Throws a DBException with getCode() ==
-     * ErrorCodes::AuthenticationFailed if authentication is rejected.  All other exceptions are
+     *  'mechanism': The std::string name of the sasl mechanism to use. Mandatory.
+     *  'user': The std::string name of the user to authenticate. Mandatory.
+     *  'db': The database target of the auth command, which identifies the location
+     *        of the credential information for the user. May be "$external" if
+     *        credential information is stored outside of the mongo cluster. Mandatory.
+     *  'pwd': The password data.
+     *  'digestPassword': Boolean, set to true if the "pwd" is undigested (default).
+     *  'serviceName': The GSSAPI service name to use. Defaults to "mongodb".
+     *  'serviceHostname': The GSSAPI hostname to use. Defaults to the name of the remote host.
+     *
+     * Other fields in 'params' are silently ignored.
+     *
+     * Returns normally on success, and throws on error. Throws a DBException with getCode() ==
+     * ErrorCodes::AuthenticationFailed if authentication is rejected. All other exceptions are
      * tantamount to authentication failure, but may also indicate more serious problems.
      */
     void auth(const BSONObj& params);
 
-    /** Authorize access to a particular database.
-        Authentication is separate for each database on the server -- you may authenticate for any
-        number of databases on a single connection.
-        The "admin" database is special and once authenticated provides access to all databases on
-        the server.
-        @param      digestPassword  if password is plain text, set this to true.  otherwise assumed
-                                    to be pre-digested
-        @param[out] authLevel       level of authentication for the given user
-        @return true if successful
-    */
+    /**
+     * Authorizes access to a particular database.
+     *
+     * Authentication is separate for each database on the server -- you may authenticate for any
+     * number of databases on a single connection. The "admin" database is special and once
+     * authenticated provides access to all databases on the server.
+     *
+     *  'digestPassword': If password is plain text, set this to true. otherwise assumed to be
+     *                    pre-digested.
+     *
+     *   Returns true if successful.
+     */
     bool auth(const std::string& dbname,
               const std::string& username,
               const std::string& pwd,
@@ -355,50 +317,32 @@ public:
     /**
      * Logs out the connection for the given database.
      *
-     * @param dbname the database to logout from.
-     * @param info the result object for the logout command (provided for backwards
-     *     compatibility with mongo shell)
+     * 'dbname': The database to logout from.
+     * 'info': The result object for the logout command (provided for backwards compatibility with
+     *         mongo shell).
      */
     virtual void logout(const std::string& dbname, BSONObj& info);
 
-    /** count number of objects in collection ns that match the query criteria specified
-        throws UserAssertion if database returns an error
-    */
-    virtual long long count(NamespaceStringOrUUID nsOrUuid,
-                            const BSONObj& query = BSONObj(),
-                            int options = 0,
-                            int limit = 0,
-                            int skip = 0,
-                            boost::optional<BSONObj> readConcernObj = boost::none);
-
-    static std::string createPasswordDigest(const std::string& username,
-                                            const std::string& clearTextPassword);
-
-    /** returns true in isPrimary param if this db is the current primary of a replica pair.
-
-       pass in info for more details e.g.:
-         { "isprimary" : 1.0 , "msg" : "not paired" , "ok" : 1.0  }
-
-       returns true if command invoked successfully.
-    */
-    virtual bool isPrimary(bool& isPrimary, BSONObj* info = nullptr);
+    virtual bool authenticatedDuringConnect() const {
+        return false;
+    }
 
     /**
-       Create a new collection in the database.  Normally, collection creation is automatic.  You
-       would use this function if you wish to specify special options on creation.
-
-       If the collection already exists, no action occurs.
-
-       @param ns     fully qualified collection name
-       @param size   desired initial extent size for the collection.
-                     Must be <= 1000000000 for normal collections.
-                     For fixed size (capped) collections, this size is the total/max size of the
-                     collection.
-       @param capped if true, this is a fixed size collection (where old data rolls out).
-       @param max    maximum number of objects if capped (optional).
-
-       returns true if successful.
-    */
+     * Creates a new collection in the database. Normally, collection creation is automatic. You
+     * would use this function if you wish to specify special options on creation.
+     *
+     *  If the collection already exists, no action occurs.
+     *
+     *  'ns': Fully qualified collection name.
+     *  'size': Desired initial extent size for the collection.
+     *          Must be <= 1000000000 for normal collections.
+     *          For fixed size (capped) collections, this size is the total/max size of the
+     *          collection.
+     *  'capped': If true, this is a fixed size collection (where old data rolls out).
+     *  'max': Maximum number of objects if capped (optional).
+     *
+     * Returns true if successful.
+     */
     bool createCollection(const std::string& ns,
                           long long size = 0,
                           bool capped = false,
@@ -406,9 +350,11 @@ public:
                           BSONObj* info = nullptr,
                           boost::optional<BSONObj> writeConcernObj = boost::none);
 
-    /** Delete the specified collection.
-     *  @param info An optional output parameter that receives the result object the database
-     *  returns from the drop command.  May be null if the caller doesn't need that info.
+    /**
+     * Deletes the specified collection.
+     *
+     *  'info': An optional output parameter that receives the result object the database returns
+     *          from the drop command. May be null if the caller doesn't need that info.
      */
     virtual bool dropCollection(const std::string& ns,
                                 const WriteConcernOptions& writeConcern = WriteConcernOptions(),
@@ -427,8 +373,9 @@ public:
         return res;
     }
 
-    /** validate a collection, checking for errors and reporting back statistics.
-        this operation is slow and blocking.
+    /**
+     * Validates a collection, checking for errors and reporting back statistics.
+     * This operation is slow and blocking.
      */
     bool validate(const std::string& ns) {
         BSONObj cmd = BSON("validate" << nsGetCollection(ns));
@@ -444,10 +391,24 @@ public:
     std::list<BSONObj> getCollectionInfos(const std::string& db, const BSONObj& filter = BSONObj());
 
     /**
+     * Drops an entire database.
+     */
+    virtual bool dropDatabase(const std::string& dbname,
+                              const WriteConcernOptions& writeConcern = WriteConcernOptions(),
+                              BSONObj* info = nullptr) {
+        BSONObj o;
+        if (info == nullptr)
+            info = &o;
+        return runCommand(
+            dbname, BSON("dropDatabase" << 1 << "writeConcern" << writeConcern.toBSON()), *info);
+    }
+
+    /**
      * Lists databases available on the server.
-     * @param filter A filter for the results
-     * @param nameOnly Only return the names of the databases
-     * @param authorizedDatabases Only return the databases the user is authorized on
+     *
+     * 'filter': A filter for the results
+     * 'nameOnly': Only return the names of the databases
+     * 'authorizedDatabases': Only return the databases the user is authorized on
      */
     std::vector<BSONObj> getDatabaseInfos(const BSONObj& filter = BSONObj(),
                                           bool nameOnly = false,
@@ -455,14 +416,14 @@ public:
 
     bool exists(const std::string& ns);
 
-    /** Create an index on the collection 'ns' as described by the given keys. If you wish
-     *  to specify options, see the more flexible overload of 'createIndex' which takes an
-     *  IndexSpec object. Failure to construct the index is reported by throwing a
-     *  AssertionException.
+    /**
+     * Creates an index on the collection 'ns' as described by the given keys. If you wish to
+     * specify options, see the more flexible overload of 'createIndex' which takes an IndexSpec
+     * object. Failure to construct the index is reported by throwing a AssertionException.
      *
-     *  @param ns Namespace on which to create the index
-     *  @param keys Document describing keys and index types. You must provide at least one
-     *  field and its direction.
+     *  'ns': Namespace on which to create the index
+     *  'keys': Document describing keys and index types. You must provide at least one field and
+     *          its direction.
      */
     void createIndex(StringData ns,
                      const BSONObj& keys,
@@ -470,13 +431,13 @@ public:
         return createIndex(ns, IndexSpec().addKeys(keys), writeConcernObj);
     }
 
-    /** Create an index on the collection 'ns' as described by the given
-     *  descriptor. Failure to construct the index is reported by throwing a
-     *  AssertionException.
+    /**
+     * Creates an index on the collection 'ns' as described by the given descriptor. Failure to
+     * construct the index is reported by throwing a AssertionException.
      *
-     *  @param ns Namespace on which to create the index
-     *  @param descriptor Configuration object describing the index to create. The
-     *  descriptor must describe at least one key and index type.
+     *  'ns': Namespace on which to create the index
+     *  'descriptor': Configuration object describing the index to create. The descriptor must
+     *                describe at least one key and index type.
      */
     virtual void createIndex(StringData ns,
                              const IndexSpec& descriptor,
@@ -525,7 +486,7 @@ public:
                            boost::optional<BSONObj> writeConcernObj = boost::none);
 
     /**
-       drops all indexes for the collection
+     * Drops all indexes for the collection.
      */
     virtual void dropIndexes(const std::string& ns,
                              boost::optional<BSONObj> writeConcernObj = boost::none);
@@ -534,72 +495,66 @@ public:
 
     static std::string genIndexName(const BSONObj& keys);
 
-    /** Erase / drop an entire database */
-    virtual bool dropDatabase(const std::string& dbname,
-                              const WriteConcernOptions& writeConcern = WriteConcernOptions(),
-                              BSONObj* info = nullptr) {
-        BSONObj o;
-        if (info == nullptr)
-            info = &o;
-        return runCommand(
-            dbname, BSON("dropDatabase" << 1 << "writeConcern" << writeConcern.toBSON()), *info);
-    }
-
-    virtual std::string toString() const = 0;
-
     /**
-     * Run a pseudo-command such as sys.inprog/currentOp, sys.killop/killOp
-     * or sys.unlock/fsyncUnlock
-     *
-     * The real command will be tried first, and if the remote server does not
-     * implement the command, it will fall back to the pseudoCommand.
-     *
-     * The cmdArgs parameter should NOT include {<commandName>: 1}.
-     *
-     * TODO: remove after MongoDB 3.2 is released and replace all callers with
-     * a call to plain runCommand
+     * 'actualServer' is set to the actual server where they call went if there was a choice (for
+     * example SecondaryOk).
      */
-    virtual bool runPseudoCommand(StringData db,
-                                  StringData realCommandName,
-                                  StringData pseudoCommandCol,
-                                  const BSONObj& cmdArgs,
-                                  BSONObj& info,
-                                  int options = 0);
+    virtual bool call(Message& toSend,
+                      Message& response,
+                      bool assertOk = true,
+                      std::string* actualServer = nullptr) = 0;
+
+    virtual void say(Message& toSend,
+                     bool isRetry = false,
+                     std::string* actualServer = nullptr) = 0;
 
     /**
-     * Reconnect if needed and allowed.
+     * Used by QueryOption_Exhaust. To use that your subclass must implement this.
      */
-    virtual void checkConnection() {}
-
-    static const uint64_t INVALID_SOCK_CREATION_TIME;
-
-    long long getConnectionId() const {
-        return _connectionId;
+    virtual Status recv(Message& m, int lastRequestId) {
+        verify(false);
+        return {ErrorCodes::NotImplemented, "recv() not implemented"};
     }
 
-    virtual int getMinWireVersion() = 0;
-    virtual int getMaxWireVersion() = 0;
+    /**
+     *  Returns a single object that matches the query. if none do, then the object is empty.
+     *  Throws AssertionException.
+     */
+    virtual BSONObj findOne(const std::string& ns,
+                            const Query& query,
+                            const BSONObj* fieldsToReturn = nullptr,
+                            int queryOptions = 0,
+                            boost::optional<BSONObj> readConcernObj = boost::none);
 
-    const std::vector<std::string>& getIsPrimarySaslMechanisms() const {
-        return _saslMechsForAuth;
-    }
+    /**
+     * 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);
 
-    /** send a query to the database.
-     @param ns namespace to query, format is <dbname>.<collectname>[.<collectname>]*
-     @param query query to perform on the collection.  this is a BSONObj (binary JSON)
-     You may format as
-       { query: { ... }, orderby: { ... } }
-     to specify a sort order.
-     @param limit - the maximum number of documents that the cursor should return. 0 = unlimited.
-     @param nToSkip start with the nth item
-     @param fieldsToReturn optional template of which fields to select. if unspecified,
-            returns all fields
-     @param queryOptions see options enum at top of this file
-
-     @return    cursor.   0 if error (connection failure)
-     @throws AssertionException
-    */
-    std::unique_ptr<DBClientCursor> query(
+    /**
+     * Sends a query to the database.
+     *
+     *  'ns': Namespace to query, format is <dbname>.<collectname>[.<collectname>]*
+     *  'query': Query to perform on the collection.
+     *  'limit': The maximum number of documents that the cursor should return. 0 = unlimited.
+     *  'nToSkip': Start with the nth item.
+     *  'fieldsToReturn': Optional template of which fields to select. If unspecified, returns all
+     *                    fields.
+     *  'queryOptions': See options enum at top of this file.
+     *
+     * Returns nullptr if error (connection failure).
+     * Throws AssertionException.
+     */
+    virtual std::unique_ptr<DBClientCursor> query(
         const NamespaceStringOrUUID& nsOrUuid,
         Query query,
         int limit = 0,
@@ -607,22 +562,22 @@ public:
         const BSONObj* fieldsToReturn = nullptr,
         int queryOptions = 0,
         int batchSize = 0,
-        boost::optional<BSONObj> readConcernObj = boost::none) override;
-
-
-    /** Uses QueryOption_Exhaust, when available and specified in 'queryOptions'.
-
-        Exhaust mode sends back all data queries as fast as possible, with no back-and-forth for
-        OP_GET_MORE.  If you are certain you will exhaust the query, it could be useful.  If
-        exhaust mode is not specified in 'queryOptions' or not available, this call transparently
-        falls back to using ordinary getMores.
-
-        Use the DBClientCursorBatchIterator version, below, if you want to do items in large
-        blocks, perhaps to avoid granular locking and such.
+        boost::optional<BSONObj> readConcernObj = boost::none);
 
-        Note:
-        The version that takes a BSONObj cannot return the namespace queried when the query is
-        is done by UUID.  If this is required, use the DBClientBatchIterator version.
+    /**
+     * Uses QueryOption_Exhaust, when available and specified in 'queryOptions'.
+     *
+     * Exhaust mode sends back all data queries as fast as possible, with no back-and-forth for
+     * getMore. If you are certain you will exhaust the query, it could be useful. If exhaust mode
+     * is not specified in 'queryOptions' or not available, this call transparently falls back to
+     * using ordinary getMores.
+     *
+     * Use the DBClientCursorBatchIterator version, below, if you want to do items in large
+     * blocks, perhaps to avoid granular locking and such.
+     *
+     * Note:
+     * The version that takes a BSONObj cannot return the namespace queried when the query is done
+     * by UUID. If this is required, use the DBClientBatchIterator version.
      */
     unsigned long long query(std::function<void(const BSONObj&)> f,
                              const NamespaceStringOrUUID& nsOrUuid,
@@ -630,32 +585,41 @@ public:
                              const BSONObj* fieldsToReturn = nullptr,
                              int queryOptions = QueryOption_Exhaust,
                              int batchSize = 0,
-                             boost::optional<BSONObj> readConcernObj = boost::none) final;
+                             boost::optional<BSONObj> readConcernObj = boost::none);
 
-    unsigned long long query(std::function<void(DBClientCursorBatchIterator&)> f,
-                             const NamespaceStringOrUUID& nsOrUuid,
-                             Query query,
-                             const BSONObj* fieldsToReturn = nullptr,
-                             int queryOptions = QueryOption_Exhaust,
-                             int batchSize = 0,
-                             boost::optional<BSONObj> readConcernObj = boost::none) override;
+    virtual unsigned long long query(std::function<void(DBClientCursorBatchIterator&)> f,
+                                     const NamespaceStringOrUUID& nsOrUuid,
+                                     Query 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.
+     *   'cursorId': Id of cursor to retrieve.
+     *   Returns an handle to a previously allocated cursor.
+     *   Throws AssertionException.
+     */
+    virtual std::unique_ptr<DBClientCursor> getMore(const std::string& ns, long long cursorId);
 
-    /** don't use this - called automatically by DBClientCursor for you
-        @param cursorId id of cursor to retrieve
-        @return an handle to a previously allocated cursor
-        @throws AssertionException
+    /**
+     * Counts number of objects in collection ns that match the query criteria specified.
+     * Throws UserAssertion if database returns an error.
      */
-    virtual std::unique_ptr<DBClientCursor> getMore(const std::string& ns,
-                                                    long long cursorId,
-                                                    int options = 0);
+    virtual long long count(NamespaceStringOrUUID nsOrUuid,
+                            const BSONObj& query = BSONObj(),
+                            int options = 0,
+                            int limit = 0,
+                            int skip = 0,
+                            boost::optional<BSONObj> readConcernObj = boost::none);
 
     /**
      * Executes an acknowledged command to insert a vector of documents.
      */
     virtual BSONObj insertAcknowledged(const std::string& ns,
                                        const std::vector<BSONObj>& v,
-                                       int flags = 0,
+                                       bool ordered = true,
                                        boost::optional<BSONObj> writeConcernObj = boost::none);
 
     /**
@@ -663,7 +627,7 @@ public:
      */
     virtual void insert(const std::string& ns,
                         BSONObj obj,
-                        int flags = 0,
+                        bool ordered = true,
                         boost::optional<BSONObj> writeConcernObj = boost::none);
 
     /**
@@ -671,7 +635,7 @@ public:
      */
     virtual void insert(const std::string& ns,
                         const std::vector<BSONObj>& v,
-                        int flags = 0,
+                        bool ordered = true,
                         boost::optional<BSONObj> writeConcernObj = boost::none);
 
     /**
@@ -694,18 +658,12 @@ public:
                         bool multi = false,
                         boost::optional<BSONObj> writeConcernObj = boost::none);
 
-    virtual void update(const std::string& ns,
-                        Query query,
-                        BSONObj obj,
-                        int flags,
-                        boost::optional<BSONObj> writeConcernObj = boost::none);
-
     /**
      * Executes an acknowledged command to remove the objects that match the query.
      */
     virtual BSONObj removeAcknowledged(const std::string& ns,
                                        Query query,
-                                       int flags = 0,
+                                       bool removeMany = true,
                                        boost::optional<BSONObj> writeConcernObj = boost::none);
 
     /**
@@ -713,56 +671,17 @@ public:
      */
     virtual void remove(const std::string& ns,
                         Query query,
-                        int flags = 0,
+                        bool removeMany = true,
                         boost::optional<BSONObj> writeConcernObj = boost::none);
 
-    virtual bool isFailed() const = 0;
-
-    /**
-     * if not checked recently, checks whether the underlying socket/sockets are still valid
-     */
-    virtual bool isStillConnected() = 0;
-
     virtual void killCursor(const NamespaceString& ns, long long cursorID);
 
-    virtual ConnectionString::ConnectionType type() const = 0;
-
-    virtual double getSoTimeout() const = 0;
-
-    virtual uint64_t getSockCreationMicroSec() const {
-        return INVALID_SOCK_CREATION_TIME;
-    }
-
-    virtual void reset() {}
-
-    virtual bool isReplicaSetMember() const = 0;
-
-    virtual bool isMongos() const = 0;
-
-    virtual bool authenticatedDuringConnect() const {
-        return false;
-    }
-
-    /**
-     * Parses command replies and runs them through the metadata reader.
-     * This is virtual and non-const to allow subclasses to act on failures.
-     */
-    virtual rpc::UniqueReply parseCommandReplyMessage(const std::string& host,
-                                                      const Message& replyMsg);
-
-    /**
-     * Returns the latest operationTime tracked on this client.
-     */
-    Timestamp getOperationTime();
-
-    void setOperationTime(Timestamp operationTime);
-
     // This is only for DBClientCursor.
     static void (*withConnection_do_not_use)(std::string host, std::function<void(DBClientBase*)>);
 
 #ifdef MONGO_CONFIG_SSL
     /**
-     * Get the SSL configuration of this client.
+     * Gets the SSL configuration of this client.
      */
     virtual const SSLConfiguration* getSSLConfiguration() = 0;
 
@@ -786,10 +705,14 @@ public:
     }
 
 protected:
-    /** if the result of a command is ok*/
+    /**
+     * Returns true if the result of a command is ok.
+     */
     bool isOk(const BSONObj&);
 
-    /** if the element contains a not primary error */
+    /**
+     * Returns true if the element contains a not primary error.
+     */
     bool isNotPrimaryErrorString(const BSONElement& e);
 
     BSONObj _countCmd(NamespaceStringOrUUID nsOrUuid,
@@ -800,7 +723,7 @@ protected:
                       boost::optional<BSONObj> readConcernObj);
 
     /**
-     * Look up the options available on this client.  Caches the answer from
+     * Looks up the options available on this client. Caches the answer from
      * _lookupAvailableOptions(), below.
      */
     QueryOptions availableOptions();
@@ -809,10 +732,14 @@ protected:
 
     virtual void _auth(const BSONObj& params);
 
-    // should be set by subclasses during connection.
+    /**
+     * Should be set by subclasses during connection.
+     */
     void _setServerRPCProtocols(rpc::ProtocolSet serverProtocols);
 
-    /** controls how chatty the client is about network errors & such.  See log.h */
+    /**
+     * Controls how chatty the client is about network errors & such. See log.h.
+     */
     const logv2::LogSeverity _logLevel;
 
     static AtomicWord<long long> ConnectionIdSequence;
@@ -830,9 +757,7 @@ private:
 
     auth::RunCommandHook _makeAuthRunCommandHook();
 
-    /**
-     * The rpc protocol the remote server(s) support.
-     */
+    // The rpc protocol the remote server(s) support.
     rpc::ProtocolSet _serverRPCProtocols{rpc::supports::kOpMsgOnly};
 
     rpc::RequestMetadataWriter _metadataWriter;