Class MongoClient

java.lang.Object
io.vertx.mutiny.ext.mongo.MongoClient
All Implemented Interfaces:
MutinyDelegate

public class MongoClient extends Object implements MutinyDelegate
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 Mutiny-ified interface using Vert.x codegen.

  • Field Details

  • Constructor Details

    • MongoClient

      public MongoClient(io.vertx.ext.mongo.MongoClient delegate)
    • MongoClient

      public MongoClient(Object delegate)
  • Method Details

    • getDelegate

      public io.vertx.ext.mongo.MongoClient getDelegate()
      Specified by:
      getDelegate in interface MutinyDelegate
      Returns:
      the delegate used by this Mutiny object of generated type
    • 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
    • create

      public static MongoClient create(Vertx vertx, io.vertx.core.json.JsonObject config)
      Parameters:
      vertx - the Vert.x instance
      config - the configuration
      Returns:
      the client
    • createShared

      public static MongoClient createShared(Vertx vertx, io.vertx.core.json.JsonObject config, String dataSourceName)
      Parameters:
      vertx - the Vert.x instance
      config - the configuration
      dataSourceName - the data source name
      Returns:
      the client
    • createShared

      public static MongoClient createShared(Vertx vertx, io.vertx.core.json.JsonObject config)
      Parameters:
      vertx - the Vert.x instance
      config - the configuration
      Returns:
      the client
    • save

      @CheckReturnValue public io.smallrye.mutiny.Uni<String> save(String collection, io.vertx.core.json.JsonObject document)
      Save a document in the specified collection

      This operation might change _id field of document parameter

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      collection - the collection
      document - the document
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • saveAndAwait

      public String saveAndAwait(String collection, io.vertx.core.json.JsonObject document)
      Blocking variant of save(String,JsonObject).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      collection - the collection
      document - the document
      Returns:
      the String instance produced by the operation.
    • saveAndForget

      public MongoClient saveAndForget(String collection, io.vertx.core.json.JsonObject document)
      Variant of save(String,JsonObject) that ignores the result of the operation.

      This method subscribes on the result of save(String,JsonObject), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from save(String,JsonObject) but you don't need to compose it with other operations.

      Parameters:
      collection - the collection
      document - the document
      Returns:
      the instance of MongoClient to chain method calls.
    • saveWithOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<String> saveWithOptions(String collection, io.vertx.core.json.JsonObject document, io.vertx.ext.mongo.WriteOption writeOption)
      Save a document in the specified collection with the specified write option

      This operation might change _id field of document parameter

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      collection - the collection
      document - the document
      writeOption - the write option to use
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • saveWithOptionsAndAwait

      public String saveWithOptionsAndAwait(String collection, io.vertx.core.json.JsonObject document, io.vertx.ext.mongo.WriteOption writeOption)
      Blocking variant of saveWithOptions(String,JsonObject,WriteOption).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      collection - the collection
      document - the document
      writeOption - the write option to use
      Returns:
      the String instance produced by the operation.
    • saveWithOptionsAndForget

      public MongoClient saveWithOptionsAndForget(String collection, io.vertx.core.json.JsonObject document, io.vertx.ext.mongo.WriteOption writeOption)
      Variant of saveWithOptions(String,JsonObject,WriteOption) that ignores the result of the operation.

      This method subscribes on the result of saveWithOptions(String,JsonObject,WriteOption), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from saveWithOptions(String,JsonObject,WriteOption) but you don't need to compose it with other operations.

      Parameters:
      collection - the collection
      document - the document
      writeOption - the write option to use
      Returns:
      the instance of MongoClient to chain method calls.
    • insert

      @CheckReturnValue public io.smallrye.mutiny.Uni<String> insert(String collection, io.vertx.core.json.JsonObject document)
      Insert a document in the specified collection

      This operation might change _id field of document parameter

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      collection - the collection
      document - the document
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • insertAndAwait

      public String insertAndAwait(String collection, io.vertx.core.json.JsonObject document)
      Blocking variant of insert(String,JsonObject).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      collection - the collection
      document - the document
      Returns:
      the String instance produced by the operation.
    • insertAndForget

      public MongoClient insertAndForget(String collection, io.vertx.core.json.JsonObject document)
      Variant of insert(String,JsonObject) that ignores the result of the operation.

      This method subscribes on the result of insert(String,JsonObject), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from insert(String,JsonObject) but you don't need to compose it with other operations.

      Parameters:
      collection - the collection
      document - the document
      Returns:
      the instance of MongoClient to chain method calls.
    • insertWithOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<String> insertWithOptions(String collection, io.vertx.core.json.JsonObject document, io.vertx.ext.mongo.WriteOption writeOption)
      Insert a document in the specified collection with the specified write option

      This operation might change _id field of document parameter

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      collection - the collection
      document - the document
      writeOption - the write option to use
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • insertWithOptionsAndAwait

      public String insertWithOptionsAndAwait(String collection, io.vertx.core.json.JsonObject document, io.vertx.ext.mongo.WriteOption writeOption)
      Blocking variant of insertWithOptions(String,JsonObject,WriteOption).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      collection - the collection
      document - the document
      writeOption - the write option to use
      Returns:
      the String instance produced by the operation.
    • insertWithOptionsAndForget

      public MongoClient insertWithOptionsAndForget(String collection, io.vertx.core.json.JsonObject document, io.vertx.ext.mongo.WriteOption writeOption)
      Variant of insertWithOptions(String,JsonObject,WriteOption) that ignores the result of the operation.

      This method subscribes on the result of insertWithOptions(String,JsonObject,WriteOption), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from insertWithOptions(String,JsonObject,WriteOption) but you don't need to compose it with other operations.

      Parameters:
      collection - the collection
      document - the document
      writeOption - the write option to use
      Returns:
      the instance of MongoClient to chain method calls.
    • updateCollection

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.mongo.MongoClientUpdateResult> updateCollection(String collection, io.vertx.core.json.JsonObject query, io.vertx.core.json.JsonObject update)
      Update matching documents in the specified collection and return the handler with MongoClientUpdateResult result

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      collection - the collection
      query - query used to match the documents
      update - used to describe how the documents will be updated
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • updateCollectionAndAwait

      public io.vertx.ext.mongo.MongoClientUpdateResult updateCollectionAndAwait(String collection, io.vertx.core.json.JsonObject query, io.vertx.core.json.JsonObject update)
      Blocking variant of updateCollection(String,JsonObject,JsonObject).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      collection - the collection
      query - query used to match the documents
      update - used to describe how the documents will be updated
      Returns:
      the MongoClientUpdateResult instance produced by the operation.
    • updateCollectionAndForget

      public MongoClient updateCollectionAndForget(String collection, io.vertx.core.json.JsonObject query, io.vertx.core.json.JsonObject update)
      Variant of updateCollection(String,JsonObject,JsonObject) that ignores the result of the operation.

      This method subscribes on the result of updateCollection(String,JsonObject,JsonObject), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from updateCollection(String,JsonObject,JsonObject) but you don't need to compose it with other operations.

      Parameters:
      collection - the collection
      query - query used to match the documents
      update - used to describe how the documents will be updated
      Returns:
      the instance of MongoClient to chain method calls.
    • updateCollection

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.mongo.MongoClientUpdateResult> updateCollection(String collection, io.vertx.core.json.JsonObject query, io.vertx.core.json.JsonArray update)
      Use an aggregation pipeline to update documents in the specified collection and return the handler with MongoClientUpdateResult result

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      collection - the collection
      query - query used to match the documents
      update - used to describe how the documents will be updated
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • updateCollectionAndAwait

      public io.vertx.ext.mongo.MongoClientUpdateResult updateCollectionAndAwait(String collection, io.vertx.core.json.JsonObject query, io.vertx.core.json.JsonArray update)
      Blocking variant of updateCollection(String,JsonObject,JsonArray).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      collection - the collection
      query - query used to match the documents
      update - used to describe how the documents will be updated
      Returns:
      the MongoClientUpdateResult instance produced by the operation.
    • updateCollectionAndForget

      public MongoClient updateCollectionAndForget(String collection, io.vertx.core.json.JsonObject query, io.vertx.core.json.JsonArray update)
      Variant of updateCollection(String,JsonObject,JsonArray) that ignores the result of the operation.

      This method subscribes on the result of updateCollection(String,JsonObject,JsonArray), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from updateCollection(String,JsonObject,JsonArray) but you don't need to compose it with other operations.

      Parameters:
      collection - the collection
      query - query used to match the documents
      update - used to describe how the documents will be updated
      Returns:
      the instance of MongoClient to chain method calls.
    • updateCollectionWithOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.mongo.MongoClientUpdateResult> updateCollectionWithOptions(String collection, io.vertx.core.json.JsonObject query, io.vertx.core.json.JsonObject update, io.vertx.ext.mongo.UpdateOptions options)
      Update matching documents in the specified collection, specifying options and return the handler with MongoClientUpdateResult result

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      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:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • updateCollectionWithOptionsAndAwait

      public io.vertx.ext.mongo.MongoClientUpdateResult updateCollectionWithOptionsAndAwait(String collection, io.vertx.core.json.JsonObject query, io.vertx.core.json.JsonObject update, io.vertx.ext.mongo.UpdateOptions options)
      Blocking variant of updateCollectionWithOptions(String,JsonObject,JsonObject,UpdateOptions).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      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:
      the MongoClientUpdateResult instance produced by the operation.
    • updateCollectionWithOptionsAndForget

      public MongoClient updateCollectionWithOptionsAndForget(String collection, io.vertx.core.json.JsonObject query, io.vertx.core.json.JsonObject update, io.vertx.ext.mongo.UpdateOptions options)
      Variant of updateCollectionWithOptions(String,JsonObject,JsonObject,UpdateOptions) that ignores the result of the operation.

      This method subscribes on the result of updateCollectionWithOptions(String,JsonObject,JsonObject,UpdateOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from updateCollectionWithOptions(String,JsonObject,JsonObject,UpdateOptions) but you don't need to compose it with other operations.

      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:
      the instance of MongoClient to chain method calls.
    • updateCollectionWithOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.mongo.MongoClientUpdateResult> updateCollectionWithOptions(String collection, io.vertx.core.json.JsonObject query, io.vertx.core.json.JsonArray update, io.vertx.ext.mongo.UpdateOptions options)
      Use an aggregation pipeline to update documents in the specified collection, specifying options and return the handler with MongoClientUpdateResult result

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      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:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • updateCollectionWithOptionsAndAwait

      public io.vertx.ext.mongo.MongoClientUpdateResult updateCollectionWithOptionsAndAwait(String collection, io.vertx.core.json.JsonObject query, io.vertx.core.json.JsonArray update, io.vertx.ext.mongo.UpdateOptions options)
      Blocking variant of updateCollectionWithOptions(String,JsonObject,JsonArray,UpdateOptions).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      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:
      the MongoClientUpdateResult instance produced by the operation.
    • updateCollectionWithOptionsAndForget

      public MongoClient updateCollectionWithOptionsAndForget(String collection, io.vertx.core.json.JsonObject query, io.vertx.core.json.JsonArray update, io.vertx.ext.mongo.UpdateOptions options)
      Variant of updateCollectionWithOptions(String,JsonObject,JsonArray,UpdateOptions) that ignores the result of the operation.

      This method subscribes on the result of updateCollectionWithOptions(String,JsonObject,JsonArray,UpdateOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from updateCollectionWithOptions(String,JsonObject,JsonArray,UpdateOptions) but you don't need to compose it with other operations.

      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:
      the instance of MongoClient to chain method calls.
    • replaceDocuments

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.mongo.MongoClientUpdateResult> replaceDocuments(String collection, io.vertx.core.json.JsonObject query, io.vertx.core.json.JsonObject replace)
      Replace matching documents in the specified collection and return the handler with MongoClientUpdateResult result

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      collection - the collection
      query - query used to match the documents
      replace - all matching documents will be replaced with this
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • replaceDocumentsAndAwait

      public io.vertx.ext.mongo.MongoClientUpdateResult replaceDocumentsAndAwait(String collection, io.vertx.core.json.JsonObject query, io.vertx.core.json.JsonObject replace)
      Blocking variant of replaceDocuments(String,JsonObject,JsonObject).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      collection - the collection
      query - query used to match the documents
      replace - all matching documents will be replaced with this
      Returns:
      the MongoClientUpdateResult instance produced by the operation.
    • replaceDocumentsAndForget

      public MongoClient replaceDocumentsAndForget(String collection, io.vertx.core.json.JsonObject query, io.vertx.core.json.JsonObject replace)
      Variant of replaceDocuments(String,JsonObject,JsonObject) that ignores the result of the operation.

      This method subscribes on the result of replaceDocuments(String,JsonObject,JsonObject), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from replaceDocuments(String,JsonObject,JsonObject) but you don't need to compose it with other operations.

      Parameters:
      collection - the collection
      query - query used to match the documents
      replace - all matching documents will be replaced with this
      Returns:
      the instance of MongoClient to chain method calls.
    • replaceDocumentsWithOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.mongo.MongoClientUpdateResult> replaceDocumentsWithOptions(String collection, io.vertx.core.json.JsonObject query, io.vertx.core.json.JsonObject replace, io.vertx.ext.mongo.UpdateOptions options)
      Replace matching documents in the specified collection, specifying options and return the handler with MongoClientUpdateResult result

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      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:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • replaceDocumentsWithOptionsAndAwait

      public io.vertx.ext.mongo.MongoClientUpdateResult replaceDocumentsWithOptionsAndAwait(String collection, io.vertx.core.json.JsonObject query, io.vertx.core.json.JsonObject replace, io.vertx.ext.mongo.UpdateOptions options)
      Blocking variant of replaceDocumentsWithOptions(String,JsonObject,JsonObject,UpdateOptions).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      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:
      the MongoClientUpdateResult instance produced by the operation.
    • replaceDocumentsWithOptionsAndForget

      public MongoClient replaceDocumentsWithOptionsAndForget(String collection, io.vertx.core.json.JsonObject query, io.vertx.core.json.JsonObject replace, io.vertx.ext.mongo.UpdateOptions options)
      Variant of replaceDocumentsWithOptions(String,JsonObject,JsonObject,UpdateOptions) that ignores the result of the operation.

      This method subscribes on the result of replaceDocumentsWithOptions(String,JsonObject,JsonObject,UpdateOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from replaceDocumentsWithOptions(String,JsonObject,JsonObject,UpdateOptions) but you don't need to compose it with other operations.

      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:
      the instance of MongoClient to chain method calls.
    • bulkWrite

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.mongo.MongoClientBulkWriteResult> bulkWrite(String collection, List<io.vertx.ext.mongo.BulkOperation> operations)
      Execute a bulk operation. Can insert, update, replace, and/or delete multiple documents with one request.

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      collection - the collection
      operations - the operations to execute
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • bulkWriteAndAwait

      public io.vertx.ext.mongo.MongoClientBulkWriteResult bulkWriteAndAwait(String collection, List<io.vertx.ext.mongo.BulkOperation> operations)
      Blocking variant of bulkWrite(String,List).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      collection - the collection
      operations - the operations to execute
      Returns:
      the MongoClientBulkWriteResult instance produced by the operation.
    • bulkWriteAndForget

      public MongoClient bulkWriteAndForget(String collection, List<io.vertx.ext.mongo.BulkOperation> operations)
      Variant of bulkWrite(String,List) that ignores the result of the operation.

      This method subscribes on the result of bulkWrite(String,List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from bulkWrite(String,List) but you don't need to compose it with other operations.

      Parameters:
      collection - the collection
      operations - the operations to execute
      Returns:
      the instance of MongoClient to chain method calls.
    • bulkWriteWithOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.mongo.MongoClientBulkWriteResult> bulkWriteWithOptions(String collection, List<io.vertx.ext.mongo.BulkOperation> operations, io.vertx.ext.mongo.BulkWriteOptions bulkWriteOptions)
      Execute a bulk operation with the specified write options. Can insert, update, replace, and/or delete multiple documents with one request.

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      collection - the collection
      operations - the operations to execute
      bulkWriteOptions - the write options
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • bulkWriteWithOptionsAndAwait

      public io.vertx.ext.mongo.MongoClientBulkWriteResult bulkWriteWithOptionsAndAwait(String collection, List<io.vertx.ext.mongo.BulkOperation> operations, io.vertx.ext.mongo.BulkWriteOptions bulkWriteOptions)
      Blocking variant of bulkWriteWithOptions(String,List,BulkWriteOptions).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      collection - the collection
      operations - the operations to execute
      bulkWriteOptions - the write options
      Returns:
      the MongoClientBulkWriteResult instance produced by the operation.
    • bulkWriteWithOptionsAndForget

      public MongoClient bulkWriteWithOptionsAndForget(String collection, List<io.vertx.ext.mongo.BulkOperation> operations, io.vertx.ext.mongo.BulkWriteOptions bulkWriteOptions)
      Variant of bulkWriteWithOptions(String,List,BulkWriteOptions) that ignores the result of the operation.

      This method subscribes on the result of bulkWriteWithOptions(String,List,BulkWriteOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from bulkWriteWithOptions(String,List,BulkWriteOptions) but you don't need to compose it with other operations.

      Parameters:
      collection - the collection
      operations - the operations to execute
      bulkWriteOptions - the write options
      Returns:
      the instance of MongoClient to chain method calls.
    • find

      @CheckReturnValue public io.smallrye.mutiny.Uni<List<io.vertx.core.json.JsonObject>> find(String collection, io.vertx.core.json.JsonObject query)
      Find matching documents in the specified collection

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      collection - the collection
      query - query used to match documents
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • findAndAwait

      public List<io.vertx.core.json.JsonObject> findAndAwait(String collection, io.vertx.core.json.JsonObject query)
      Blocking variant of find(String,JsonObject).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      collection - the collection
      query - query used to match documents
      Returns:
      the List instance produced by the operation.
    • findAndForget

      public MongoClient findAndForget(String collection, io.vertx.core.json.JsonObject query)
      Variant of find(String,JsonObject) that ignores the result of the operation.

      This method subscribes on the result of find(String,JsonObject), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from find(String,JsonObject) but you don't need to compose it with other operations.

      Parameters:
      collection - the collection
      query - query used to match documents
      Returns:
      the instance of MongoClient to chain method calls.
    • findBatch

      public ReadStream<io.vertx.core.json.JsonObject> findBatch(String collection, io.vertx.core.json.JsonObject query)
      Parameters:
      collection - the collection
      query - query used to match documents
      Returns:
      a emitting found documents
    • findWithOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<List<io.vertx.core.json.JsonObject>> findWithOptions(String collection, io.vertx.core.json.JsonObject query, io.vertx.ext.mongo.FindOptions options)
      Find matching documents in the specified collection, specifying options

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      collection - the collection
      query - query used to match documents
      options - options to configure the find
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • findWithOptionsAndAwait

      public List<io.vertx.core.json.JsonObject> findWithOptionsAndAwait(String collection, io.vertx.core.json.JsonObject query, io.vertx.ext.mongo.FindOptions options)
      Blocking variant of findWithOptions(String,JsonObject,FindOptions).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      collection - the collection
      query - query used to match documents
      options - options to configure the find
      Returns:
      the List instance produced by the operation.
    • findWithOptionsAndForget

      public MongoClient findWithOptionsAndForget(String collection, io.vertx.core.json.JsonObject query, io.vertx.ext.mongo.FindOptions options)
      Variant of findWithOptions(String,JsonObject,FindOptions) that ignores the result of the operation.

      This method subscribes on the result of findWithOptions(String,JsonObject,FindOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from findWithOptions(String,JsonObject,FindOptions) but you don't need to compose it with other operations.

      Parameters:
      collection - the collection
      query - query used to match documents
      options - options to configure the find
      Returns:
      the instance of MongoClient to chain method calls.
    • findBatchWithOptions

      public ReadStream<io.vertx.core.json.JsonObject> findBatchWithOptions(String collection, io.vertx.core.json.JsonObject query, io.vertx.ext.mongo.FindOptions options)
      Parameters:
      collection - the collection
      query - query used to match documents
      options - options to configure the find
      Returns:
      a emitting found documents
    • findOne

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.core.json.JsonObject> findOne(String collection, io.vertx.core.json.JsonObject query, io.vertx.core.json.JsonObject fields)
      Find a single matching document in the specified collection

      This operation might change _id field of query parameter

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      collection - the collection
      query - the query used to match the document
      fields - the fields
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • findOneAndAwait

      public io.vertx.core.json.JsonObject findOneAndAwait(String collection, io.vertx.core.json.JsonObject query, io.vertx.core.json.JsonObject fields)
      Blocking variant of findOne(String,JsonObject,JsonObject).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      collection - the collection
      query - the query used to match the document
      fields - the fields
      Returns:
      the JsonObject instance produced by the operation.
    • findOneAndForget

      public MongoClient findOneAndForget(String collection, io.vertx.core.json.JsonObject query, io.vertx.core.json.JsonObject fields)
      Variant of findOne(String,JsonObject,JsonObject) that ignores the result of the operation.

      This method subscribes on the result of findOne(String,JsonObject,JsonObject), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from findOne(String,JsonObject,JsonObject) but you don't need to compose it with other operations.

      Parameters:
      collection - the collection
      query - the query used to match the document
      fields - the fields
      Returns:
      the instance of MongoClient to chain method calls.
    • findOneAndUpdate

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.core.json.JsonObject> findOneAndUpdate(String collection, io.vertx.core.json.JsonObject query, io.vertx.core.json.JsonObject update)
      Find a single matching document in the specified collection and update it.

      This operation might change _id field of query parameter

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      collection - the collection
      query - the query used to match the document
      update - used to describe how the documents will be updated
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • findOneAndUpdateAndAwait

      public io.vertx.core.json.JsonObject findOneAndUpdateAndAwait(String collection, io.vertx.core.json.JsonObject query, io.vertx.core.json.JsonObject update)
      Blocking variant of findOneAndUpdate(String,JsonObject,JsonObject).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      collection - the collection
      query - the query used to match the document
      update - used to describe how the documents will be updated
      Returns:
      the JsonObject instance produced by the operation.
    • findOneAndUpdateAndForget

      public MongoClient findOneAndUpdateAndForget(String collection, io.vertx.core.json.JsonObject query, io.vertx.core.json.JsonObject update)
      Variant of findOneAndUpdate(String,JsonObject,JsonObject) that ignores the result of the operation.

      This method subscribes on the result of findOneAndUpdate(String,JsonObject,JsonObject), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from findOneAndUpdate(String,JsonObject,JsonObject) but you don't need to compose it with other operations.

      Parameters:
      collection - the collection
      query - the query used to match the document
      update - used to describe how the documents will be updated
      Returns:
      the instance of MongoClient to chain method calls.
    • findOneAndUpdateWithOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.core.json.JsonObject> findOneAndUpdateWithOptions(String collection, io.vertx.core.json.JsonObject query, io.vertx.core.json.JsonObject update, io.vertx.ext.mongo.FindOptions findOptions, io.vertx.ext.mongo.UpdateOptions updateOptions)
      Find a single matching document in the specified collection and update it.

      This operation might change _id field of query parameter

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      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:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • findOneAndUpdateWithOptionsAndAwait

      public io.vertx.core.json.JsonObject findOneAndUpdateWithOptionsAndAwait(String collection, io.vertx.core.json.JsonObject query, io.vertx.core.json.JsonObject update, io.vertx.ext.mongo.FindOptions findOptions, io.vertx.ext.mongo.UpdateOptions updateOptions)
      Blocking variant of findOneAndUpdateWithOptions(String,JsonObject,JsonObject,FindOptions,UpdateOptions).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      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:
      the JsonObject instance produced by the operation.
    • findOneAndUpdateWithOptionsAndForget

      public MongoClient findOneAndUpdateWithOptionsAndForget(String collection, io.vertx.core.json.JsonObject query, io.vertx.core.json.JsonObject update, io.vertx.ext.mongo.FindOptions findOptions, io.vertx.ext.mongo.UpdateOptions updateOptions)
      Variant of findOneAndUpdateWithOptions(String,JsonObject,JsonObject,FindOptions,UpdateOptions) that ignores the result of the operation.

      This method subscribes on the result of findOneAndUpdateWithOptions(String,JsonObject,JsonObject,FindOptions,UpdateOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from findOneAndUpdateWithOptions(String,JsonObject,JsonObject,FindOptions,UpdateOptions) but you don't need to compose it with other operations.

      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:
      the instance of MongoClient to chain method calls.
    • findOneAndReplace

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.core.json.JsonObject> findOneAndReplace(String collection, io.vertx.core.json.JsonObject query, io.vertx.core.json.JsonObject replace)
      Find a single matching document in the specified collection and replace it.

      This operation might change _id field of query parameter

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      collection - the collection
      query - the query used to match the document
      replace - the replacement document
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • findOneAndReplaceAndAwait

      public io.vertx.core.json.JsonObject findOneAndReplaceAndAwait(String collection, io.vertx.core.json.JsonObject query, io.vertx.core.json.JsonObject replace)
      Blocking variant of findOneAndReplace(String,JsonObject,JsonObject).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      collection - the collection
      query - the query used to match the document
      replace - the replacement document
      Returns:
      the JsonObject instance produced by the operation.
    • findOneAndReplaceAndForget

      public MongoClient findOneAndReplaceAndForget(String collection, io.vertx.core.json.JsonObject query, io.vertx.core.json.JsonObject replace)
      Variant of findOneAndReplace(String,JsonObject,JsonObject) that ignores the result of the operation.

      This method subscribes on the result of findOneAndReplace(String,JsonObject,JsonObject), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from findOneAndReplace(String,JsonObject,JsonObject) but you don't need to compose it with other operations.

      Parameters:
      collection - the collection
      query - the query used to match the document
      replace - the replacement document
      Returns:
      the instance of MongoClient to chain method calls.
    • findOneAndReplaceWithOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.core.json.JsonObject> findOneAndReplaceWithOptions(String collection, io.vertx.core.json.JsonObject query, io.vertx.core.json.JsonObject replace, io.vertx.ext.mongo.FindOptions findOptions, io.vertx.ext.mongo.UpdateOptions updateOptions)
      Find a single matching document in the specified collection and replace it.

      This operation might change _id field of query parameter

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      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:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • findOneAndReplaceWithOptionsAndAwait

      public io.vertx.core.json.JsonObject findOneAndReplaceWithOptionsAndAwait(String collection, io.vertx.core.json.JsonObject query, io.vertx.core.json.JsonObject replace, io.vertx.ext.mongo.FindOptions findOptions, io.vertx.ext.mongo.UpdateOptions updateOptions)
      Blocking variant of findOneAndReplaceWithOptions(String,JsonObject,JsonObject,FindOptions,UpdateOptions).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      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:
      the JsonObject instance produced by the operation.
    • findOneAndReplaceWithOptionsAndForget

      public MongoClient findOneAndReplaceWithOptionsAndForget(String collection, io.vertx.core.json.JsonObject query, io.vertx.core.json.JsonObject replace, io.vertx.ext.mongo.FindOptions findOptions, io.vertx.ext.mongo.UpdateOptions updateOptions)
      Variant of findOneAndReplaceWithOptions(String,JsonObject,JsonObject,FindOptions,UpdateOptions) that ignores the result of the operation.

      This method subscribes on the result of findOneAndReplaceWithOptions(String,JsonObject,JsonObject,FindOptions,UpdateOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from findOneAndReplaceWithOptions(String,JsonObject,JsonObject,FindOptions,UpdateOptions) but you don't need to compose it with other operations.

      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:
      the instance of MongoClient to chain method calls.
    • findOneAndDelete

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.core.json.JsonObject> findOneAndDelete(String collection, io.vertx.core.json.JsonObject query)
      Find a single matching document in the specified collection and delete it.

      This operation might change _id field of query parameter

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      collection - the collection
      query - the query used to match the document
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • findOneAndDeleteAndAwait

      public io.vertx.core.json.JsonObject findOneAndDeleteAndAwait(String collection, io.vertx.core.json.JsonObject query)
      Blocking variant of findOneAndDelete(String,JsonObject).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      collection - the collection
      query - the query used to match the document
      Returns:
      the JsonObject instance produced by the operation.
    • findOneAndDeleteAndForget

      public MongoClient findOneAndDeleteAndForget(String collection, io.vertx.core.json.JsonObject query)
      Variant of findOneAndDelete(String,JsonObject) that ignores the result of the operation.

      This method subscribes on the result of findOneAndDelete(String,JsonObject), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from findOneAndDelete(String,JsonObject) but you don't need to compose it with other operations.

      Parameters:
      collection - the collection
      query - the query used to match the document
      Returns:
      the instance of MongoClient to chain method calls.
    • findOneAndDeleteWithOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.core.json.JsonObject> findOneAndDeleteWithOptions(String collection, io.vertx.core.json.JsonObject query, io.vertx.ext.mongo.FindOptions findOptions)
      Find a single matching document in the specified collection and delete it.

      This operation might change _id field of query parameter

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      collection - the collection
      query - the query used to match the document
      findOptions - options to configure the find
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • findOneAndDeleteWithOptionsAndAwait

      public io.vertx.core.json.JsonObject findOneAndDeleteWithOptionsAndAwait(String collection, io.vertx.core.json.JsonObject query, io.vertx.ext.mongo.FindOptions findOptions)
      Blocking variant of findOneAndDeleteWithOptions(String,JsonObject,FindOptions).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      collection - the collection
      query - the query used to match the document
      findOptions - options to configure the find
      Returns:
      the JsonObject instance produced by the operation.
    • findOneAndDeleteWithOptionsAndForget

      public MongoClient findOneAndDeleteWithOptionsAndForget(String collection, io.vertx.core.json.JsonObject query, io.vertx.ext.mongo.FindOptions findOptions)
      Variant of findOneAndDeleteWithOptions(String,JsonObject,FindOptions) that ignores the result of the operation.

      This method subscribes on the result of findOneAndDeleteWithOptions(String,JsonObject,FindOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from findOneAndDeleteWithOptions(String,JsonObject,FindOptions) but you don't need to compose it with other operations.

      Parameters:
      collection - the collection
      query - the query used to match the document
      findOptions - options to configure the find
      Returns:
      the instance of MongoClient to chain method calls.
    • count

      @CheckReturnValue public io.smallrye.mutiny.Uni<Long> count(String collection, io.vertx.core.json.JsonObject query)
      Count matching documents in a collection.

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      collection - the collection
      query - query used to match documents
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • countAndAwait

      public Long countAndAwait(String collection, io.vertx.core.json.JsonObject query)
      Blocking variant of count(String,JsonObject).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      collection - the collection
      query - query used to match documents
      Returns:
      the Long instance produced by the operation.
    • countAndForget

      public MongoClient countAndForget(String collection, io.vertx.core.json.JsonObject query)
      Variant of count(String,JsonObject) that ignores the result of the operation.

      This method subscribes on the result of count(String,JsonObject), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from count(String,JsonObject) but you don't need to compose it with other operations.

      Parameters:
      collection - the collection
      query - query used to match documents
      Returns:
      the instance of MongoClient to chain method calls.
    • countWithOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<Long> countWithOptions(String collection, io.vertx.core.json.JsonObject query, io.vertx.ext.mongo.CountOptions countOptions)
      Count matching documents in a collection.

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      collection - the collection
      query - query used to match documents
      countOptions -
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • countWithOptionsAndAwait

      public Long countWithOptionsAndAwait(String collection, io.vertx.core.json.JsonObject query, io.vertx.ext.mongo.CountOptions countOptions)
      Blocking variant of countWithOptions(String,JsonObject,CountOptions).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      collection - the collection
      query - query used to match documents
      countOptions -
      Returns:
      the Long instance produced by the operation.
    • countWithOptionsAndForget

      public MongoClient countWithOptionsAndForget(String collection, io.vertx.core.json.JsonObject query, io.vertx.ext.mongo.CountOptions countOptions)
      Variant of countWithOptions(String,JsonObject,CountOptions) that ignores the result of the operation.

      This method subscribes on the result of countWithOptions(String,JsonObject,CountOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from countWithOptions(String,JsonObject,CountOptions) but you don't need to compose it with other operations.

      Parameters:
      collection - the collection
      query - query used to match documents
      countOptions -
      Returns:
      the instance of MongoClient to chain method calls.
    • removeDocuments

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.mongo.MongoClientDeleteResult> removeDocuments(String collection, io.vertx.core.json.JsonObject query)
      Remove matching documents from a collection and return the handler with MongoClientDeleteResult result

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      collection - the collection
      query - query used to match documents
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • removeDocumentsAndAwait

      public io.vertx.ext.mongo.MongoClientDeleteResult removeDocumentsAndAwait(String collection, io.vertx.core.json.JsonObject query)
      Blocking variant of removeDocuments(String,JsonObject).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      collection - the collection
      query - query used to match documents
      Returns:
      the MongoClientDeleteResult instance produced by the operation.
    • removeDocumentsAndForget

      public MongoClient removeDocumentsAndForget(String collection, io.vertx.core.json.JsonObject query)
      Variant of removeDocuments(String,JsonObject) that ignores the result of the operation.

      This method subscribes on the result of removeDocuments(String,JsonObject), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from removeDocuments(String,JsonObject) but you don't need to compose it with other operations.

      Parameters:
      collection - the collection
      query - query used to match documents
      Returns:
      the instance of MongoClient to chain method calls.
    • removeDocumentsWithOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.mongo.MongoClientDeleteResult> removeDocumentsWithOptions(String collection, io.vertx.core.json.JsonObject query, io.vertx.ext.mongo.WriteOption writeOption)
      Remove matching documents from a collection with the specified write option and return the handler with MongoClientDeleteResult result

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      collection - the collection
      query - query used to match documents
      writeOption - the write option to use
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • removeDocumentsWithOptionsAndAwait

      public io.vertx.ext.mongo.MongoClientDeleteResult removeDocumentsWithOptionsAndAwait(String collection, io.vertx.core.json.JsonObject query, io.vertx.ext.mongo.WriteOption writeOption)
      Blocking variant of removeDocumentsWithOptions(String,JsonObject,WriteOption).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      collection - the collection
      query - query used to match documents
      writeOption - the write option to use
      Returns:
      the MongoClientDeleteResult instance produced by the operation.
    • removeDocumentsWithOptionsAndForget

      public MongoClient removeDocumentsWithOptionsAndForget(String collection, io.vertx.core.json.JsonObject query, io.vertx.ext.mongo.WriteOption writeOption)
      Variant of removeDocumentsWithOptions(String,JsonObject,WriteOption) that ignores the result of the operation.

      This method subscribes on the result of removeDocumentsWithOptions(String,JsonObject,WriteOption), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from removeDocumentsWithOptions(String,JsonObject,WriteOption) but you don't need to compose it with other operations.

      Parameters:
      collection - the collection
      query - query used to match documents
      writeOption - the write option to use
      Returns:
      the instance of MongoClient to chain method calls.
    • removeDocument

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.mongo.MongoClientDeleteResult> removeDocument(String collection, io.vertx.core.json.JsonObject query)
      Remove a single matching document from a collection and return the handler with MongoClientDeleteResult result

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      collection - the collection
      query - query used to match document
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • removeDocumentAndAwait

      public io.vertx.ext.mongo.MongoClientDeleteResult removeDocumentAndAwait(String collection, io.vertx.core.json.JsonObject query)
      Blocking variant of removeDocument(String,JsonObject).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      collection - the collection
      query - query used to match document
      Returns:
      the MongoClientDeleteResult instance produced by the operation.
    • removeDocumentAndForget

      public MongoClient removeDocumentAndForget(String collection, io.vertx.core.json.JsonObject query)
      Variant of removeDocument(String,JsonObject) that ignores the result of the operation.

      This method subscribes on the result of removeDocument(String,JsonObject), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from removeDocument(String,JsonObject) but you don't need to compose it with other operations.

      Parameters:
      collection - the collection
      query - query used to match document
      Returns:
      the instance of MongoClient to chain method calls.
    • removeDocumentWithOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.mongo.MongoClientDeleteResult> removeDocumentWithOptions(String collection, io.vertx.core.json.JsonObject query, io.vertx.ext.mongo.WriteOption writeOption)
      Remove a single matching document from a collection with the specified write option and return the handler with MongoClientDeleteResult result

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      collection - the collection
      query - query used to match document
      writeOption - the write option to use
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • removeDocumentWithOptionsAndAwait

      public io.vertx.ext.mongo.MongoClientDeleteResult removeDocumentWithOptionsAndAwait(String collection, io.vertx.core.json.JsonObject query, io.vertx.ext.mongo.WriteOption writeOption)
      Blocking variant of removeDocumentWithOptions(String,JsonObject,WriteOption).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      collection - the collection
      query - query used to match document
      writeOption - the write option to use
      Returns:
      the MongoClientDeleteResult instance produced by the operation.
    • removeDocumentWithOptionsAndForget

      public MongoClient removeDocumentWithOptionsAndForget(String collection, io.vertx.core.json.JsonObject query, io.vertx.ext.mongo.WriteOption writeOption)
      Variant of removeDocumentWithOptions(String,JsonObject,WriteOption) that ignores the result of the operation.

      This method subscribes on the result of removeDocumentWithOptions(String,JsonObject,WriteOption), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from removeDocumentWithOptions(String,JsonObject,WriteOption) but you don't need to compose it with other operations.

      Parameters:
      collection - the collection
      query - query used to match document
      writeOption - the write option to use
      Returns:
      the instance of MongoClient to chain method calls.
    • createCollection

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> createCollection(String collectionName)
      Create a new collection

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      collectionName - the name of the collection
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • createCollectionAndAwait

      public Void createCollectionAndAwait(String collectionName)
      Blocking variant of createCollection(String).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      collectionName - the name of the collection
      Returns:
      the Void instance produced by the operation.
    • createCollectionAndForget

      public MongoClient createCollectionAndForget(String collectionName)
      Variant of createCollection(String) that ignores the result of the operation.

      This method subscribes on the result of createCollection(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from createCollection(String) but you don't need to compose it with other operations.

      Parameters:
      collectionName - the name of the collection
      Returns:
      the instance of MongoClient to chain method calls.
    • createCollectionWithOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> createCollectionWithOptions(String collectionName, io.vertx.ext.mongo.CreateCollectionOptions collectionOptions)
      Create a new collection with options

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      collectionName - the name of the collection
      collectionOptions - options of the collection
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • createCollectionWithOptionsAndAwait

      public Void createCollectionWithOptionsAndAwait(String collectionName, io.vertx.ext.mongo.CreateCollectionOptions collectionOptions)
      Blocking variant of createCollectionWithOptions(String,CreateCollectionOptions).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      collectionName - the name of the collection
      collectionOptions - options of the collection
      Returns:
      the Void instance produced by the operation.
    • createCollectionWithOptionsAndForget

      public MongoClient createCollectionWithOptionsAndForget(String collectionName, io.vertx.ext.mongo.CreateCollectionOptions collectionOptions)
      Variant of createCollectionWithOptions(String,CreateCollectionOptions) that ignores the result of the operation.

      This method subscribes on the result of createCollectionWithOptions(String,CreateCollectionOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from createCollectionWithOptions(String,CreateCollectionOptions) but you don't need to compose it with other operations.

      Parameters:
      collectionName - the name of the collection
      collectionOptions - options of the collection
      Returns:
      the instance of MongoClient to chain method calls.
    • getCollections

      @CheckReturnValue public io.smallrye.mutiny.Uni<List<String>> getCollections()
      Get a list of all collections in the database.

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • getCollectionsAndAwait

      public List<String> getCollectionsAndAwait()
      Blocking variant of getCollections().

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Returns:
      the List instance produced by the operation.
    • getCollectionsAndForget

      public MongoClient getCollectionsAndForget()
      Variant of getCollections() that ignores the result of the operation.

      This method subscribes on the result of getCollections(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from getCollections() but you don't need to compose it with other operations.

      Returns:
      the instance of MongoClient to chain method calls.
    • dropCollection

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> dropCollection(String collection)
      Drop a collection

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      collection - the collection
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • dropCollectionAndAwait

      public Void dropCollectionAndAwait(String collection)
      Blocking variant of dropCollection(String).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      collection - the collection
      Returns:
      the Void instance produced by the operation.
    • dropCollectionAndForget

      public MongoClient dropCollectionAndForget(String collection)
      Variant of dropCollection(String) that ignores the result of the operation.

      This method subscribes on the result of dropCollection(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from dropCollection(String) but you don't need to compose it with other operations.

      Parameters:
      collection - the collection
      Returns:
      the instance of MongoClient to chain method calls.
    • createIndex

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> createIndex(String collection, io.vertx.core.json.JsonObject key)
      Creates an index.

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      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:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • createIndexAndAwait

      public Void createIndexAndAwait(String collection, io.vertx.core.json.JsonObject key)
      Blocking variant of createIndex(String,JsonObject).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      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:
      the Void instance produced by the operation.
    • createIndexAndForget

      public MongoClient createIndexAndForget(String collection, io.vertx.core.json.JsonObject key)
      Variant of createIndex(String,JsonObject) that ignores the result of the operation.

      This method subscribes on the result of createIndex(String,JsonObject), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from createIndex(String,JsonObject) but you don't need to compose it with other operations.

      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:
      the instance of MongoClient to chain method calls.
    • createIndexWithOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> createIndexWithOptions(String collection, io.vertx.core.json.JsonObject key, io.vertx.ext.mongo.IndexOptions options)
      Creates an index.

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      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:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • createIndexWithOptionsAndAwait

      public Void createIndexWithOptionsAndAwait(String collection, io.vertx.core.json.JsonObject key, io.vertx.ext.mongo.IndexOptions options)
      Blocking variant of createIndexWithOptions(String,JsonObject,IndexOptions).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      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:
      the Void instance produced by the operation.
    • createIndexWithOptionsAndForget

      public MongoClient createIndexWithOptionsAndForget(String collection, io.vertx.core.json.JsonObject key, io.vertx.ext.mongo.IndexOptions options)
      Variant of createIndexWithOptions(String,JsonObject,IndexOptions) that ignores the result of the operation.

      This method subscribes on the result of createIndexWithOptions(String,JsonObject,IndexOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from createIndexWithOptions(String,JsonObject,IndexOptions) but you don't need to compose it with other operations.

      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:
      the instance of MongoClient to chain method calls.
    • createIndexes

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> createIndexes(String collection, List<io.vertx.ext.mongo.IndexModel> indexes)
      creates an indexes

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      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:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • createIndexesAndAwait

      public Void createIndexesAndAwait(String collection, List<io.vertx.ext.mongo.IndexModel> indexes)
      Blocking variant of createIndexes(String,List).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      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:
      the Void instance produced by the operation.
    • createIndexesAndForget

      public MongoClient createIndexesAndForget(String collection, List<io.vertx.ext.mongo.IndexModel> indexes)
      Variant of createIndexes(String,List) that ignores the result of the operation.

      This method subscribes on the result of createIndexes(String,List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from createIndexes(String,List) but you don't need to compose it with other operations.

      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:
      the instance of MongoClient to chain method calls.
    • listIndexes

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.core.json.JsonArray> listIndexes(String collection)
      Get all the indexes in this collection.

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      collection - the collection
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • listIndexesAndAwait

      public io.vertx.core.json.JsonArray listIndexesAndAwait(String collection)
      Blocking variant of listIndexes(String).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      collection - the collection
      Returns:
      the JsonArray instance produced by the operation.
    • listIndexesAndForget

      public MongoClient listIndexesAndForget(String collection)
      Variant of listIndexes(String) that ignores the result of the operation.

      This method subscribes on the result of listIndexes(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from listIndexes(String) but you don't need to compose it with other operations.

      Parameters:
      collection - the collection
      Returns:
      the instance of MongoClient to chain method calls.
    • dropIndex

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> dropIndex(String collection, String indexName)
      Drops the index given its name.

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      collection - the collection
      indexName - the name of the index to remove
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • dropIndexAndAwait

      public Void dropIndexAndAwait(String collection, String indexName)
      Blocking variant of dropIndex(String,String).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      collection - the collection
      indexName - the name of the index to remove
      Returns:
      the Void instance produced by the operation.
    • dropIndexAndForget

      public MongoClient dropIndexAndForget(String collection, String indexName)
      Variant of dropIndex(String,String) that ignores the result of the operation.

      This method subscribes on the result of dropIndex(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from dropIndex(String,String) but you don't need to compose it with other operations.

      Parameters:
      collection - the collection
      indexName - the name of the index to remove
      Returns:
      the instance of MongoClient to chain method calls.
    • runCommand

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.core.json.JsonObject> runCommand(String commandName, io.vertx.core.json.JsonObject command)
      Run an arbitrary MongoDB command.

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      commandName - the name of the command
      command - the command
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • runCommandAndAwait

      public io.vertx.core.json.JsonObject runCommandAndAwait(String commandName, io.vertx.core.json.JsonObject command)
      Blocking variant of runCommand(String,JsonObject).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      commandName - the name of the command
      command - the command
      Returns:
      the JsonObject instance produced by the operation.
    • runCommandAndForget

      public MongoClient runCommandAndForget(String commandName, io.vertx.core.json.JsonObject command)
      Variant of runCommand(String,JsonObject) that ignores the result of the operation.

      This method subscribes on the result of runCommand(String,JsonObject), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from runCommand(String,JsonObject) but you don't need to compose it with other operations.

      Parameters:
      commandName - the name of the command
      command - the command
      Returns:
      the instance of MongoClient to chain method calls.
    • distinct

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.core.json.JsonArray> 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 ])

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      collection - the collection
      fieldName - the field name
      resultClassname -
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • distinctAndAwait

      public io.vertx.core.json.JsonArray distinctAndAwait(String collection, String fieldName, String resultClassname)
      Blocking variant of distinct(String,String,String).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      collection - the collection
      fieldName - the field name
      resultClassname -
      Returns:
      the JsonArray instance produced by the operation.
    • distinctAndForget

      public MongoClient distinctAndForget(String collection, String fieldName, String resultClassname)
      Variant of distinct(String,String,String) that ignores the result of the operation.

      This method subscribes on the result of distinct(String,String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from distinct(String,String,String) but you don't need to compose it with other operations.

      Parameters:
      collection - the collection
      fieldName - the field name
      resultClassname -
      Returns:
      the instance of MongoClient to chain method calls.
    • distinct

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.core.json.JsonArray> distinct(String collection, String fieldName, String resultClassname, io.vertx.ext.mongo.DistinctOptions distinctOptions)
      Gets the distinct values of the specified field name. Return a JsonArray containing distinct values (eg: [ 1 , 89 ])

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      collection - the collection
      fieldName - the field name
      resultClassname -
      distinctOptions - options (e.g. collation)
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • distinctAndAwait

      public io.vertx.core.json.JsonArray distinctAndAwait(String collection, String fieldName, String resultClassname, io.vertx.ext.mongo.DistinctOptions distinctOptions)
      Blocking variant of distinct(String,String,String,DistinctOptions).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      collection - the collection
      fieldName - the field name
      resultClassname -
      distinctOptions - options (e.g. collation)
      Returns:
      the JsonArray instance produced by the operation.
    • distinctAndForget

      public MongoClient distinctAndForget(String collection, String fieldName, String resultClassname, io.vertx.ext.mongo.DistinctOptions distinctOptions)
      Variant of distinct(String,String,String,DistinctOptions) that ignores the result of the operation.

      This method subscribes on the result of distinct(String,String,String,DistinctOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from distinct(String,String,String,DistinctOptions) but you don't need to compose it with other operations.

      Parameters:
      collection - the collection
      fieldName - the field name
      resultClassname -
      distinctOptions - options (e.g. collation)
      Returns:
      the instance of MongoClient to chain method calls.
    • distinctWithQuery

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.core.json.JsonArray> distinctWithQuery(String collection, String fieldName, String resultClassname, io.vertx.core.json.JsonObject query)
      Gets the distinct values of the specified field name filtered by specified query. Return a JsonArray containing distinct values (eg: [ 1 , 89 ])

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      collection - the collection
      fieldName - the field name
      resultClassname -
      query - the query
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • distinctWithQueryAndAwait

      public io.vertx.core.json.JsonArray distinctWithQueryAndAwait(String collection, String fieldName, String resultClassname, io.vertx.core.json.JsonObject query)
      Blocking variant of distinctWithQuery(String,String,String,JsonObject).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      collection - the collection
      fieldName - the field name
      resultClassname -
      query - the query
      Returns:
      the JsonArray instance produced by the operation.
    • distinctWithQueryAndForget

      public MongoClient distinctWithQueryAndForget(String collection, String fieldName, String resultClassname, io.vertx.core.json.JsonObject query)
      Variant of distinctWithQuery(String,String,String,JsonObject) that ignores the result of the operation.

      This method subscribes on the result of distinctWithQuery(String,String,String,JsonObject), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from distinctWithQuery(String,String,String,JsonObject) but you don't need to compose it with other operations.

      Parameters:
      collection - the collection
      fieldName - the field name
      resultClassname -
      query - the query
      Returns:
      the instance of MongoClient to chain method calls.
    • distinctWithQuery

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.core.json.JsonArray> distinctWithQuery(String collection, String fieldName, String resultClassname, io.vertx.core.json.JsonObject query, io.vertx.ext.mongo.DistinctOptions distinctOptions)
      Gets the distinct values of the specified field name filtered by specified query. Return a JsonArray containing distinct values (eg: [ 1 , 89 ])

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      collection - the collection
      fieldName - the field name
      resultClassname -
      query - the query
      distinctOptions - options (e.g. collation)
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • distinctWithQueryAndAwait

      public io.vertx.core.json.JsonArray distinctWithQueryAndAwait(String collection, String fieldName, String resultClassname, io.vertx.core.json.JsonObject query, io.vertx.ext.mongo.DistinctOptions distinctOptions)
      Blocking variant of distinctWithQuery(String,String,String,JsonObject,DistinctOptions).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      collection - the collection
      fieldName - the field name
      resultClassname -
      query - the query
      distinctOptions - options (e.g. collation)
      Returns:
      the JsonArray instance produced by the operation.
    • distinctWithQueryAndForget

      public MongoClient distinctWithQueryAndForget(String collection, String fieldName, String resultClassname, io.vertx.core.json.JsonObject query, io.vertx.ext.mongo.DistinctOptions distinctOptions)
      Variant of distinctWithQuery(String,String,String,JsonObject,DistinctOptions) that ignores the result of the operation.

      This method subscribes on the result of distinctWithQuery(String,String,String,JsonObject,DistinctOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from distinctWithQuery(String,String,String,JsonObject,DistinctOptions) but you don't need to compose it with other operations.

      Parameters:
      collection - the collection
      fieldName - the field name
      resultClassname -
      query - the query
      distinctOptions - options (e.g. collation)
      Returns:
      the instance of MongoClient to chain method calls.
    • distinctBatch

      public ReadStream<io.vertx.core.json.JsonObject> distinctBatch(String collection, String fieldName, String resultClassname)
      Parameters:
      collection - the collection
      fieldName - the field name
      resultClassname -
      Returns:
      a emitting json fragments
    • distinctBatch

      public ReadStream<io.vertx.core.json.JsonObject> distinctBatch(String collection, String fieldName, String resultClassname, io.vertx.ext.mongo.DistinctOptions distinctOptions)
      Parameters:
      collection - the collection
      fieldName - the field name
      resultClassname -
      distinctOptions - options (e.g. collation)
      Returns:
      a emitting json fragments
    • distinctBatchWithQuery

      public ReadStream<io.vertx.core.json.JsonObject> distinctBatchWithQuery(String collection, String fieldName, String resultClassname, io.vertx.core.json.JsonObject query)
      Parameters:
      collection - the collection
      fieldName - the field name
      resultClassname -
      query - the query
      Returns:
      a emitting json fragments
    • distinctBatchWithQuery

      public ReadStream<io.vertx.core.json.JsonObject> distinctBatchWithQuery(String collection, String fieldName, String resultClassname, io.vertx.core.json.JsonObject query, io.vertx.ext.mongo.DistinctOptions distinctOptions)
      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<io.vertx.core.json.JsonObject> distinctBatchWithQuery(String collection, String fieldName, String resultClassname, io.vertx.core.json.JsonObject query, int batchSize)
      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<io.vertx.core.json.JsonObject> distinctBatchWithQuery(String collection, String fieldName, String resultClassname, io.vertx.core.json.JsonObject query, int batchSize, io.vertx.ext.mongo.DistinctOptions distinctOptions)
      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<io.vertx.core.json.JsonObject> aggregate(String collection, io.vertx.core.json.JsonArray pipeline)
      Parameters:
      collection - the collection
      pipeline - aggregation pipeline to be executed
      Returns:
    • aggregateWithOptions

      public ReadStream<io.vertx.core.json.JsonObject> aggregateWithOptions(String collection, io.vertx.core.json.JsonArray pipeline, io.vertx.ext.mongo.AggregateOptions options)
      Parameters:
      collection - the collection
      pipeline - aggregation pipeline to be executed
      options - options to configure the aggregation command
      Returns:
    • createDefaultGridFsBucketService

      @CheckReturnValue public io.smallrye.mutiny.Uni<MongoGridFsClient> createDefaultGridFsBucketService()
      Creates a MongoGridFsClient used to interact with Mongo GridFS.

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • createDefaultGridFsBucketServiceAndAwait

      public MongoGridFsClient createDefaultGridFsBucketServiceAndAwait()
      Blocking variant of createDefaultGridFsBucketService().

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Returns:
      the MongoGridFsClient instance produced by the operation.
    • createDefaultGridFsBucketServiceAndForget

      public MongoClient createDefaultGridFsBucketServiceAndForget()
      Variant of createDefaultGridFsBucketService() that ignores the result of the operation.

      This method subscribes on the result of createDefaultGridFsBucketService(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from createDefaultGridFsBucketService() but you don't need to compose it with other operations.

      Returns:
      the instance of MongoClient to chain method calls.
    • createGridFsBucketService

      @CheckReturnValue public io.smallrye.mutiny.Uni<MongoGridFsClient> createGridFsBucketService(String bucketName)
      Creates a MongoGridFsClient used to interact with Mongo GridFS.

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      bucketName - the name of the GridFS bucket
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • createGridFsBucketServiceAndAwait

      public MongoGridFsClient createGridFsBucketServiceAndAwait(String bucketName)
      Blocking variant of createGridFsBucketService(String).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      bucketName - the name of the GridFS bucket
      Returns:
      the MongoGridFsClient instance produced by the operation.
    • createGridFsBucketServiceAndForget

      public MongoClient createGridFsBucketServiceAndForget(String bucketName)
      Variant of createGridFsBucketService(String) that ignores the result of the operation.

      This method subscribes on the result of createGridFsBucketService(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from createGridFsBucketService(String) but you don't need to compose it with other operations.

      Parameters:
      bucketName - the name of the GridFS bucket
      Returns:
      the instance of MongoClient to chain method calls.
    • close

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> close()
      Close the client and release its resources

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • closeAndAwait

      public Void closeAndAwait()
      Blocking variant of close().

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Returns:
      the Void instance produced by the operation.
    • closeAndForget

      public void closeAndForget()
      Variant of close() that ignores the result of the operation.

      This method subscribes on the result of close(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from close() but you don't need to compose it with other operations.

    • watch

      public ReadStream<com.mongodb.client.model.changestream.ChangeStreamDocument<io.vertx.core.json.JsonObject>> watch(String collection, io.vertx.core.json.JsonArray pipeline, boolean withUpdatedDoc, int batchSize)
      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(io.vertx.ext.mongo.MongoClient arg)