io.vertx.reactivex.ext.mongo

## Class MongoClient

- java.lang.Object
- - io.vertx.reactivex.ext.mongo.MongoClient

-     public class MongoClient
      extends Object

  A Vert.x service used to interact with MongoDB server instances.

  Some of the operations might change _id field of passed document.

  NOTE: This class has been automatically generated from the `original` non RX-ified interface using Vert.x codegen.

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static io.vertx.lang.rx.TypeArg<MongoClient>` | `__TYPE_ARG`
    `static String` | `DEFAULT_DB_NAME` The name of the default database
    `static String` | `DEFAULT_POOL_NAME` The name of the default pool

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `MongoClient(MongoClient delegate)`
    `MongoClient(Object delegate)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `ReadStream<JsonObject>` | `aggregate(String collection, JsonArray pipeline)` Run aggregate MongoDB command with default `AggregateOptions`.
    `ReadStream<JsonObject>` | `aggregateWithOptions(String collection, JsonArray pipeline, AggregateOptions options)` Run aggregate MongoDB command.
    `MongoClient` | `bulkWrite(String collection, List<BulkOperation> operations)` Execute a bulk operation.
    `MongoClient` | `bulkWrite(String collection, List<BulkOperation> operations, Handler<AsyncResult<MongoClientBulkWriteResult>> resultHandler)` Execute a bulk operation.
    `MongoClient` | `bulkWriteWithOptions(String collection, List<BulkOperation> operations, BulkWriteOptions bulkWriteOptions)` Execute a bulk operation with the specified write options.
    `MongoClient` | `bulkWriteWithOptions(String collection, List<BulkOperation> operations, BulkWriteOptions bulkWriteOptions, Handler<AsyncResult<MongoClientBulkWriteResult>> resultHandler)` Execute a bulk operation with the specified write options.
    `void` | `close()` Close the client and release its resources
    `void` | `close(Handler<AsyncResult<Void>> handler)` Close the client and release its resources
    `MongoClient` | `count(String collection, JsonObject query)` Count matching documents in a collection.
    `MongoClient` | `count(String collection, JsonObject query, Handler<AsyncResult<Long>> resultHandler)` Count matching documents in a collection.
    `MongoClient` | `countWithOptions(String collection, JsonObject query, CountOptions countOptions)` Count matching documents in a collection.
    `MongoClient` | `countWithOptions(String collection, JsonObject query, CountOptions countOptions, Handler<AsyncResult<Long>> resultHandler)` Count matching documents in a collection.
    `static MongoClient` | `create(Vertx vertx, JsonObject config)` Create a Mongo client which maintains its own data source.
    `MongoClient` | `createCollection(String collectionName)` Create a new collection
    `MongoClient` | `createCollection(String collectionName, Handler<AsyncResult<Void>> resultHandler)` Create a new collection
    `MongoClient` | `createCollectionWithOptions(String collectionName, CreateCollectionOptions collectionOptions)` Create a new collection with options
    `MongoClient` | `createCollectionWithOptions(String collectionName, CreateCollectionOptions collectionOptions, Handler<AsyncResult<Void>> resultHandler)` Create a new collection with options
    `MongoClient` | `createDefaultGridFsBucketService()` Creates a `MongoGridFsClient` used to interact with Mongo GridFS.
    `MongoClient` | `createDefaultGridFsBucketService(Handler<AsyncResult<MongoGridFsClient>> resultHandler)` Creates a `MongoGridFsClient` used to interact with Mongo GridFS.
    `MongoClient` | `createGridFsBucketService(String bucketName)` Creates a `MongoGridFsClient` used to interact with Mongo GridFS.
    `MongoClient` | `createGridFsBucketService(String bucketName, Handler<AsyncResult<MongoGridFsClient>> resultHandler)` Creates a `MongoGridFsClient` used to interact with Mongo GridFS.
    `MongoClient` | `createIndex(String collection, JsonObject key)` Creates an index.
    `MongoClient` | `createIndex(String collection, JsonObject key, Handler<AsyncResult<Void>> resultHandler)` Creates an index.
    `MongoClient` | `createIndexes(String collection, List<IndexModel> indexes)` creates an indexes
    `MongoClient` | `createIndexes(String collection, List<IndexModel> indexes, Handler<AsyncResult<Void>> resultHandler)` creates an indexes
    `MongoClient` | `createIndexWithOptions(String collection, JsonObject key, IndexOptions options)` Creates an index.
    `MongoClient` | `createIndexWithOptions(String collection, JsonObject key, IndexOptions options, Handler<AsyncResult<Void>> resultHandler)` Creates an index.
    `static MongoClient` | `createShared(Vertx vertx, JsonObject config)` Like `createShared(io.vertx.reactivex.core.Vertx, io.vertx.core.json.JsonObject, java.lang.String)` but with the default data source name
    `static MongoClient` | `createShared(Vertx vertx, JsonObject config, String dataSourceName)` Create a Mongo client which shares its data source with any other Mongo clients created with the same data source name
    `MongoClient` | `distinct(String collection, String fieldName, String resultClassname)` Gets the distinct values of the specified field name.
    `MongoClient` | `distinct(String collection, String fieldName, String resultClassname, DistinctOptions distinctOptions)` Gets the distinct values of the specified field name.
    `MongoClient` | `distinct(String collection, String fieldName, String resultClassname, DistinctOptions distinctOptions, Handler<AsyncResult<JsonArray>> resultHandler)` Gets the distinct values of the specified field name.
    `MongoClient` | `distinct(String collection, String fieldName, String resultClassname, Handler<AsyncResult<JsonArray>> resultHandler)` Gets the distinct values of the specified field name.
    `ReadStream<JsonObject>` | `distinctBatch(String collection, String fieldName, String resultClassname)` Gets the distinct values of the specified field name.
    `ReadStream<JsonObject>` | `distinctBatch(String collection, String fieldName, String resultClassname, DistinctOptions distinctOptions)` Gets the distinct values of the specified field name.
    `ReadStream<JsonObject>` | `distinctBatchWithQuery(String collection, String fieldName, String resultClassname, JsonObject query)` Gets the distinct values of the specified field name filtered by specified query.
    `ReadStream<JsonObject>` | `distinctBatchWithQuery(String collection, String fieldName, String resultClassname, JsonObject query, DistinctOptions distinctOptions)` Gets the distinct values of the specified field name filtered by specified query.
    `ReadStream<JsonObject>` | `distinctBatchWithQuery(String collection, String fieldName, String resultClassname, JsonObject query, int batchSize)` Gets the distinct values of the specified field name filtered by specified query.
    `ReadStream<JsonObject>` | `distinctBatchWithQuery(String collection, String fieldName, String resultClassname, JsonObject query, int batchSize, DistinctOptions distinctOptions)` Gets the distinct values of the specified field name filtered by specified query.
    `MongoClient` | `distinctWithQuery(String collection, String fieldName, String resultClassname, JsonObject query)` Gets the distinct values of the specified field name filtered by specified query.
    `MongoClient` | `distinctWithQuery(String collection, String fieldName, String resultClassname, JsonObject query, DistinctOptions distinctOptions)` Gets the distinct values of the specified field name filtered by specified query.
    `MongoClient` | `distinctWithQuery(String collection, String fieldName, String resultClassname, JsonObject query, DistinctOptions distinctOptions, Handler<AsyncResult<JsonArray>> resultHandler)` Gets the distinct values of the specified field name filtered by specified query.
    `MongoClient` | `distinctWithQuery(String collection, String fieldName, String resultClassname, JsonObject query, Handler<AsyncResult<JsonArray>> resultHandler)` Gets the distinct values of the specified field name filtered by specified query.
    `MongoClient` | `dropCollection(String collection)` Drop a collection
    `MongoClient` | `dropCollection(String collection, Handler<AsyncResult<Void>> resultHandler)` Drop a collection
    `MongoClient` | `dropIndex(String collection, String indexName)` Drops the index given its name.
    `MongoClient` | `dropIndex(String collection, String indexName, Handler<AsyncResult<Void>> resultHandler)` Drops the index given its name.
    `boolean` | `equals(Object o)`
    `MongoClient` | `find(String collection, JsonObject query)` Find matching documents in the specified collection
    `MongoClient` | `find(String collection, JsonObject query, Handler<AsyncResult<List<JsonObject>>> resultHandler)` Find matching documents in the specified collection
    `ReadStream<JsonObject>` | `findBatch(String collection, JsonObject query)` Find matching documents in the specified collection.
    `ReadStream<JsonObject>` | `findBatchWithOptions(String collection, JsonObject query, FindOptions options)` Find matching documents in the specified collection, specifying options.
    `MongoClient` | `findOne(String collection, JsonObject query, JsonObject fields)` Find a single matching document in the specified collection
    `MongoClient` | `findOne(String collection, JsonObject query, JsonObject fields, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection
    `MongoClient` | `findOneAndDelete(String collection, JsonObject query)` Find a single matching document in the specified collection and delete it.
    `MongoClient` | `findOneAndDelete(String collection, JsonObject query, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and delete it.
    `MongoClient` | `findOneAndDeleteWithOptions(String collection, JsonObject query, FindOptions findOptions)` Find a single matching document in the specified collection and delete it.
    `MongoClient` | `findOneAndDeleteWithOptions(String collection, JsonObject query, FindOptions findOptions, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and delete it.
    `MongoClient` | `findOneAndReplace(String collection, JsonObject query, JsonObject replace)` Find a single matching document in the specified collection and replace it.
    `MongoClient` | `findOneAndReplace(String collection, JsonObject query, JsonObject replace, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and replace it.
    `MongoClient` | `findOneAndReplaceWithOptions(String collection, JsonObject query, JsonObject replace, FindOptions findOptions, UpdateOptions updateOptions)` Find a single matching document in the specified collection and replace it.
    `MongoClient` | `findOneAndReplaceWithOptions(String collection, JsonObject query, JsonObject replace, FindOptions findOptions, UpdateOptions updateOptions, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and replace it.
    `MongoClient` | `findOneAndUpdate(String collection, JsonObject query, JsonObject update)` Find a single matching document in the specified collection and update it.
    `MongoClient` | `findOneAndUpdate(String collection, JsonObject query, JsonObject update, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and update it.
    `MongoClient` | `findOneAndUpdateWithOptions(String collection, JsonObject query, JsonObject update, FindOptions findOptions, UpdateOptions updateOptions)` Find a single matching document in the specified collection and update it.
    `MongoClient` | `findOneAndUpdateWithOptions(String collection, JsonObject query, JsonObject update, FindOptions findOptions, UpdateOptions updateOptions, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and update it.
    `MongoClient` | `findWithOptions(String collection, JsonObject query, FindOptions options)` Find matching documents in the specified collection, specifying options
    `MongoClient` | `findWithOptions(String collection, JsonObject query, FindOptions options, Handler<AsyncResult<List<JsonObject>>> resultHandler)` Find matching documents in the specified collection, specifying options
    `MongoClient` | `getCollections()` Get a list of all collections in the database.
    `MongoClient` | `getCollections(Handler<AsyncResult<List<String>>> resultHandler)` Get a list of all collections in the database.
    `MongoClient` | `getDelegate()`
    `int` | `hashCode()`
    `MongoClient` | `insert(String collection, JsonObject document)` Insert a document in the specified collection
    `MongoClient` | `insert(String collection, JsonObject document, Handler<AsyncResult<String>> resultHandler)` Insert a document in the specified collection
    `MongoClient` | `insertWithOptions(String collection, JsonObject document, WriteOption writeOption)` Insert a document in the specified collection with the specified write option
    `MongoClient` | `insertWithOptions(String collection, JsonObject document, WriteOption writeOption, Handler<AsyncResult<String>> resultHandler)` Insert a document in the specified collection with the specified write option
    `MongoClient` | `listIndexes(String collection)` Get all the indexes in this collection.
    `MongoClient` | `listIndexes(String collection, Handler<AsyncResult<JsonArray>> resultHandler)` Get all the indexes in this collection.
    `static MongoClient` | `newInstance(MongoClient arg)`
    `MongoClient` | `removeDocument(String collection, JsonObject query)` Remove a single matching document from a collection and return the handler with `MongoClientDeleteResult` result
    `MongoClient` | `removeDocument(String collection, JsonObject query, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)` Remove a single matching document from a collection and return the handler with `MongoClientDeleteResult` result
    `MongoClient` | `removeDocuments(String collection, JsonObject query)` Remove matching documents from a collection and return the handler with `MongoClientDeleteResult` result
    `MongoClient` | `removeDocuments(String collection, JsonObject query, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)` Remove matching documents from a collection and return the handler with `MongoClientDeleteResult` result
    `MongoClient` | `removeDocumentsWithOptions(String collection, JsonObject query, WriteOption writeOption)` Remove matching documents from a collection with the specified write option and return the handler with `MongoClientDeleteResult` result
    `MongoClient` | `removeDocumentsWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)` Remove matching documents from a collection with the specified write option and return the handler with `MongoClientDeleteResult` result
    `MongoClient` | `removeDocumentWithOptions(String collection, JsonObject query, WriteOption writeOption)` Remove a single matching document from a collection with the specified write option and return the handler with `MongoClientDeleteResult` result
    `MongoClient` | `removeDocumentWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)` Remove a single matching document from a collection with the specified write option and return the handler with `MongoClientDeleteResult` result
    `MongoClient` | `replaceDocuments(String collection, JsonObject query, JsonObject replace)` Replace matching documents in the specified collection and return the handler with `MongoClientUpdateResult` result
    `MongoClient` | `replaceDocuments(String collection, JsonObject query, JsonObject replace, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Replace matching documents in the specified collection and return the handler with `MongoClientUpdateResult` result
    `MongoClient` | `replaceDocumentsWithOptions(String collection, JsonObject query, JsonObject replace, UpdateOptions options)` Replace matching documents in the specified collection, specifying options and return the handler with `MongoClientUpdateResult` result
    `MongoClient` | `replaceDocumentsWithOptions(String collection, JsonObject query, JsonObject replace, UpdateOptions options, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Replace matching documents in the specified collection, specifying options and return the handler with `MongoClientUpdateResult` result
    `MongoClient` | `runCommand(String commandName, JsonObject command)` Run an arbitrary MongoDB command.
    `MongoClient` | `runCommand(String commandName, JsonObject command, Handler<AsyncResult<JsonObject>> resultHandler)` Run an arbitrary MongoDB command.
    `Maybe<MongoClientBulkWriteResult>` | `rxBulkWrite(String collection, List<BulkOperation> operations)` Execute a bulk operation.
    `Maybe<MongoClientBulkWriteResult>` | `rxBulkWriteWithOptions(String collection, List<BulkOperation> operations, BulkWriteOptions bulkWriteOptions)` Execute a bulk operation with the specified write options.
    `Completable` | `rxClose()` Close the client and release its resources
    `Single<Long>` | `rxCount(String collection, JsonObject query)` Count matching documents in a collection.
    `Single<Long>` | `rxCountWithOptions(String collection, JsonObject query, CountOptions countOptions)` Count matching documents in a collection.
    `Completable` | `rxCreateCollection(String collectionName)` Create a new collection
    `Completable` | `rxCreateCollectionWithOptions(String collectionName, CreateCollectionOptions collectionOptions)` Create a new collection with options
    `Single<MongoGridFsClient>` | `rxCreateDefaultGridFsBucketService()` Creates a `MongoGridFsClient` used to interact with Mongo GridFS.
    `Single<MongoGridFsClient>` | `rxCreateGridFsBucketService(String bucketName)` Creates a `MongoGridFsClient` used to interact with Mongo GridFS.
    `Completable` | `rxCreateIndex(String collection, JsonObject key)` Creates an index.
    `Completable` | `rxCreateIndexes(String collection, List<IndexModel> indexes)` creates an indexes
    `Completable` | `rxCreateIndexWithOptions(String collection, JsonObject key, IndexOptions options)` Creates an index.
    `Single<JsonArray>` | `rxDistinct(String collection, String fieldName, String resultClassname)` Gets the distinct values of the specified field name.
    `Single<JsonArray>` | `rxDistinct(String collection, String fieldName, String resultClassname, DistinctOptions distinctOptions)` Gets the distinct values of the specified field name.
    `Single<JsonArray>` | `rxDistinctWithQuery(String collection, String fieldName, String resultClassname, JsonObject query)` Gets the distinct values of the specified field name filtered by specified query.
    `Single<JsonArray>` | `rxDistinctWithQuery(String collection, String fieldName, String resultClassname, JsonObject query, DistinctOptions distinctOptions)` Gets the distinct values of the specified field name filtered by specified query.
    `Completable` | `rxDropCollection(String collection)` Drop a collection
    `Completable` | `rxDropIndex(String collection, String indexName)` Drops the index given its name.
    `Single<List<JsonObject>>` | `rxFind(String collection, JsonObject query)` Find matching documents in the specified collection
    `Maybe<JsonObject>` | `rxFindOne(String collection, JsonObject query, JsonObject fields)` Find a single matching document in the specified collection
    `Maybe<JsonObject>` | `rxFindOneAndDelete(String collection, JsonObject query)` Find a single matching document in the specified collection and delete it.
    `Maybe<JsonObject>` | `rxFindOneAndDeleteWithOptions(String collection, JsonObject query, FindOptions findOptions)` Find a single matching document in the specified collection and delete it.
    `Maybe<JsonObject>` | `rxFindOneAndReplace(String collection, JsonObject query, JsonObject replace)` Find a single matching document in the specified collection and replace it.
    `Maybe<JsonObject>` | `rxFindOneAndReplaceWithOptions(String collection, JsonObject query, JsonObject replace, FindOptions findOptions, UpdateOptions updateOptions)` Find a single matching document in the specified collection and replace it.
    `Maybe<JsonObject>` | `rxFindOneAndUpdate(String collection, JsonObject query, JsonObject update)` Find a single matching document in the specified collection and update it.
    `Maybe<JsonObject>` | `rxFindOneAndUpdateWithOptions(String collection, JsonObject query, JsonObject update, FindOptions findOptions, UpdateOptions updateOptions)` Find a single matching document in the specified collection and update it.
    `Single<List<JsonObject>>` | `rxFindWithOptions(String collection, JsonObject query, FindOptions options)` Find matching documents in the specified collection, specifying options
    `Single<List<String>>` | `rxGetCollections()` Get a list of all collections in the database.
    `Maybe<String>` | `rxInsert(String collection, JsonObject document)` Insert a document in the specified collection
    `Maybe<String>` | `rxInsertWithOptions(String collection, JsonObject document, WriteOption writeOption)` Insert a document in the specified collection with the specified write option
    `Single<JsonArray>` | `rxListIndexes(String collection)` Get all the indexes in this collection.
    `Maybe<MongoClientDeleteResult>` | `rxRemoveDocument(String collection, JsonObject query)` Remove a single matching document from a collection and return the handler with `MongoClientDeleteResult` result
    `Maybe<MongoClientDeleteResult>` | `rxRemoveDocuments(String collection, JsonObject query)` Remove matching documents from a collection and return the handler with `MongoClientDeleteResult` result
    `Maybe<MongoClientDeleteResult>` | `rxRemoveDocumentsWithOptions(String collection, JsonObject query, WriteOption writeOption)` Remove matching documents from a collection with the specified write option and return the handler with `MongoClientDeleteResult` result
    `Maybe<MongoClientDeleteResult>` | `rxRemoveDocumentWithOptions(String collection, JsonObject query, WriteOption writeOption)` Remove a single matching document from a collection with the specified write option and return the handler with `MongoClientDeleteResult` result
    `Maybe<MongoClientUpdateResult>` | `rxReplaceDocuments(String collection, JsonObject query, JsonObject replace)` Replace matching documents in the specified collection and return the handler with `MongoClientUpdateResult` result
    `Maybe<MongoClientUpdateResult>` | `rxReplaceDocumentsWithOptions(String collection, JsonObject query, JsonObject replace, UpdateOptions options)` Replace matching documents in the specified collection, specifying options and return the handler with `MongoClientUpdateResult` result
    `Maybe<JsonObject>` | `rxRunCommand(String commandName, JsonObject command)` Run an arbitrary MongoDB command.
    `Maybe<String>` | `rxSave(String collection, JsonObject document)` Save a document in the specified collection
    `Maybe<String>` | `rxSaveWithOptions(String collection, JsonObject document, WriteOption writeOption)` Save a document in the specified collection with the specified write option
    `Maybe<MongoClientUpdateResult>` | `rxUpdateCollection(String collection, JsonObject query, JsonArray update)` Use an aggregation pipeline to update documents in the specified collection and return the handler with `MongoClientUpdateResult` result
    `Maybe<MongoClientUpdateResult>` | `rxUpdateCollection(String collection, JsonObject query, JsonObject update)` Update matching documents in the specified collection and return the handler with `MongoClientUpdateResult` result
    `Maybe<MongoClientUpdateResult>` | `rxUpdateCollectionWithOptions(String collection, JsonObject query, JsonArray update, UpdateOptions options)` Use an aggregation pipeline to update documents in the specified collection, specifying options and return the handler with `MongoClientUpdateResult` result
    `Maybe<MongoClientUpdateResult>` | `rxUpdateCollectionWithOptions(String collection, JsonObject query, JsonObject update, UpdateOptions options)` Update matching documents in the specified collection, specifying options and return the handler with `MongoClientUpdateResult` result
    `MongoClient` | `save(String collection, JsonObject document)` Save a document in the specified collection
    `MongoClient` | `save(String collection, JsonObject document, Handler<AsyncResult<String>> resultHandler)` Save a document in the specified collection
    `MongoClient` | `saveWithOptions(String collection, JsonObject document, WriteOption writeOption)` Save a document in the specified collection with the specified write option
    `MongoClient` | `saveWithOptions(String collection, JsonObject document, WriteOption writeOption, Handler<AsyncResult<String>> resultHandler)` Save a document in the specified collection with the specified write option
    `String` | `toString()`
    `MongoClient` | `updateCollection(String collection, JsonObject query, JsonArray update)` Use an aggregation pipeline to update documents in the specified collection and return the handler with `MongoClientUpdateResult` result
    `MongoClient` | `updateCollection(String collection, JsonObject query, JsonArray update, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Use an aggregation pipeline to update documents in the specified collection and return the handler with `MongoClientUpdateResult` result
    `MongoClient` | `updateCollection(String collection, JsonObject query, JsonObject update)` Update matching documents in the specified collection and return the handler with `MongoClientUpdateResult` result
    `MongoClient` | `updateCollection(String collection, JsonObject query, JsonObject update, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Update matching documents in the specified collection and return the handler with `MongoClientUpdateResult` result
    `MongoClient` | `updateCollectionWithOptions(String collection, JsonObject query, JsonArray update, UpdateOptions options)` Use an aggregation pipeline to update documents in the specified collection, specifying options and return the handler with `MongoClientUpdateResult` result
    `MongoClient` | `updateCollectionWithOptions(String collection, JsonObject query, JsonArray update, UpdateOptions options, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Use an aggregation pipeline to update documents in the specified collection, specifying options and return the handler with `MongoClientUpdateResult` result
    `MongoClient` | `updateCollectionWithOptions(String collection, JsonObject query, JsonObject update, UpdateOptions options)` Update matching documents in the specified collection, specifying options and return the handler with `MongoClientUpdateResult` result
    `MongoClient` | `updateCollectionWithOptions(String collection, JsonObject query, JsonObject update, UpdateOptions options, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Update matching documents in the specified collection, specifying options and return the handler with `MongoClientUpdateResult` result
    `ReadStream<com.mongodb.client.model.changestream.ChangeStreamDocument<JsonObject>>` | `watch(String collection, JsonArray pipeline, boolean withUpdatedDoc, int batchSize)` Watch the collection change.

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

- - ### Field Detail

    - #### __TYPE_ARG

          public static final io.vertx.lang.rx.TypeArg<MongoClient> __TYPE_ARG

    - #### DEFAULT_POOL_NAME

          public static final String DEFAULT_POOL_NAME

      The name of the default pool
      See Also:
        Constant Field Values

    - #### DEFAULT_DB_NAME

          public static final String DEFAULT_DB_NAME

      The name of the default database
      See Also:
        Constant Field Values

  - ### Constructor Detail

    - #### MongoClient

          public MongoClient(MongoClient delegate)

    - #### MongoClient

          public MongoClient(Object delegate)

  - ### Method Detail

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`

    - #### equals

          public boolean equals(Object o)

      Overrides:
        `equals` in class `Object`

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `Object`

    - #### getDelegate

          public MongoClient getDelegate()

    - #### create

          public static MongoClient create(Vertx vertx,
                                           JsonObject config)

      Create a Mongo client which maintains its own data source.
      Parameters:
        `vertx` - the Vert.x instance
        `config` - the configuration
      Returns:
        the client

    - #### createShared

          public static MongoClient createShared(Vertx vertx,
                                                 JsonObject config,
                                                 String dataSourceName)

      Create a Mongo client which shares its data source with any other Mongo clients created with the same data source name
      Parameters:
        `vertx` - the Vert.x instance
        `config` - the configuration
        `dataSourceName` - the data source name
      Returns:
        the client

    - #### createShared

          public static MongoClient createShared(Vertx vertx,
                                                 JsonObject config)

      Like `createShared(io.vertx.reactivex.core.Vertx, io.vertx.core.json.JsonObject, java.lang.String)` but with the default data source name
      Parameters:
        `vertx` - the Vert.x instance
        `config` - the configuration
      Returns:
        the client

    - #### save

          public MongoClient save(String collection,
                                  JsonObject document,
                                  Handler<AsyncResult<String>> resultHandler)

      Save a document in the specified collection

      This operation might change _id field of document parameter

      Parameters:
        `collection` - the collection
        `document` - the document
        `resultHandler` - result handler will be provided with the id if document didn't already have one
      Returns:

    - #### save

          public MongoClient save(String collection,
                                  JsonObject document)

      Save a document in the specified collection

      This operation might change _id field of document parameter

      Parameters:
        `collection` - the collection
        `document` - the document
      Returns:

    - #### rxSave

          public Maybe<String> rxSave(String collection,
                                      JsonObject document)

      Save a document in the specified collection

      This operation might change _id field of document parameter

      Parameters:
        `collection` - the collection
        `document` - the document
      Returns:

    - #### saveWithOptions

          public MongoClient saveWithOptions(String collection,
                                             JsonObject document,
                                             WriteOption writeOption,
                                             Handler<AsyncResult<String>> resultHandler)

      Save a document in the specified collection with the specified write option

      This operation might change _id field of document parameter

      Parameters:
        `collection` - the collection
        `document` - the document
        `writeOption` - the write option to use
        `resultHandler` - result handler will be provided with the id if document didn't already have one
      Returns:

    - #### saveWithOptions

          public MongoClient saveWithOptions(String collection,
                                             JsonObject document,
                                             WriteOption writeOption)

      Save a document in the specified collection with the specified write option

      This operation might change _id field of document parameter

      Parameters:
        `collection` - the collection
        `document` - the document
        `writeOption` - the write option to use
      Returns:

    - #### rxSaveWithOptions

          public Maybe<String> rxSaveWithOptions(String collection,
                                                 JsonObject document,
                                                 WriteOption writeOption)

      Save a document in the specified collection with the specified write option

      This operation might change _id field of document parameter

      Parameters:
        `collection` - the collection
        `document` - the document
        `writeOption` - the write option to use
      Returns:

    - #### insert

          public MongoClient insert(String collection,
                                    JsonObject document,
                                    Handler<AsyncResult<String>> resultHandler)

      Insert a document in the specified collection

      This operation might change _id field of document parameter

      Parameters:
        `collection` - the collection
        `document` - the document
        `resultHandler` - result handler will be provided with the id if document didn't already have one
      Returns:

    - #### insert

          public MongoClient insert(String collection,
                                    JsonObject document)

      Insert a document in the specified collection

      This operation might change _id field of document parameter

      Parameters:
        `collection` - the collection
        `document` - the document
      Returns:

    - #### rxInsert

          public Maybe<String> rxInsert(String collection,
                                        JsonObject document)

      Insert a document in the specified collection

      This operation might change _id field of document parameter

      Parameters:
        `collection` - the collection
        `document` - the document
      Returns:

    - #### insertWithOptions

          public MongoClient insertWithOptions(String collection,
                                               JsonObject document,
                                               WriteOption writeOption,
                                               Handler<AsyncResult<String>> resultHandler)

      Insert a document in the specified collection with the specified write option

      This operation might change _id field of document parameter

      Parameters:
        `collection` - the collection
        `document` - the document
        `writeOption` - the write option to use
        `resultHandler` - result handler will be provided with the id if document didn't already have one
      Returns:

    - #### insertWithOptions

          public MongoClient insertWithOptions(String collection,
                                               JsonObject document,
                                               WriteOption writeOption)

      Insert a document in the specified collection with the specified write option

      This operation might change _id field of document parameter

      Parameters:
        `collection` - the collection
        `document` - the document
        `writeOption` - the write option to use
      Returns:

    - #### rxInsertWithOptions

          public Maybe<String> rxInsertWithOptions(String collection,
                                                   JsonObject document,
                                                   WriteOption writeOption)

      Insert a document in the specified collection with the specified write option

      This operation might change _id field of document parameter

      Parameters:
        `collection` - the collection
        `document` - the document
        `writeOption` - the write option to use
      Returns:

    - #### updateCollection

          public MongoClient updateCollection(String collection,
                                              JsonObject query,
                                              JsonObject update,
                                              Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)

      Update matching documents in the specified collection and return the handler with `MongoClientUpdateResult` result
      Parameters:
        `collection` - the collection
        `query` - query used to match the documents
        `update` - used to describe how the documents will be updated
        `resultHandler` - will be called with a `MongoClientUpdateResult` when complete
      Returns:

    - #### updateCollection

          public MongoClient updateCollection(String collection,
                                              JsonObject query,
                                              JsonObject update)

      Update matching documents in the specified collection and return the handler with `MongoClientUpdateResult` result
      Parameters:
        `collection` - the collection
        `query` - query used to match the documents
        `update` - used to describe how the documents will be updated
      Returns:

    - #### rxUpdateCollection

          public Maybe<MongoClientUpdateResult> rxUpdateCollection(String collection,
                                                                   JsonObject query,
                                                                   JsonObject update)

      Update matching documents in the specified collection and return the handler with `MongoClientUpdateResult` result
      Parameters:
        `collection` - the collection
        `query` - query used to match the documents
        `update` - used to describe how the documents will be updated
      Returns:

    - #### updateCollection

          public MongoClient updateCollection(String collection,
                                              JsonObject query,
                                              JsonArray update,
                                              Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)

      Use an aggregation pipeline to update documents in the specified collection and return the handler with `MongoClientUpdateResult` result
      Parameters:
        `collection` - the collection
        `query` - query used to match the documents
        `update` - used to describe how the documents will be updated
        `resultHandler` - will be called with a `MongoClientUpdateResult` when complete
      Returns:

    - #### updateCollection

          public MongoClient updateCollection(String collection,
                                              JsonObject query,
                                              JsonArray update)

      Use an aggregation pipeline to update documents in the specified collection and return the handler with `MongoClientUpdateResult` result
      Parameters:
        `collection` - the collection
        `query` - query used to match the documents
        `update` - used to describe how the documents will be updated
      Returns:

    - #### rxUpdateCollection

          public Maybe<MongoClientUpdateResult> rxUpdateCollection(String collection,
                                                                   JsonObject query,
                                                                   JsonArray update)

      Use an aggregation pipeline to update documents in the specified collection and return the handler with `MongoClientUpdateResult` result
      Parameters:
        `collection` - the collection
        `query` - query used to match the documents
        `update` - used to describe how the documents will be updated
      Returns:

    - #### updateCollectionWithOptions

          public MongoClient updateCollectionWithOptions(String collection,
                                                         JsonObject query,
                                                         JsonObject update,
                                                         UpdateOptions options,
                                                         Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)

      Update matching documents in the specified collection, specifying options and return the handler with `MongoClientUpdateResult` result
      Parameters:
        `collection` - the collection
        `query` - query used to match the documents
        `update` - used to describe how the documents will be updated
        `options` - options to configure the update
        `resultHandler` - will be called with a `MongoClientUpdateResult` when complete
      Returns:

    - #### updateCollectionWithOptions

          public MongoClient updateCollectionWithOptions(String collection,
                                                         JsonObject query,
                                                         JsonObject update,
                                                         UpdateOptions options)

      Update matching documents in the specified collection, specifying options and return the handler with `MongoClientUpdateResult` result
      Parameters:
        `collection` - the collection
        `query` - query used to match the documents
        `update` - used to describe how the documents will be updated
        `options` - options to configure the update
      Returns:

    - #### rxUpdateCollectionWithOptions

          public Maybe<MongoClientUpdateResult> rxUpdateCollectionWithOptions(String collection,
                                                                              JsonObject query,
                                                                              JsonObject update,
                                                                              UpdateOptions options)

      Update matching documents in the specified collection, specifying options and return the handler with `MongoClientUpdateResult` result
      Parameters:
        `collection` - the collection
        `query` - query used to match the documents
        `update` - used to describe how the documents will be updated
        `options` - options to configure the update
      Returns:

    - #### updateCollectionWithOptions

          public MongoClient updateCollectionWithOptions(String collection,
                                                         JsonObject query,
                                                         JsonArray update,
                                                         UpdateOptions options,
                                                         Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)

      Use an aggregation pipeline to update documents in the specified collection, specifying options and return the handler with `MongoClientUpdateResult` result
      Parameters:
        `collection` - the collection
        `query` - query used to match the documents
        `update` - aggregation pipeline used to describe how documents will be updated
        `options` - options to configure the update
        `resultHandler` - will be called with a `MongoClientUpdateResult` when complete
      Returns:

    - #### updateCollectionWithOptions

          public MongoClient updateCollectionWithOptions(String collection,
                                                         JsonObject query,
                                                         JsonArray update,
                                                         UpdateOptions options)

      Use an aggregation pipeline to update documents in the specified collection, specifying options and return the handler with `MongoClientUpdateResult` result
      Parameters:
        `collection` - the collection
        `query` - query used to match the documents
        `update` - aggregation pipeline used to describe how documents will be updated
        `options` - options to configure the update
      Returns:

    - #### rxUpdateCollectionWithOptions

          public Maybe<MongoClientUpdateResult> rxUpdateCollectionWithOptions(String collection,
                                                                              JsonObject query,
                                                                              JsonArray update,
                                                                              UpdateOptions options)

      Use an aggregation pipeline to update documents in the specified collection, specifying options and return the handler with `MongoClientUpdateResult` result
      Parameters:
        `collection` - the collection
        `query` - query used to match the documents
        `update` - aggregation pipeline used to describe how documents will be updated
        `options` - options to configure the update
      Returns:

    - #### replaceDocuments

          public MongoClient replaceDocuments(String collection,
                                              JsonObject query,
                                              JsonObject replace,
                                              Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)

      Replace matching documents in the specified collection and return the handler with `MongoClientUpdateResult` result
      Parameters:
        `collection` - the collection
        `query` - query used to match the documents
        `replace` - all matching documents will be replaced with this
        `resultHandler` - will be called with a `MongoClientUpdateResult` when complete
      Returns:

    - #### replaceDocuments

          public MongoClient replaceDocuments(String collection,
                                              JsonObject query,
                                              JsonObject replace)

      Replace matching documents in the specified collection and return the handler with `MongoClientUpdateResult` result
      Parameters:
        `collection` - the collection
        `query` - query used to match the documents
        `replace` - all matching documents will be replaced with this
      Returns:

    - #### rxReplaceDocuments

          public Maybe<MongoClientUpdateResult> rxReplaceDocuments(String collection,
                                                                   JsonObject query,
                                                                   JsonObject replace)

      Replace matching documents in the specified collection and return the handler with `MongoClientUpdateResult` result
      Parameters:
        `collection` - the collection
        `query` - query used to match the documents
        `replace` - all matching documents will be replaced with this
      Returns:

    - #### replaceDocumentsWithOptions

          public MongoClient replaceDocumentsWithOptions(String collection,
                                                         JsonObject query,
                                                         JsonObject replace,
                                                         UpdateOptions options,
                                                         Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)

      Replace matching documents in the specified collection, specifying options and return the handler with `MongoClientUpdateResult` result
      Parameters:
        `collection` - the collection
        `query` - query used to match the documents
        `replace` - all matching documents will be replaced with this
        `options` - options to configure the replace
        `resultHandler` - will be called with a `MongoClientUpdateResult` when complete
      Returns:

    - #### replaceDocumentsWithOptions

          public MongoClient replaceDocumentsWithOptions(String collection,
                                                         JsonObject query,
                                                         JsonObject replace,
                                                         UpdateOptions options)

      Replace matching documents in the specified collection, specifying options and return the handler with `MongoClientUpdateResult` result
      Parameters:
        `collection` - the collection
        `query` - query used to match the documents
        `replace` - all matching documents will be replaced with this
        `options` - options to configure the replace
      Returns:

    - #### rxReplaceDocumentsWithOptions

          public Maybe<MongoClientUpdateResult> rxReplaceDocumentsWithOptions(String collection,
                                                                              JsonObject query,
                                                                              JsonObject replace,
                                                                              UpdateOptions options)

      Replace matching documents in the specified collection, specifying options and return the handler with `MongoClientUpdateResult` result
      Parameters:
        `collection` - the collection
        `query` - query used to match the documents
        `replace` - all matching documents will be replaced with this
        `options` - options to configure the replace
      Returns:

    - #### bulkWrite

          public MongoClient bulkWrite(String collection,
                                       List<BulkOperation> operations,
                                       Handler<AsyncResult<MongoClientBulkWriteResult>> resultHandler)

      Execute a bulk operation. Can insert, update, replace, and/or delete multiple documents with one request.
      Parameters:
        `collection` - the collection
        `operations` - the operations to execute
        `resultHandler` - will be called with a `MongoClientBulkWriteResult` when complete
      Returns:

    - #### bulkWrite

          public MongoClient bulkWrite(String collection,
                                       List<BulkOperation> operations)

      Execute a bulk operation. Can insert, update, replace, and/or delete multiple documents with one request.
      Parameters:
        `collection` - the collection
        `operations` - the operations to execute
      Returns:

    - #### rxBulkWrite

          public Maybe<MongoClientBulkWriteResult> rxBulkWrite(String collection,
                                                               List<BulkOperation> operations)

      Execute a bulk operation. Can insert, update, replace, and/or delete multiple documents with one request.
      Parameters:
        `collection` - the collection
        `operations` - the operations to execute
      Returns:

    - #### bulkWriteWithOptions

          public MongoClient bulkWriteWithOptions(String collection,
                                                  List<BulkOperation> operations,
                                                  BulkWriteOptions bulkWriteOptions,
                                                  Handler<AsyncResult<MongoClientBulkWriteResult>> resultHandler)

      Execute a bulk operation with the specified write options. Can insert, update, replace, and/or delete multiple documents with one request.
      Parameters:
        `collection` - the collection
        `operations` - the operations to execute
        `bulkWriteOptions` - the write options
        `resultHandler` - will be called with a `MongoClientBulkWriteResult` when complete
      Returns:

    - #### bulkWriteWithOptions

          public MongoClient bulkWriteWithOptions(String collection,
                                                  List<BulkOperation> operations,
                                                  BulkWriteOptions bulkWriteOptions)

      Execute a bulk operation with the specified write options. Can insert, update, replace, and/or delete multiple documents with one request.
      Parameters:
        `collection` - the collection
        `operations` - the operations to execute
        `bulkWriteOptions` - the write options
      Returns:

    - #### rxBulkWriteWithOptions

          public Maybe<MongoClientBulkWriteResult> rxBulkWriteWithOptions(String collection,
                                                                          List<BulkOperation> operations,
                                                                          BulkWriteOptions bulkWriteOptions)

      Execute a bulk operation with the specified write options. Can insert, update, replace, and/or delete multiple documents with one request.
      Parameters:
        `collection` - the collection
        `operations` - the operations to execute
        `bulkWriteOptions` - the write options
      Returns:

    - #### find

          public MongoClient find(String collection,
                                  JsonObject query,
                                  Handler<AsyncResult<List<JsonObject>>> resultHandler)

      Find matching documents in the specified collection
      Parameters:
        `collection` - the collection
        `query` - query used to match documents
        `resultHandler` - will be provided with list of documents
      Returns:

    - #### find

          public MongoClient find(String collection,
                                  JsonObject query)

      Find matching documents in the specified collection
      Parameters:
        `collection` - the collection
        `query` - query used to match documents
      Returns:

    - #### rxFind

          public Single<List<JsonObject>> rxFind(String collection,
                                                 JsonObject query)

      Find matching documents in the specified collection
      Parameters:
        `collection` - the collection
        `query` - query used to match documents
      Returns:

    - #### findBatch

          public ReadStream<JsonObject> findBatch(String collection,
                                                  JsonObject query)

      Find matching documents in the specified collection. This method use batchCursor for returning each found document.
      Parameters:
        `collection` - the collection
        `query` - query used to match documents
      Returns:
        a emitting found documents

    - #### findWithOptions

          public MongoClient findWithOptions(String collection,
                                             JsonObject query,
                                             FindOptions options,
                                             Handler<AsyncResult<List<JsonObject>>> resultHandler)

      Find matching documents in the specified collection, specifying options
      Parameters:
        `collection` - the collection
        `query` - query used to match documents
        `options` - options to configure the find
        `resultHandler` - will be provided with list of documents
      Returns:

    - #### findWithOptions

          public MongoClient findWithOptions(String collection,
                                             JsonObject query,
                                             FindOptions options)

      Find matching documents in the specified collection, specifying options
      Parameters:
        `collection` - the collection
        `query` - query used to match documents
        `options` - options to configure the find
      Returns:

    - #### rxFindWithOptions

          public Single<List<JsonObject>> rxFindWithOptions(String collection,
                                                            JsonObject query,
                                                            FindOptions options)

      Find matching documents in the specified collection, specifying options
      Parameters:
        `collection` - the collection
        `query` - query used to match documents
        `options` - options to configure the find
      Returns:

    - #### findBatchWithOptions

          public ReadStream<JsonObject> findBatchWithOptions(String collection,
                                                             JsonObject query,
                                                             FindOptions options)

      Find matching documents in the specified collection, specifying options. This method use batchCursor for returning each found document.
      Parameters:
        `collection` - the collection
        `query` - query used to match documents
        `options` - options to configure the find
      Returns:
        a emitting found documents

    - #### findOne

          public MongoClient findOne(String collection,
                                     JsonObject query,
                                     JsonObject fields,
                                     Handler<AsyncResult<JsonObject>> resultHandler)

      Find a single matching document in the specified collection

      This operation might change _id field of query parameter

      Parameters:
        `collection` - the collection
        `query` - the query used to match the document
        `fields` - the fields
        `resultHandler` - will be provided with the document, if any
      Returns:

    - #### findOne

          public MongoClient findOne(String collection,
                                     JsonObject query,
                                     JsonObject fields)

      Find a single matching document in the specified collection

      This operation might change _id field of query parameter

      Parameters:
        `collection` - the collection
        `query` - the query used to match the document
        `fields` - the fields
      Returns:

    - #### rxFindOne

          public Maybe<JsonObject> rxFindOne(String collection,
                                             JsonObject query,
                                             JsonObject fields)

      Find a single matching document in the specified collection

      This operation might change _id field of query parameter

      Parameters:
        `collection` - the collection
        `query` - the query used to match the document
        `fields` - the fields
      Returns:

    - #### findOneAndUpdate

          public MongoClient findOneAndUpdate(String collection,
                                              JsonObject query,
                                              JsonObject update,
                                              Handler<AsyncResult<JsonObject>> resultHandler)

      Find a single matching document in the specified collection and update it.

      This operation might change _id field of query parameter

      Parameters:
        `collection` - the collection
        `query` - the query used to match the document
        `update` - used to describe how the documents will be updated
        `resultHandler` - will be provided with the document, if any
      Returns:

    - #### findOneAndUpdate

          public MongoClient findOneAndUpdate(String collection,
                                              JsonObject query,
                                              JsonObject update)

      Find a single matching document in the specified collection and update it.

      This operation might change _id field of query parameter

      Parameters:
        `collection` - the collection
        `query` - the query used to match the document
        `update` - used to describe how the documents will be updated
      Returns:

    - #### rxFindOneAndUpdate

          public Maybe<JsonObject> rxFindOneAndUpdate(String collection,
                                                      JsonObject query,
                                                      JsonObject update)

      Find a single matching document in the specified collection and update it.

      This operation might change _id field of query parameter

      Parameters:
        `collection` - the collection
        `query` - the query used to match the document
        `update` - used to describe how the documents will be updated
      Returns:

    - #### findOneAndUpdateWithOptions

          public MongoClient findOneAndUpdateWithOptions(String collection,
                                                         JsonObject query,
                                                         JsonObject update,
                                                         FindOptions findOptions,
                                                         UpdateOptions updateOptions,
                                                         Handler<AsyncResult<JsonObject>> resultHandler)

      Find a single matching document in the specified collection and update it.

      This operation might change _id field of query parameter

      Parameters:
        `collection` - the collection
        `query` - the query used to match the document
        `update` - used to describe how the documents will be updated
        `findOptions` - options to configure the find
        `updateOptions` - options to configure the update
        `resultHandler` - will be provided with the document, if any
      Returns:

    - #### findOneAndUpdateWithOptions

          public MongoClient findOneAndUpdateWithOptions(String collection,
                                                         JsonObject query,
                                                         JsonObject update,
                                                         FindOptions findOptions,
                                                         UpdateOptions updateOptions)

      Find a single matching document in the specified collection and update it.

      This operation might change _id field of query parameter

      Parameters:
        `collection` - the collection
        `query` - the query used to match the document
        `update` - used to describe how the documents will be updated
        `findOptions` - options to configure the find
        `updateOptions` - options to configure the update
      Returns:

    - #### rxFindOneAndUpdateWithOptions

          public Maybe<JsonObject> rxFindOneAndUpdateWithOptions(String collection,
                                                                 JsonObject query,
                                                                 JsonObject update,
                                                                 FindOptions findOptions,
                                                                 UpdateOptions updateOptions)

      Find a single matching document in the specified collection and update it.

      This operation might change _id field of query parameter

      Parameters:
        `collection` - the collection
        `query` - the query used to match the document
        `update` - used to describe how the documents will be updated
        `findOptions` - options to configure the find
        `updateOptions` - options to configure the update
      Returns:

    - #### findOneAndReplace

          public MongoClient findOneAndReplace(String collection,
                                               JsonObject query,
                                               JsonObject replace,
                                               Handler<AsyncResult<JsonObject>> resultHandler)

      Find a single matching document in the specified collection and replace it.

      This operation might change _id field of query parameter

      Parameters:
        `collection` - the collection
        `query` - the query used to match the document
        `replace` - the replacement document
        `resultHandler` - will be provided with the document, if any
      Returns:

    - #### findOneAndReplace

          public MongoClient findOneAndReplace(String collection,
                                               JsonObject query,
                                               JsonObject replace)

      Find a single matching document in the specified collection and replace it.

      This operation might change _id field of query parameter

      Parameters:
        `collection` - the collection
        `query` - the query used to match the document
        `replace` - the replacement document
      Returns:

    - #### rxFindOneAndReplace

          public Maybe<JsonObject> rxFindOneAndReplace(String collection,
                                                       JsonObject query,
                                                       JsonObject replace)

      Find a single matching document in the specified collection and replace it.

      This operation might change _id field of query parameter

      Parameters:
        `collection` - the collection
        `query` - the query used to match the document
        `replace` - the replacement document
      Returns:

    - #### findOneAndReplaceWithOptions

          public MongoClient findOneAndReplaceWithOptions(String collection,
                                                          JsonObject query,
                                                          JsonObject replace,
                                                          FindOptions findOptions,
                                                          UpdateOptions updateOptions,
                                                          Handler<AsyncResult<JsonObject>> resultHandler)

      Find a single matching document in the specified collection and replace it.

      This operation might change _id field of query parameter

      Parameters:
        `collection` - the collection
        `query` - the query used to match the document
        `replace` - the replacement document
        `findOptions` - options to configure the find
        `updateOptions` - options to configure the update
        `resultHandler` - will be provided with the document, if any
      Returns:

    - #### findOneAndReplaceWithOptions

          public MongoClient findOneAndReplaceWithOptions(String collection,
                                                          JsonObject query,
                                                          JsonObject replace,
                                                          FindOptions findOptions,
                                                          UpdateOptions updateOptions)

      Find a single matching document in the specified collection and replace it.

      This operation might change _id field of query parameter

      Parameters:
        `collection` - the collection
        `query` - the query used to match the document
        `replace` - the replacement document
        `findOptions` - options to configure the find
        `updateOptions` - options to configure the update
      Returns:

    - #### rxFindOneAndReplaceWithOptions

          public Maybe<JsonObject> rxFindOneAndReplaceWithOptions(String collection,
                                                                  JsonObject query,
                                                                  JsonObject replace,
                                                                  FindOptions findOptions,
                                                                  UpdateOptions updateOptions)

      Find a single matching document in the specified collection and replace it.

      This operation might change _id field of query parameter

      Parameters:
        `collection` - the collection
        `query` - the query used to match the document
        `replace` - the replacement document
        `findOptions` - options to configure the find
        `updateOptions` - options to configure the update
      Returns:

    - #### findOneAndDelete

          public MongoClient findOneAndDelete(String collection,
                                              JsonObject query,
                                              Handler<AsyncResult<JsonObject>> resultHandler)

      Find a single matching document in the specified collection and delete it.

      This operation might change _id field of query parameter

      Parameters:
        `collection` - the collection
        `query` - the query used to match the document
        `resultHandler` - will be provided with the deleted document, if any
      Returns:

    - #### findOneAndDelete

          public MongoClient findOneAndDelete(String collection,
                                              JsonObject query)

      Find a single matching document in the specified collection and delete it.

      This operation might change _id field of query parameter

      Parameters:
        `collection` - the collection
        `query` - the query used to match the document
      Returns:

    - #### rxFindOneAndDelete

          public Maybe<JsonObject> rxFindOneAndDelete(String collection,
                                                      JsonObject query)

      Find a single matching document in the specified collection and delete it.

      This operation might change _id field of query parameter

      Parameters:
        `collection` - the collection
        `query` - the query used to match the document
      Returns:

    - #### findOneAndDeleteWithOptions

          public MongoClient findOneAndDeleteWithOptions(String collection,
                                                         JsonObject query,
                                                         FindOptions findOptions,
                                                         Handler<AsyncResult<JsonObject>> resultHandler)

      Find a single matching document in the specified collection and delete it.

      This operation might change _id field of query parameter

      Parameters:
        `collection` - the collection
        `query` - the query used to match the document
        `findOptions` - options to configure the find
        `resultHandler` - will be provided with the deleted document, if any
      Returns:

    - #### findOneAndDeleteWithOptions

          public MongoClient findOneAndDeleteWithOptions(String collection,
                                                         JsonObject query,
                                                         FindOptions findOptions)

      Find a single matching document in the specified collection and delete it.

      This operation might change _id field of query parameter

      Parameters:
        `collection` - the collection
        `query` - the query used to match the document
        `findOptions` - options to configure the find
      Returns:

    - #### rxFindOneAndDeleteWithOptions

          public Maybe<JsonObject> rxFindOneAndDeleteWithOptions(String collection,
                                                                 JsonObject query,
                                                                 FindOptions findOptions)

      Find a single matching document in the specified collection and delete it.

      This operation might change _id field of query parameter

      Parameters:
        `collection` - the collection
        `query` - the query used to match the document
        `findOptions` - options to configure the find
      Returns:

    - #### count

          public MongoClient count(String collection,
                                   JsonObject query,
                                   Handler<AsyncResult<Long>> resultHandler)

      Count matching documents in a collection.
      Parameters:
        `collection` - the collection
        `query` - query used to match documents
        `resultHandler` - will be provided with the number of matching documents
      Returns:

    - #### count

          public MongoClient count(String collection,
                                   JsonObject query)

      Count matching documents in a collection.
      Parameters:
        `collection` - the collection
        `query` - query used to match documents
      Returns:

    - #### rxCount

          public Single<Long> rxCount(String collection,
                                      JsonObject query)

      Count matching documents in a collection.
      Parameters:
        `collection` - the collection
        `query` - query used to match documents
      Returns:

    - #### countWithOptions

          public MongoClient countWithOptions(String collection,
                                              JsonObject query,
                                              CountOptions countOptions,
                                              Handler<AsyncResult<Long>> resultHandler)

      Count matching documents in a collection.
      Parameters:
        `collection` - the collection
        `query` - query used to match documents
        `countOptions` -
        `resultHandler` - will be provided with the number of matching documents
      Returns:

    - #### countWithOptions

          public MongoClient countWithOptions(String collection,
                                              JsonObject query,
                                              CountOptions countOptions)

      Count matching documents in a collection.
      Parameters:
        `collection` - the collection
        `query` - query used to match documents
        `countOptions` -
      Returns:

    - #### rxCountWithOptions

          public Single<Long> rxCountWithOptions(String collection,
                                                 JsonObject query,
                                                 CountOptions countOptions)

      Count matching documents in a collection.
      Parameters:
        `collection` - the collection
        `query` - query used to match documents
        `countOptions` -
      Returns:

    - #### removeDocuments

          public MongoClient removeDocuments(String collection,
                                             JsonObject query,
                                             Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)

      Remove matching documents from a collection and return the handler with `MongoClientDeleteResult` result
      Parameters:
        `collection` - the collection
        `query` - query used to match documents
        `resultHandler` - will be called with a `MongoClientDeleteResult` when complete
      Returns:

    - #### removeDocuments

          public MongoClient removeDocuments(String collection,
                                             JsonObject query)

      Remove matching documents from a collection and return the handler with `MongoClientDeleteResult` result
      Parameters:
        `collection` - the collection
        `query` - query used to match documents
      Returns:

    - #### rxRemoveDocuments

          public Maybe<MongoClientDeleteResult> rxRemoveDocuments(String collection,
                                                                  JsonObject query)

      Remove matching documents from a collection and return the handler with `MongoClientDeleteResult` result
      Parameters:
        `collection` - the collection
        `query` - query used to match documents
      Returns:

    - #### removeDocumentsWithOptions

          public MongoClient removeDocumentsWithOptions(String collection,
                                                        JsonObject query,
                                                        WriteOption writeOption,
                                                        Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)

      Remove matching documents from a collection with the specified write option and return the handler with `MongoClientDeleteResult` result
      Parameters:
        `collection` - the collection
        `query` - query used to match documents
        `writeOption` - the write option to use
        `resultHandler` - will be called with a `MongoClientDeleteResult` when complete
      Returns:

    - #### removeDocumentsWithOptions

          public MongoClient removeDocumentsWithOptions(String collection,
                                                        JsonObject query,
                                                        WriteOption writeOption)

      Remove matching documents from a collection with the specified write option and return the handler with `MongoClientDeleteResult` result
      Parameters:
        `collection` - the collection
        `query` - query used to match documents
        `writeOption` - the write option to use
      Returns:

    - #### rxRemoveDocumentsWithOptions

          public Maybe<MongoClientDeleteResult> rxRemoveDocumentsWithOptions(String collection,
                                                                             JsonObject query,
                                                                             WriteOption writeOption)

      Remove matching documents from a collection with the specified write option and return the handler with `MongoClientDeleteResult` result
      Parameters:
        `collection` - the collection
        `query` - query used to match documents
        `writeOption` - the write option to use
      Returns:

    - #### removeDocument

          public MongoClient removeDocument(String collection,
                                            JsonObject query,
                                            Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)

      Remove a single matching document from a collection and return the handler with `MongoClientDeleteResult` result
      Parameters:
        `collection` - the collection
        `query` - query used to match document
        `resultHandler` - will be called with a `MongoClientDeleteResult` when complete
      Returns:

    - #### removeDocument

          public MongoClient removeDocument(String collection,
                                            JsonObject query)

      Remove a single matching document from a collection and return the handler with `MongoClientDeleteResult` result
      Parameters:
        `collection` - the collection
        `query` - query used to match document
      Returns:

    - #### rxRemoveDocument

          public Maybe<MongoClientDeleteResult> rxRemoveDocument(String collection,
                                                                 JsonObject query)

      Remove a single matching document from a collection and return the handler with `MongoClientDeleteResult` result
      Parameters:
        `collection` - the collection
        `query` - query used to match document
      Returns:

    - #### removeDocumentWithOptions

          public MongoClient removeDocumentWithOptions(String collection,
                                                       JsonObject query,
                                                       WriteOption writeOption,
                                                       Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)

      Remove a single matching document from a collection with the specified write option and return the handler with `MongoClientDeleteResult` result
      Parameters:
        `collection` - the collection
        `query` - query used to match document
        `writeOption` - the write option to use
        `resultHandler` - will be called with a `MongoClientDeleteResult` when complete
      Returns:

    - #### removeDocumentWithOptions

          public MongoClient removeDocumentWithOptions(String collection,
                                                       JsonObject query,
                                                       WriteOption writeOption)

      Remove a single matching document from a collection with the specified write option and return the handler with `MongoClientDeleteResult` result
      Parameters:
        `collection` - the collection
        `query` - query used to match document
        `writeOption` - the write option to use
      Returns:

    - #### rxRemoveDocumentWithOptions

          public Maybe<MongoClientDeleteResult> rxRemoveDocumentWithOptions(String collection,
                                                                            JsonObject query,
                                                                            WriteOption writeOption)

      Remove a single matching document from a collection with the specified write option and return the handler with `MongoClientDeleteResult` result
      Parameters:
        `collection` - the collection
        `query` - query used to match document
        `writeOption` - the write option to use
      Returns:

    - #### createCollection

          public MongoClient createCollection(String collectionName,
                                              Handler<AsyncResult<Void>> resultHandler)

      Create a new collection
      Parameters:
        `collectionName` - the name of the collection
        `resultHandler` - will be called when complete
      Returns:

    - #### createCollection

          public MongoClient createCollection(String collectionName)

      Create a new collection
      Parameters:
        `collectionName` - the name of the collection
      Returns:

    - #### rxCreateCollection

          public Completable rxCreateCollection(String collectionName)

      Create a new collection
      Parameters:
        `collectionName` - the name of the collection
      Returns:

    - #### createCollectionWithOptions

          public MongoClient createCollectionWithOptions(String collectionName,
                                                         CreateCollectionOptions collectionOptions,
                                                         Handler<AsyncResult<Void>> resultHandler)

      Create a new collection with options
      Parameters:
        `collectionName` - the name of the collection
        `collectionOptions` - options of the collection
        `resultHandler` - will be called when complete
      Returns:

    - #### createCollectionWithOptions

          public MongoClient createCollectionWithOptions(String collectionName,
                                                         CreateCollectionOptions collectionOptions)

      Create a new collection with options
      Parameters:
        `collectionName` - the name of the collection
        `collectionOptions` - options of the collection
      Returns:

    - #### rxCreateCollectionWithOptions

          public Completable rxCreateCollectionWithOptions(String collectionName,
                                                           CreateCollectionOptions collectionOptions)

      Create a new collection with options
      Parameters:
        `collectionName` - the name of the collection
        `collectionOptions` - options of the collection
      Returns:

    - #### getCollections

          public MongoClient getCollections(Handler<AsyncResult<List<String>>> resultHandler)

      Get a list of all collections in the database.
      Parameters:
        `resultHandler` - will be called with a list of collections.
      Returns:

    - #### getCollections

          public MongoClient getCollections()

      Get a list of all collections in the database.
      Returns:

    - #### rxGetCollections

          public Single<List<String>> rxGetCollections()

      Get a list of all collections in the database.
      Returns:

    - #### dropCollection

          public MongoClient dropCollection(String collection,
                                            Handler<AsyncResult<Void>> resultHandler)

      Drop a collection
      Parameters:
        `collection` - the collection
        `resultHandler` - will be called when complete
      Returns:

    - #### dropCollection

          public MongoClient dropCollection(String collection)

      Drop a collection
      Parameters:
        `collection` - the collection
      Returns:

    - #### rxDropCollection

          public Completable rxDropCollection(String collection)

      Drop a collection
      Parameters:
        `collection` - the collection
      Returns:

    - #### createIndex

          public MongoClient createIndex(String collection,
                                         JsonObject key,
                                         Handler<AsyncResult<Void>> resultHandler)

      Creates an index.
      Parameters:
        `collection` - the collection
        `key` - A document that contains the field and value pairs where the field is the index key and the value describes the type of index for that field. For an ascending index on a field, specify a value of 1; for descending index, specify a value of -1.
        `resultHandler` - will be called when complete
      Returns:

    - #### createIndex

          public MongoClient createIndex(String collection,
                                         JsonObject key)

      Creates an index.
      Parameters:
        `collection` - the collection
        `key` - A document that contains the field and value pairs where the field is the index key and the value describes the type of index for that field. For an ascending index on a field, specify a value of 1; for descending index, specify a value of -1.
      Returns:

    - #### rxCreateIndex

          public Completable rxCreateIndex(String collection,
                                           JsonObject key)

      Creates an index.
      Parameters:
        `collection` - the collection
        `key` - A document that contains the field and value pairs where the field is the index key and the value describes the type of index for that field. For an ascending index on a field, specify a value of 1; for descending index, specify a value of -1.
      Returns:

    - #### createIndexWithOptions

          public MongoClient createIndexWithOptions(String collection,
                                                    JsonObject key,
                                                    IndexOptions options,
                                                    Handler<AsyncResult<Void>> resultHandler)

      Creates an index.
      Parameters:
        `collection` - the collection
        `key` - A document that contains the field and value pairs where the field is the index key and the value describes the type of index for that field. For an ascending index on a field, specify a value of 1; for descending index, specify a value of -1.
        `options` - the options for the index
        `resultHandler` - will be called when complete
      Returns:

    - #### createIndexWithOptions

          public MongoClient createIndexWithOptions(String collection,
                                                    JsonObject key,
                                                    IndexOptions options)

      Creates an index.
      Parameters:
        `collection` - the collection
        `key` - A document that contains the field and value pairs where the field is the index key and the value describes the type of index for that field. For an ascending index on a field, specify a value of 1; for descending index, specify a value of -1.
        `options` - the options for the index
      Returns:

    - #### rxCreateIndexWithOptions

          public Completable rxCreateIndexWithOptions(String collection,
                                                      JsonObject key,
                                                      IndexOptions options)

      Creates an index.
      Parameters:
        `collection` - the collection
        `key` - A document that contains the field and value pairs where the field is the index key and the value describes the type of index for that field. For an ascending index on a field, specify a value of 1; for descending index, specify a value of -1.
        `options` - the options for the index
      Returns:

    - #### createIndexes

          public MongoClient createIndexes(String collection,
                                           List<IndexModel> indexes,
                                           Handler<AsyncResult<Void>> resultHandler)

      creates an indexes
      Parameters:
        `collection` - the collection
        `indexes` - A model that contains pairs of document and indexOptions, document contains the field and value pairs where the field is the index key and the value describes the type of index for that field. For an ascending index on a field, specify a value of 1; for descending index, specify a value of -1.
        `resultHandler` - will be called when complete
      Returns:

    - #### createIndexes

          public MongoClient createIndexes(String collection,
                                           List<IndexModel> indexes)

      creates an indexes
      Parameters:
        `collection` - the collection
        `indexes` - A model that contains pairs of document and indexOptions, document contains the field and value pairs where the field is the index key and the value describes the type of index for that field. For an ascending index on a field, specify a value of 1; for descending index, specify a value of -1.
      Returns:

    - #### rxCreateIndexes

          public Completable rxCreateIndexes(String collection,
                                             List<IndexModel> indexes)

      creates an indexes
      Parameters:
        `collection` - the collection
        `indexes` - A model that contains pairs of document and indexOptions, document contains the field and value pairs where the field is the index key and the value describes the type of index for that field. For an ascending index on a field, specify a value of 1; for descending index, specify a value of -1.
      Returns:

    - #### listIndexes

          public MongoClient listIndexes(String collection,
                                         Handler<AsyncResult<JsonArray>> resultHandler)

      Get all the indexes in this collection.
      Parameters:
        `collection` - the collection
        `resultHandler` - will be called when complete
      Returns:

    - #### listIndexes

          public MongoClient listIndexes(String collection)

      Get all the indexes in this collection.
      Parameters:
        `collection` - the collection
      Returns:

    - #### rxListIndexes

          public Single<JsonArray> rxListIndexes(String collection)

      Get all the indexes in this collection.
      Parameters:
        `collection` - the collection
      Returns:

    - #### dropIndex

          public MongoClient dropIndex(String collection,
                                       String indexName,
                                       Handler<AsyncResult<Void>> resultHandler)

      Drops the index given its name.
      Parameters:
        `collection` - the collection
        `indexName` - the name of the index to remove
        `resultHandler` - will be called when complete
      Returns:

    - #### dropIndex

          public MongoClient dropIndex(String collection,
                                       String indexName)

      Drops the index given its name.
      Parameters:
        `collection` - the collection
        `indexName` - the name of the index to remove
      Returns:

    - #### rxDropIndex

          public Completable rxDropIndex(String collection,
                                         String indexName)

      Drops the index given its name.
      Parameters:
        `collection` - the collection
        `indexName` - the name of the index to remove
      Returns:

    - #### runCommand

          public MongoClient runCommand(String commandName,
                                        JsonObject command,
                                        Handler<AsyncResult<JsonObject>> resultHandler)

      Run an arbitrary MongoDB command.
      Parameters:
        `commandName` - the name of the command
        `command` - the command
        `resultHandler` - will be called with the result.
      Returns:

    - #### runCommand

          public MongoClient runCommand(String commandName,
                                        JsonObject command)

      Run an arbitrary MongoDB command.
      Parameters:
        `commandName` - the name of the command
        `command` - the command
      Returns:

    - #### rxRunCommand

          public Maybe<JsonObject> rxRunCommand(String commandName,
                                                JsonObject command)

      Run an arbitrary MongoDB command.
      Parameters:
        `commandName` - the name of the command
        `command` - the command
      Returns:

    - #### distinct

          public MongoClient distinct(String collection,
                                      String fieldName,
                                      String resultClassname,
                                      Handler<AsyncResult<JsonArray>> resultHandler)

      Gets the distinct values of the specified field name. Return a JsonArray containing distinct values (eg: [ 1 , 89 ])
      Parameters:
        `collection` - the collection
        `fieldName` - the field name
        `resultClassname` -
        `resultHandler` - will be provided with array of values.
      Returns:

    - #### distinct

          public MongoClient distinct(String collection,
                                      String fieldName,
                                      String resultClassname)

      Gets the distinct values of the specified field name. Return a JsonArray containing distinct values (eg: [ 1 , 89 ])
      Parameters:
        `collection` - the collection
        `fieldName` - the field name
        `resultClassname` -
      Returns:

    - #### rxDistinct

          public Single<JsonArray> rxDistinct(String collection,
                                              String fieldName,
                                              String resultClassname)

      Gets the distinct values of the specified field name. Return a JsonArray containing distinct values (eg: [ 1 , 89 ])
      Parameters:
        `collection` - the collection
        `fieldName` - the field name
        `resultClassname` -
      Returns:

    - #### distinct

          public MongoClient distinct(String collection,
                                      String fieldName,
                                      String resultClassname,
                                      DistinctOptions distinctOptions,
                                      Handler<AsyncResult<JsonArray>> resultHandler)

      Gets the distinct values of the specified field name. Return a JsonArray containing distinct values (eg: [ 1 , 89 ])
      Parameters:
        `collection` - the collection
        `fieldName` - the field name
        `resultClassname` -
        `distinctOptions` - options (e.g. collation)
        `resultHandler` - will be provided with array of values.
      Returns:

    - #### distinct

          public MongoClient distinct(String collection,
                                      String fieldName,
                                      String resultClassname,
                                      DistinctOptions distinctOptions)

      Gets the distinct values of the specified field name. Return a JsonArray containing distinct values (eg: [ 1 , 89 ])
      Parameters:
        `collection` - the collection
        `fieldName` - the field name
        `resultClassname` -
        `distinctOptions` - options (e.g. collation)
      Returns:

    - #### rxDistinct

          public Single<JsonArray> rxDistinct(String collection,
                                              String fieldName,
                                              String resultClassname,
                                              DistinctOptions distinctOptions)

      Gets the distinct values of the specified field name. Return a JsonArray containing distinct values (eg: [ 1 , 89 ])
      Parameters:
        `collection` - the collection
        `fieldName` - the field name
        `resultClassname` -
        `distinctOptions` - options (e.g. collation)
      Returns:

    - #### distinctWithQuery

          public MongoClient distinctWithQuery(String collection,
                                               String fieldName,
                                               String resultClassname,
                                               JsonObject query,
                                               Handler<AsyncResult<JsonArray>> resultHandler)

      Gets the distinct values of the specified field name filtered by specified query. Return a JsonArray containing distinct values (eg: [ 1 , 89 ])
      Parameters:
        `collection` - the collection
        `fieldName` - the field name
        `resultClassname` -
        `query` - the query
        `resultHandler` - will be provided with array of values.
      Returns:

    - #### distinctWithQuery

          public MongoClient distinctWithQuery(String collection,
                                               String fieldName,
                                               String resultClassname,
                                               JsonObject query)

      Gets the distinct values of the specified field name filtered by specified query. Return a JsonArray containing distinct values (eg: [ 1 , 89 ])
      Parameters:
        `collection` - the collection
        `fieldName` - the field name
        `resultClassname` -
        `query` - the query
      Returns:

    - #### rxDistinctWithQuery

          public Single<JsonArray> rxDistinctWithQuery(String collection,
                                                       String fieldName,
                                                       String resultClassname,
                                                       JsonObject query)

      Gets the distinct values of the specified field name filtered by specified query. Return a JsonArray containing distinct values (eg: [ 1 , 89 ])
      Parameters:
        `collection` - the collection
        `fieldName` - the field name
        `resultClassname` -
        `query` - the query
      Returns:

    - #### distinctWithQuery

          public MongoClient distinctWithQuery(String collection,
                                               String fieldName,
                                               String resultClassname,
                                               JsonObject query,
                                               DistinctOptions distinctOptions,
                                               Handler<AsyncResult<JsonArray>> resultHandler)

      Gets the distinct values of the specified field name filtered by specified query. Return a JsonArray containing distinct values (eg: [ 1 , 89 ])
      Parameters:
        `collection` - the collection
        `fieldName` - the field name
        `resultClassname` -
        `query` - the query
        `distinctOptions` - options (e.g. collation)
        `resultHandler` - will be provided with array of values.
      Returns:

    - #### distinctWithQuery

          public MongoClient distinctWithQuery(String collection,
                                               String fieldName,
                                               String resultClassname,
                                               JsonObject query,
                                               DistinctOptions distinctOptions)

      Gets the distinct values of the specified field name filtered by specified query. Return a JsonArray containing distinct values (eg: [ 1 , 89 ])
      Parameters:
        `collection` - the collection
        `fieldName` - the field name
        `resultClassname` -
        `query` - the query
        `distinctOptions` - options (e.g. collation)
      Returns:

    - #### rxDistinctWithQuery

          public Single<JsonArray> rxDistinctWithQuery(String collection,
                                                       String fieldName,
                                                       String resultClassname,
                                                       JsonObject query,
                                                       DistinctOptions distinctOptions)

      Gets the distinct values of the specified field name filtered by specified query. Return a JsonArray containing distinct values (eg: [ 1 , 89 ])
      Parameters:
        `collection` - the collection
        `fieldName` - the field name
        `resultClassname` -
        `query` - the query
        `distinctOptions` - options (e.g. collation)
      Returns:

    - #### distinctBatch

          public ReadStream<JsonObject> distinctBatch(String collection,
                                                      String fieldName,
                                                      String resultClassname)

      Gets the distinct values of the specified field name. This method use batchCursor for returning each found value. Each value is a json fragment with fieldName key (eg: {"num": 1}).
      Parameters:
        `collection` - the collection
        `fieldName` - the field name
        `resultClassname` -
      Returns:
        a emitting json fragments

    - #### distinctBatch

          public ReadStream<JsonObject> distinctBatch(String collection,
                                                      String fieldName,
                                                      String resultClassname,
                                                      DistinctOptions distinctOptions)

      Gets the distinct values of the specified field name. This method use batchCursor for returning each found value. Each value is a json fragment with fieldName key (eg: {"num": 1}).
      Parameters:
        `collection` - the collection
        `fieldName` - the field name
        `resultClassname` -
        `distinctOptions` - options (e.g. collation)
      Returns:
        a emitting json fragments

    - #### distinctBatchWithQuery

          public ReadStream<JsonObject> distinctBatchWithQuery(String collection,
                                                               String fieldName,
                                                               String resultClassname,
                                                               JsonObject query)

      Gets the distinct values of the specified field name filtered by specified query. This method use batchCursor for returning each found value. Each value is a json fragment with fieldName key (eg: {"num": 1}).
      Parameters:
        `collection` - the collection
        `fieldName` - the field name
        `resultClassname` -
        `query` - the query
      Returns:
        a emitting json fragments

    - #### distinctBatchWithQuery

          public ReadStream<JsonObject> distinctBatchWithQuery(String collection,
                                                               String fieldName,
                                                               String resultClassname,
                                                               JsonObject query,
                                                               DistinctOptions distinctOptions)

      Gets the distinct values of the specified field name filtered by specified query. This method use batchCursor for returning each found value. Each value is a json fragment with fieldName key (eg: {"num": 1}).
      Parameters:
        `collection` - the collection
        `fieldName` - the field name
        `resultClassname` -
        `query` - the query
        `distinctOptions` - options (e.g. collation)
      Returns:
        a emitting json fragments

    - #### distinctBatchWithQuery

          public ReadStream<JsonObject> distinctBatchWithQuery(String collection,
                                                               String fieldName,
                                                               String resultClassname,
                                                               JsonObject query,
                                                               int batchSize)

      Gets the distinct values of the specified field name filtered by specified query. This method use batchCursor for returning each found value. Each value is a json fragment with fieldName key (eg: {"num": 1}).
      Parameters:
        `collection` - the collection
        `fieldName` - the field name
        `resultClassname` -
        `query` - the query
        `batchSize` - the number of documents to load in a batch
      Returns:
        a emitting json fragments

    - #### distinctBatchWithQuery

          public ReadStream<JsonObject> distinctBatchWithQuery(String collection,
                                                               String fieldName,
                                                               String resultClassname,
                                                               JsonObject query,
                                                               int batchSize,
                                                               DistinctOptions distinctOptions)

      Gets the distinct values of the specified field name filtered by specified query. This method use batchCursor for returning each found value. Each value is a json fragment with fieldName key (eg: {"num": 1}).
      Parameters:
        `collection` - the collection
        `fieldName` - the field name
        `resultClassname` -
        `query` - the query
        `batchSize` - the number of documents to load in a batch
        `distinctOptions` - options (e.g. collation)
      Returns:
        a emitting json fragments

    - #### aggregate

          public ReadStream<JsonObject> aggregate(String collection,
                                                  JsonArray pipeline)

      Run aggregate MongoDB command with default `AggregateOptions`.
      Parameters:
        `collection` - the collection
        `pipeline` - aggregation pipeline to be executed
      Returns:

    - #### aggregateWithOptions

          public ReadStream<JsonObject> aggregateWithOptions(String collection,
                                                             JsonArray pipeline,
                                                             AggregateOptions options)

      Run aggregate MongoDB command.
      Parameters:
        `collection` - the collection
        `pipeline` - aggregation pipeline to be executed
        `options` - options to configure the aggregation command
      Returns:

    - #### createDefaultGridFsBucketService

          public MongoClient createDefaultGridFsBucketService(Handler<AsyncResult<MongoGridFsClient>> resultHandler)

      Creates a `MongoGridFsClient` used to interact with Mongo GridFS.
      Parameters:
        `resultHandler` - the `MongoGridFsClient` to interact with the bucket named bucketName
      Returns:

    - #### createDefaultGridFsBucketService

          public MongoClient createDefaultGridFsBucketService()

      Creates a `MongoGridFsClient` used to interact with Mongo GridFS.
      Returns:

    - #### rxCreateDefaultGridFsBucketService

          public Single<MongoGridFsClient> rxCreateDefaultGridFsBucketService()

      Creates a `MongoGridFsClient` used to interact with Mongo GridFS.
      Returns:

    - #### createGridFsBucketService

          public MongoClient createGridFsBucketService(String bucketName,
                                                       Handler<AsyncResult<MongoGridFsClient>> resultHandler)

      Creates a `MongoGridFsClient` used to interact with Mongo GridFS.
      Parameters:
        `bucketName` - the name of the GridFS bucket
        `resultHandler` - the `MongoGridFsClient` to interact with the bucket named bucketName
      Returns:

    - #### createGridFsBucketService

          public MongoClient createGridFsBucketService(String bucketName)

      Creates a `MongoGridFsClient` used to interact with Mongo GridFS.
      Parameters:
        `bucketName` - the name of the GridFS bucket
      Returns:

    - #### rxCreateGridFsBucketService

          public Single<MongoGridFsClient> rxCreateGridFsBucketService(String bucketName)

      Creates a `MongoGridFsClient` used to interact with Mongo GridFS.
      Parameters:
        `bucketName` - the name of the GridFS bucket
      Returns:

    - #### close

          public void close(Handler<AsyncResult<Void>> handler)

      Close the client and release its resources
      Parameters:
        `handler` -

    - #### close

          public void close()

      Close the client and release its resources

    - #### rxClose

          public Completable rxClose()

      Close the client and release its resources
      Returns:

    - #### watch

          public ReadStream<com.mongodb.client.model.changestream.ChangeStreamDocument<JsonObject>> watch(String collection,
                                                                                                          JsonArray pipeline,
                                                                                                          boolean withUpdatedDoc,
                                                                                                          int batchSize)

      Watch the collection change.
      Parameters:
        `collection` - the collection
        `pipeline` - watching pipeline to be executed
        `withUpdatedDoc` - whether to get updated fullDocument for "update" operation
        `batchSize` - the number of documents to load in a batch
      Returns:

    - #### newInstance

          public static MongoClient newInstance(MongoClient arg)

Copyright © 2022 Eclipse. All rights reserved.