Class RedisAPI

java.lang.Object
io.vertx.mutiny.redis.client.RedisAPI
All Implemented Interfaces:
MutinyDelegate

public class RedisAPI extends Object implements MutinyDelegate
Auto generated Redis API client wrapper.

NOTE: This class has been automatically generated from the original non Mutiny-ified interface.

Version:
redis_version:8.6.2
See Also:
  • RedisAPI
  • Field Details

  • Constructor Details

    • RedisAPI

      public RedisAPI(io.vertx.redis.client.RedisAPI delegate)
      Create a new instance of RedisAPI delegating to the given (non-null) instance of RedisAPI.
    • RedisAPI

      public RedisAPI(Object delegate)
  • Method Details

    • getDelegate

      public io.vertx.redis.client.RedisAPI getDelegate()
      Get the delegate instance.

      This method returns the instance on which this shim is delegating the calls. And so, give you access to the bare API.

      Specified by:
      getDelegate in interface MutinyDelegate
      Returns:
      the delegate instance
    • ftAdd

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftAdd(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
    • ftAddAndAwait

      public io.vertx.redis.client.Response ftAddAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
    • ftAddAndForget

      public RedisAPI ftAddAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
    • ftAggregate

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftAggregate(List<String> args)
      Run a search query on an index and perform aggregate transformations on the results.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Search 1.1.0
      See Also:
    • ftAggregateAndAwait

      public io.vertx.redis.client.Response ftAggregateAndAwait(List<String> args)
      Run a search query on an index and perform aggregate transformations on the results.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Search 1.1.0
      See Also:
    • ftAggregateAndForget

      public RedisAPI ftAggregateAndForget(List<String> args)
      Run a search query on an index and perform aggregate transformations on the results.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Search 1.1.0
      See Also:
    • ftAliasadd

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftAliasadd(List<String> args)
      Adds an alias to the index.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftAliasaddAndAwait

      public io.vertx.redis.client.Response ftAliasaddAndAwait(List<String> args)
      Adds an alias to the index.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Search 1.0.0
      See Also:
    • ftAliasaddAndForget

      public RedisAPI ftAliasaddAndForget(List<String> args)
      Adds an alias to the index.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftAliasdel

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftAliasdel(List<String> args)
      Deletes an alias from the index.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftAliasdelAndAwait

      public io.vertx.redis.client.Response ftAliasdelAndAwait(List<String> args)
      Deletes an alias from the index.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Search 1.0.0
      See Also:
    • ftAliasdelAndForget

      public RedisAPI ftAliasdelAndForget(List<String> args)
      Deletes an alias from the index.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftAliasupdate

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftAliasupdate(List<String> args)
      Adds or updates an alias to the index.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftAliasupdateAndAwait

      public io.vertx.redis.client.Response ftAliasupdateAndAwait(List<String> args)
      Adds or updates an alias to the index.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Search 1.0.0
      See Also:
    • ftAliasupdateAndForget

      public RedisAPI ftAliasupdateAndForget(List<String> args)
      Adds or updates an alias to the index.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftAlter

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftAlter(List<String> args)
      Adds a new field to the index.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftAlterAndAwait

      public io.vertx.redis.client.Response ftAlterAndAwait(List<String> args)
      Adds a new field to the index.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Search 1.0.0
      See Also:
    • ftAlterAndForget

      public RedisAPI ftAlterAndForget(List<String> args)
      Adds a new field to the index.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftConfig

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftConfig(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
    • ftConfigAndAwait

      public io.vertx.redis.client.Response ftConfigAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
    • ftConfigAndForget

      public RedisAPI ftConfigAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
    • ftCreate

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftCreate(List<String> args)
      Creates an index with the given spec.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftCreateAndAwait

      public io.vertx.redis.client.Response ftCreateAndAwait(List<String> args)
      Creates an index with the given spec.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Search 1.0.0
      See Also:
    • ftCreateAndForget

      public RedisAPI ftCreateAndForget(List<String> args)
      Creates an index with the given spec.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftCursor

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftCursor(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
    • ftCursorAndAwait

      public io.vertx.redis.client.Response ftCursorAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
    • ftCursorAndForget

      public RedisAPI ftCursorAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
    • ftDebug

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftDebug(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
    • ftDebugAndAwait

      public io.vertx.redis.client.Response ftDebugAndAwait(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
    • ftDebugAndForget

      public RedisAPI ftDebugAndForget(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
    • ftDel

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftDel(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
    • ftDelAndAwait

      public io.vertx.redis.client.Response ftDelAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
    • ftDelAndForget

      public RedisAPI ftDelAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
    • ftDictadd

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftDictadd(List<String> args)
      Adds terms to a dictionary.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Search 1.4.0
      See Also:
    • ftDictaddAndAwait

      public io.vertx.redis.client.Response ftDictaddAndAwait(List<String> args)
      Adds terms to a dictionary.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Search 1.4.0
      See Also:
    • ftDictaddAndForget

      public RedisAPI ftDictaddAndForget(List<String> args)
      Adds terms to a dictionary.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Search 1.4.0
      See Also:
    • ftDictdel

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftDictdel(List<String> args)
      Deletes terms from a dictionary.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Search 1.4.0
      See Also:
    • ftDictdelAndAwait

      public io.vertx.redis.client.Response ftDictdelAndAwait(List<String> args)
      Deletes terms from a dictionary.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Search 1.4.0
      See Also:
    • ftDictdelAndForget

      public RedisAPI ftDictdelAndForget(List<String> args)
      Deletes terms from a dictionary.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Search 1.4.0
      See Also:
    • ftDictdump

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftDictdump(List<String> args)
      Dumps all terms in the given dictionary.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Search 1.4.0
      See Also:
    • ftDictdumpAndAwait

      public io.vertx.redis.client.Response ftDictdumpAndAwait(List<String> args)
      Dumps all terms in the given dictionary.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Search 1.4.0
      See Also:
    • ftDictdumpAndForget

      public RedisAPI ftDictdumpAndForget(List<String> args)
      Dumps all terms in the given dictionary.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Search 1.4.0
      See Also:
    • ftDrop

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftDrop(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
    • ftDropAndAwait

      public io.vertx.redis.client.Response ftDropAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
    • ftDropAndForget

      public RedisAPI ftDropAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
    • ftDropindex

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftDropindex(List<String> args)
      Deletes the index.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Search 2.0.0
      See Also:
    • ftDropindexAndAwait

      public io.vertx.redis.client.Response ftDropindexAndAwait(List<String> args)
      Deletes the index.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Search 2.0.0
      See Also:
    • ftDropindexAndForget

      public RedisAPI ftDropindexAndForget(List<String> args)
      Deletes the index.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Search 2.0.0
      See Also:
    • ftExplain

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftExplain(List<String> args)
      Returns the execution plan for a complex query.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftExplainAndAwait

      public io.vertx.redis.client.Response ftExplainAndAwait(List<String> args)
      Returns the execution plan for a complex query.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Search 1.0.0
      See Also:
    • ftExplainAndForget

      public RedisAPI ftExplainAndForget(List<String> args)
      Returns the execution plan for a complex query.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftExplaincli

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftExplaincli(List<String> args)
      Returns the execution plan for a complex query.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftExplaincliAndAwait

      public io.vertx.redis.client.Response ftExplaincliAndAwait(List<String> args)
      Returns the execution plan for a complex query.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Search 1.0.0
      See Also:
    • ftExplaincliAndForget

      public RedisAPI ftExplaincliAndForget(List<String> args)
      Returns the execution plan for a complex query.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftGet

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftGet(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
    • ftGetAndAwait

      public io.vertx.redis.client.Response ftGetAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
    • ftGetAndForget

      public RedisAPI ftGetAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
    • ftHybrid

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftHybrid(List<String> args)
      Performs hybrid search combining text search and vector similarity search.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Search 8.4.4
      See Also:
    • ftHybridAndAwait

      public io.vertx.redis.client.Response ftHybridAndAwait(List<String> args)
      Performs hybrid search combining text search and vector similarity search.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Search 8.4.4
      See Also:
    • ftHybridAndForget

      public RedisAPI ftHybridAndForget(List<String> args)
      Performs hybrid search combining text search and vector similarity search.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Search 8.4.4
      See Also:
    • ftInfo

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftInfo(List<String> args)
      Returns information and statistics on the index.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftInfoAndAwait

      public io.vertx.redis.client.Response ftInfoAndAwait(List<String> args)
      Returns information and statistics on the index.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Search 1.0.0
      See Also:
    • ftInfoAndForget

      public RedisAPI ftInfoAndForget(List<String> args)
      Returns information and statistics on the index.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftMget

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftMget(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
    • ftMgetAndAwait

      public io.vertx.redis.client.Response ftMgetAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
    • ftMgetAndForget

      public RedisAPI ftMgetAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
    • ftProfile

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftProfile(List<String> args)
      Performs a `FT.SEARCH` or `FT.AGGREGATE` command and collects performance information.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Search 2.2.0
      See Also:
    • ftProfileAndAwait

      public io.vertx.redis.client.Response ftProfileAndAwait(List<String> args)
      Performs a `FT.SEARCH` or `FT.AGGREGATE` command and collects performance information.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Search 2.2.0
      See Also:
    • ftProfileAndForget

      public RedisAPI ftProfileAndForget(List<String> args)
      Performs a `FT.SEARCH` or `FT.AGGREGATE` command and collects performance information.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Search 2.2.0
      See Also:
    • ftSafeadd

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftSafeadd(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
    • ftSafeaddAndAwait

      public io.vertx.redis.client.Response ftSafeaddAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
    • ftSafeaddAndForget

      public RedisAPI ftSafeaddAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
    • ftSearch

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftSearch(List<String> args)
      Searches the index with a textual query, returning either documents or just ids.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftSearchAndAwait

      public io.vertx.redis.client.Response ftSearchAndAwait(List<String> args)
      Searches the index with a textual query, returning either documents or just ids.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Search 1.0.0
      See Also:
    • ftSearchAndForget

      public RedisAPI ftSearchAndForget(List<String> args)
      Searches the index with a textual query, returning either documents or just ids.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftSpellcheck

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftSpellcheck(List<String> args)
      Performs spelling correction on a query, returning suggestions for misspelled terms.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Search 1.4.0
      See Also:
    • ftSpellcheckAndAwait

      public io.vertx.redis.client.Response ftSpellcheckAndAwait(List<String> args)
      Performs spelling correction on a query, returning suggestions for misspelled terms.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Search 1.4.0
      See Also:
    • ftSpellcheckAndForget

      public RedisAPI ftSpellcheckAndForget(List<String> args)
      Performs spelling correction on a query, returning suggestions for misspelled terms.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Search 1.4.0
      See Also:
    • ftSugadd

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftSugadd(List<String> args)
      Adds a suggestion string to an auto-complete suggestion dictionary.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftSugaddAndAwait

      public io.vertx.redis.client.Response ftSugaddAndAwait(List<String> args)
      Adds a suggestion string to an auto-complete suggestion dictionary.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Search 1.0.0
      See Also:
    • ftSugaddAndForget

      public RedisAPI ftSugaddAndForget(List<String> args)
      Adds a suggestion string to an auto-complete suggestion dictionary.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftSugdel

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftSugdel(List<String> args)
      Deletes a string from a suggestion index.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftSugdelAndAwait

      public io.vertx.redis.client.Response ftSugdelAndAwait(List<String> args)
      Deletes a string from a suggestion index.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Search 1.0.0
      See Also:
    • ftSugdelAndForget

      public RedisAPI ftSugdelAndForget(List<String> args)
      Deletes a string from a suggestion index.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftSugget

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftSugget(List<String> args)
      Gets completion suggestions for a prefix.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftSuggetAndAwait

      public io.vertx.redis.client.Response ftSuggetAndAwait(List<String> args)
      Gets completion suggestions for a prefix.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Search 1.0.0
      See Also:
    • ftSuggetAndForget

      public RedisAPI ftSuggetAndForget(List<String> args)
      Gets completion suggestions for a prefix.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftSuglen

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftSuglen(List<String> args)
      Gets the size of an auto-complete suggestion dictionary.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftSuglenAndAwait

      public io.vertx.redis.client.Response ftSuglenAndAwait(List<String> args)
      Gets the size of an auto-complete suggestion dictionary.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Search 1.0.0
      See Also:
    • ftSuglenAndForget

      public RedisAPI ftSuglenAndForget(List<String> args)
      Gets the size of an auto-complete suggestion dictionary.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftSynadd

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftSynadd(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
    • ftSynaddAndAwait

      public io.vertx.redis.client.Response ftSynaddAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
    • ftSynaddAndForget

      public RedisAPI ftSynaddAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
    • ftSyndump

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftSyndump(List<String> args)
      Dumps the contents of a synonym group.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Search 1.2.0
      See Also:
    • ftSyndumpAndAwait

      public io.vertx.redis.client.Response ftSyndumpAndAwait(List<String> args)
      Dumps the contents of a synonym group.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Search 1.2.0
      See Also:
    • ftSyndumpAndForget

      public RedisAPI ftSyndumpAndForget(List<String> args)
      Dumps the contents of a synonym group.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Search 1.2.0
      See Also:
    • ftSynupdate

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftSynupdate(List<String> args)
      Creates or updates a synonym group with additional terms.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Search 1.2.0
      See Also:
    • ftSynupdateAndAwait

      public io.vertx.redis.client.Response ftSynupdateAndAwait(List<String> args)
      Creates or updates a synonym group with additional terms.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Search 1.2.0
      See Also:
    • ftSynupdateAndForget

      public RedisAPI ftSynupdateAndForget(List<String> args)
      Creates or updates a synonym group with additional terms.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Search 1.2.0
      See Also:
    • ftTagvals

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftTagvals(List<String> args)
      Returns the distinct tags indexed in a Tag field.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftTagvalsAndAwait

      public io.vertx.redis.client.Response ftTagvalsAndAwait(List<String> args)
      Returns the distinct tags indexed in a Tag field.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Search 1.0.0
      See Also:
    • ftTagvalsAndForget

      public RedisAPI ftTagvalsAndForget(List<String> args)
      Returns the distinct tags indexed in a Tag field.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftAliasaddifnx

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftAliasaddifnx(List<String> args)
      Adds an alias to the index.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftAliasaddifnxAndAwait

      public io.vertx.redis.client.Response ftAliasaddifnxAndAwait(List<String> args)
      Adds an alias to the index.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Search 1.0.0
      See Also:
    • ftAliasaddifnxAndForget

      public RedisAPI ftAliasaddifnxAndForget(List<String> args)
      Adds an alias to the index.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftAliasdelifx

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftAliasdelifx(List<String> args)
      Deletes an alias from the index.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftAliasdelifxAndAwait

      public io.vertx.redis.client.Response ftAliasdelifxAndAwait(List<String> args)
      Deletes an alias from the index.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Search 1.0.0
      See Also:
    • ftAliasdelifxAndForget

      public RedisAPI ftAliasdelifxAndForget(List<String> args)
      Deletes an alias from the index.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftAlterifnx

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftAlterifnx(List<String> args)
      Adds a new field to the index.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftAlterifnxAndAwait

      public io.vertx.redis.client.Response ftAlterifnxAndAwait(List<String> args)
      Adds a new field to the index.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Search 1.0.0
      See Also:
    • ftAlterifnxAndForget

      public RedisAPI ftAlterifnxAndForget(List<String> args)
      Adds a new field to the index.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftCreateifnx

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftCreateifnx(List<String> args)
      Creates an index with the given spec.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftCreateifnxAndAwait

      public io.vertx.redis.client.Response ftCreateifnxAndAwait(List<String> args)
      Creates an index with the given spec.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Search 1.0.0
      See Also:
    • ftCreateifnxAndForget

      public RedisAPI ftCreateifnxAndForget(List<String> args)
      Creates an index with the given spec.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Search 1.0.0
      See Also:
    • ftDropifx

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftDropifx(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
    • ftDropifxAndAwait

      public io.vertx.redis.client.Response ftDropifxAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
    • ftDropifxAndForget

      public RedisAPI ftDropifxAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
    • ftDropindexifx

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftDropindexifx(List<String> args)
      Deletes the index.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Search 2.0.0
      See Also:
    • ftDropindexifxAndAwait

      public io.vertx.redis.client.Response ftDropindexifxAndAwait(List<String> args)
      Deletes the index.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Search 2.0.0
      See Also:
    • ftDropindexifxAndForget

      public RedisAPI ftDropindexifxAndForget(List<String> args)
      Deletes the index.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Search 2.0.0
      See Also:
    • ftList

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ftList(List<String> args)
      Returns a list of all existing indexes.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Search 2.0.0
      See Also:
    • ftListAndAwait

      public io.vertx.redis.client.Response ftListAndAwait(List<String> args)
      Returns a list of all existing indexes.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Search 2.0.0
      See Also:
    • ftListAndForget

      public RedisAPI ftListAndForget(List<String> args)
      Returns a list of all existing indexes.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Search 2.0.0
      See Also:
    • vadd

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> vadd(List<String> args)
      Add one or more elements to a vector set, or update its vector if it already exists.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis VectorSet 8.0.0
      See Also:
      • VADD
      • RedisAPI.vadd(List)
    • vaddAndAwait

      public io.vertx.redis.client.Response vaddAndAwait(List<String> args)
      Add one or more elements to a vector set, or update its vector if it already exists.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis VectorSet 8.0.0
      See Also:
      • VADD
      • RedisAPI.vadd(List)
    • vaddAndForget

      public RedisAPI vaddAndForget(List<String> args)
      Add one or more elements to a vector set, or update its vector if it already exists.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis VectorSet 8.0.0
      See Also:
      • VADD
      • RedisAPI.vadd(List)
    • vcard

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> vcard(String arg0)
      Return the number of elements in a vector set.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis VectorSet 8.0.0
      See Also:
      • VCARD
      • RedisAPI.vcard(String)
    • vcardAndAwait

      public io.vertx.redis.client.Response vcardAndAwait(String arg0)
      Return the number of elements in a vector set.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis VectorSet 8.0.0
      See Also:
      • VCARD
      • RedisAPI.vcard(String)
    • vcardAndForget

      public RedisAPI vcardAndForget(String arg0)
      Return the number of elements in a vector set.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis VectorSet 8.0.0
      See Also:
      • VCARD
      • RedisAPI.vcard(String)
    • vdim

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> vdim(String arg0)
      Return the dimension of vectors in the vector set.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis VectorSet 8.0.0
      See Also:
      • VDIM
      • RedisAPI.vdim(String)
    • vdimAndAwait

      public io.vertx.redis.client.Response vdimAndAwait(String arg0)
      Return the dimension of vectors in the vector set.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis VectorSet 8.0.0
      See Also:
      • VDIM
      • RedisAPI.vdim(String)
    • vdimAndForget

      public RedisAPI vdimAndForget(String arg0)
      Return the dimension of vectors in the vector set.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis VectorSet 8.0.0
      See Also:
      • VDIM
      • RedisAPI.vdim(String)
    • vemb

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> vemb(List<String> args)
      Return the vector associated with an element.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis VectorSet 8.0.0
      See Also:
      • VEMB
      • RedisAPI.vemb(List)
    • vembAndAwait

      public io.vertx.redis.client.Response vembAndAwait(List<String> args)
      Return the vector associated with an element.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis VectorSet 8.0.0
      See Also:
      • VEMB
      • RedisAPI.vemb(List)
    • vembAndForget

      public RedisAPI vembAndForget(List<String> args)
      Return the vector associated with an element.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis VectorSet 8.0.0
      See Also:
      • VEMB
      • RedisAPI.vemb(List)
    • vgetattr

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> vgetattr(String arg0, String arg1)
      Retrieve the JSON attributes of elements.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis VectorSet 8.0.0
      See Also:
      • VGETATTR
      • RedisAPI.vgetattr(String, String)
    • vgetattrAndAwait

      public io.vertx.redis.client.Response vgetattrAndAwait(String arg0, String arg1)
      Retrieve the JSON attributes of elements.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis VectorSet 8.0.0
      See Also:
      • VGETATTR
      • RedisAPI.vgetattr(String, String)
    • vgetattrAndForget

      public RedisAPI vgetattrAndForget(String arg0, String arg1)
      Retrieve the JSON attributes of elements.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis VectorSet 8.0.0
      See Also:
      • VGETATTR
      • RedisAPI.vgetattr(String, String)
    • vinfo

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> vinfo(String arg0)
      Return information about a vector set.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis VectorSet 8.0.0
      See Also:
      • VINFO
      • RedisAPI.vinfo(String)
    • vinfoAndAwait

      public io.vertx.redis.client.Response vinfoAndAwait(String arg0)
      Return information about a vector set.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis VectorSet 8.0.0
      See Also:
      • VINFO
      • RedisAPI.vinfo(String)
    • vinfoAndForget

      public RedisAPI vinfoAndForget(String arg0)
      Return information about a vector set.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis VectorSet 8.0.0
      See Also:
      • VINFO
      • RedisAPI.vinfo(String)
    • vismember

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> vismember(String arg0, String arg1)
      Check if an element exists in a vector set.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis VectorSet 8.2.0
      See Also:
      • VISMEMBER
      • RedisAPI.vismember(String, String)
    • vismemberAndAwait

      public io.vertx.redis.client.Response vismemberAndAwait(String arg0, String arg1)
      Check if an element exists in a vector set.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis VectorSet 8.2.0
      See Also:
      • VISMEMBER
      • RedisAPI.vismember(String, String)
    • vismemberAndForget

      public RedisAPI vismemberAndForget(String arg0, String arg1)
      Check if an element exists in a vector set.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis VectorSet 8.2.0
      See Also:
      • VISMEMBER
      • RedisAPI.vismember(String, String)
    • vlinks

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> vlinks(List<String> args)
      Return the neighbors of an element at each layer in the HNSW graph.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis VectorSet 8.0.0
      See Also:
      • VLINKS
      • RedisAPI.vlinks(List)
    • vlinksAndAwait

      public io.vertx.redis.client.Response vlinksAndAwait(List<String> args)
      Return the neighbors of an element at each layer in the HNSW graph.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis VectorSet 8.0.0
      See Also:
      • VLINKS
      • RedisAPI.vlinks(List)
    • vlinksAndForget

      public RedisAPI vlinksAndForget(List<String> args)
      Return the neighbors of an element at each layer in the HNSW graph.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis VectorSet 8.0.0
      See Also:
      • VLINKS
      • RedisAPI.vlinks(List)
    • vrandmember

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> vrandmember(List<String> args)
      Return one or multiple random members from a vector set.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis VectorSet 8.0.0
      See Also:
    • vrandmemberAndAwait

      public io.vertx.redis.client.Response vrandmemberAndAwait(List<String> args)
      Return one or multiple random members from a vector set.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis VectorSet 8.0.0
      See Also:
    • vrandmemberAndForget

      public RedisAPI vrandmemberAndForget(List<String> args)
      Return one or multiple random members from a vector set.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis VectorSet 8.0.0
      See Also:
    • vrange

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> vrange(List<String> args)
      Return vector set elements in a lex range.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis VectorSet 8.4.0
      See Also:
      • VRANGE
      • RedisAPI.vrange(List)
    • vrangeAndAwait

      public io.vertx.redis.client.Response vrangeAndAwait(List<String> args)
      Return vector set elements in a lex range.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis VectorSet 8.4.0
      See Also:
      • VRANGE
      • RedisAPI.vrange(List)
    • vrangeAndForget

      public RedisAPI vrangeAndForget(List<String> args)
      Return vector set elements in a lex range.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis VectorSet 8.4.0
      See Also:
      • VRANGE
      • RedisAPI.vrange(List)
    • vrem

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> vrem(String arg0, String arg1)
      Remove an element from a vector set.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis VectorSet 8.0.0
      See Also:
      • VREM
      • RedisAPI.vrem(String, String)
    • vremAndAwait

      public io.vertx.redis.client.Response vremAndAwait(String arg0, String arg1)
      Remove an element from a vector set.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis VectorSet 8.0.0
      See Also:
      • VREM
      • RedisAPI.vrem(String, String)
    • vremAndForget

      public RedisAPI vremAndForget(String arg0, String arg1)
      Remove an element from a vector set.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis VectorSet 8.0.0
      See Also:
      • VREM
      • RedisAPI.vrem(String, String)
    • vsetattr

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> vsetattr(String arg0, String arg1, String arg2)
      Associate or remove the JSON attributes of elements.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis VectorSet 8.0.0
      See Also:
      • VSETATTR
      • RedisAPI.vsetattr(String, String, String)
    • vsetattrAndAwait

      public io.vertx.redis.client.Response vsetattrAndAwait(String arg0, String arg1, String arg2)
      Associate or remove the JSON attributes of elements.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis VectorSet 8.0.0
      See Also:
      • VSETATTR
      • RedisAPI.vsetattr(String, String, String)
    • vsetattrAndForget

      public RedisAPI vsetattrAndForget(String arg0, String arg1, String arg2)
      Associate or remove the JSON attributes of elements.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis VectorSet 8.0.0
      See Also:
      • VSETATTR
      • RedisAPI.vsetattr(String, String, String)
    • vsim

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> vsim(List<String> args)
      Return elements by vector similarity.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis VectorSet 8.0.0
      See Also:
      • VSIM
      • RedisAPI.vsim(List)
    • vsimAndAwait

      public io.vertx.redis.client.Response vsimAndAwait(List<String> args)
      Return elements by vector similarity.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis VectorSet 8.0.0
      See Also:
      • VSIM
      • RedisAPI.vsim(List)
    • vsimAndForget

      public RedisAPI vsimAndForget(List<String> args)
      Return elements by vector similarity.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis VectorSet 8.0.0
      See Also:
      • VSIM
      • RedisAPI.vsim(List)
    • acl

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> acl(List<String> args)
      A container for Access List Control commands.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 6.0.0
      See Also:
      • ACL
      • RedisAPI.acl(List)
    • aclAndAwait

      public io.vertx.redis.client.Response aclAndAwait(List<String> args)
      A container for Access List Control commands.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 6.0.0
      See Also:
      • ACL
      • RedisAPI.acl(List)
    • aclAndForget

      public RedisAPI aclAndForget(List<String> args)
      A container for Access List Control commands.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 6.0.0
      See Also:
      • ACL
      • RedisAPI.acl(List)
    • append

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> append(String arg0, String arg1)
      Appends a string to the value of a key. Creates the key if it doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.0.0
      See Also:
      • APPEND
      • RedisAPI.append(String, String)
    • appendAndAwait

      public io.vertx.redis.client.Response appendAndAwait(String arg0, String arg1)
      Appends a string to the value of a key. Creates the key if it doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.0.0
      See Also:
      • APPEND
      • RedisAPI.append(String, String)
    • appendAndForget

      public RedisAPI appendAndForget(String arg0, String arg1)
      Appends a string to the value of a key. Creates the key if it doesn't exist.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.0.0
      See Also:
      • APPEND
      • RedisAPI.append(String, String)
    • asking

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> asking()
      Signals that a cluster client is following an -ASK redirect.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 3.0.0
      See Also:
    • askingAndAwait

      public io.vertx.redis.client.Response askingAndAwait()
      Signals that a cluster client is following an -ASK redirect.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 3.0.0
      See Also:
    • askingAndForget

      public RedisAPI askingAndForget()
      Signals that a cluster client is following an -ASK redirect.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 3.0.0
      See Also:
    • auth

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> auth(List<String> args)
      Authenticates the connection.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • AUTH
      • RedisAPI.auth(List)
    • authAndAwait

      public io.vertx.redis.client.Response authAndAwait(List<String> args)
      Authenticates the connection.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • AUTH
      • RedisAPI.auth(List)
    • authAndForget

      public RedisAPI authAndForget(List<String> args)
      Authenticates the connection.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • AUTH
      • RedisAPI.auth(List)
    • bfAdd

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> bfAdd(String arg0, String arg1)
      Adds an item to a Bloom Filter.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 1.0.0
      See Also:
      • BF.ADD
      • RedisAPI.bfAdd(String, String)
    • bfAddAndAwait

      public io.vertx.redis.client.Response bfAddAndAwait(String arg0, String arg1)
      Adds an item to a Bloom Filter.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 1.0.0
      See Also:
      • BF.ADD
      • RedisAPI.bfAdd(String, String)
    • bfAddAndForget

      public RedisAPI bfAddAndForget(String arg0, String arg1)
      Adds an item to a Bloom Filter.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 1.0.0
      See Also:
      • BF.ADD
      • RedisAPI.bfAdd(String, String)
    • bfAdd

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> bfAdd(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • RedisAPI.bfAdd(List)
    • bfAddAndAwait

      public io.vertx.redis.client.Response bfAddAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
      • RedisAPI.bfAdd(List)
    • bfAddAndForget

      public RedisAPI bfAddAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • RedisAPI.bfAdd(List)
    • bfCard

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> bfCard(String arg0)
      Returns the cardinality of a Bloom filter.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 2.4.4
      See Also:
    • bfCardAndAwait

      public io.vertx.redis.client.Response bfCardAndAwait(String arg0)
      Returns the cardinality of a Bloom filter.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 2.4.4
      See Also:
    • bfCardAndForget

      public RedisAPI bfCardAndForget(String arg0)
      Returns the cardinality of a Bloom filter.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 2.4.4
      See Also:
    • bfCard

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> bfCard(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • RedisAPI.bfCard(List)
    • bfCardAndAwait

      public io.vertx.redis.client.Response bfCardAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
      • RedisAPI.bfCard(List)
    • bfCardAndForget

      public RedisAPI bfCardAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • RedisAPI.bfCard(List)
    • bfDebug

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> bfDebug(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
    • bfDebugAndAwait

      public io.vertx.redis.client.Response bfDebugAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
    • bfDebugAndForget

      public RedisAPI bfDebugAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
    • bfExists

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> bfExists(String arg0, String arg1)
      Checks whether an item exists in a Bloom Filter.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 1.0.0
      See Also:
      • BF.EXISTS
      • RedisAPI.bfExists(String, String)
    • bfExistsAndAwait

      public io.vertx.redis.client.Response bfExistsAndAwait(String arg0, String arg1)
      Checks whether an item exists in a Bloom Filter.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 1.0.0
      See Also:
      • BF.EXISTS
      • RedisAPI.bfExists(String, String)
    • bfExistsAndForget

      public RedisAPI bfExistsAndForget(String arg0, String arg1)
      Checks whether an item exists in a Bloom Filter.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 1.0.0
      See Also:
      • BF.EXISTS
      • RedisAPI.bfExists(String, String)
    • bfExists

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> bfExists(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • RedisAPI.bfExists(List)
    • bfExistsAndAwait

      public io.vertx.redis.client.Response bfExistsAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
      • RedisAPI.bfExists(List)
    • bfExistsAndForget

      public RedisAPI bfExistsAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • RedisAPI.bfExists(List)
    • bfInfo

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> bfInfo(List<String> args)
      Returns information about a Bloom Filter.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 1.0.0
      See Also:
    • bfInfoAndAwait

      public io.vertx.redis.client.Response bfInfoAndAwait(List<String> args)
      Returns information about a Bloom Filter.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 1.0.0
      See Also:
    • bfInfoAndForget

      public RedisAPI bfInfoAndForget(List<String> args)
      Returns information about a Bloom Filter.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 1.0.0
      See Also:
    • bfInsert

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> bfInsert(List<String> args)
      Adds one or more items to a Bloom Filter. A filter will be created if it does not exist.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 1.0.0
      See Also:
    • bfInsertAndAwait

      public io.vertx.redis.client.Response bfInsertAndAwait(List<String> args)
      Adds one or more items to a Bloom Filter. A filter will be created if it does not exist.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 1.0.0
      See Also:
    • bfInsertAndForget

      public RedisAPI bfInsertAndForget(List<String> args)
      Adds one or more items to a Bloom Filter. A filter will be created if it does not exist.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 1.0.0
      See Also:
    • bfLoadchunk

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> bfLoadchunk(String arg0, String arg1, String arg2)
      Restores a filter previously saved using SCANDUMP.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 1.0.0
      See Also:
    • bfLoadchunkAndAwait

      public io.vertx.redis.client.Response bfLoadchunkAndAwait(String arg0, String arg1, String arg2)
      Restores a filter previously saved using SCANDUMP.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 1.0.0
      See Also:
    • bfLoadchunkAndForget

      public RedisAPI bfLoadchunkAndForget(String arg0, String arg1, String arg2)
      Restores a filter previously saved using SCANDUMP.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 1.0.0
      See Also:
    • bfLoadchunk

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> bfLoadchunk(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • RedisAPI.bfLoadchunk(List)
    • bfLoadchunkAndAwait

      public io.vertx.redis.client.Response bfLoadchunkAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
      • RedisAPI.bfLoadchunk(List)
    • bfLoadchunkAndForget

      public RedisAPI bfLoadchunkAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • RedisAPI.bfLoadchunk(List)
    • bfMadd

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> bfMadd(List<String> args)
      Adds one or more items to a Bloom Filter. A filter will be created if it does not exist.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 1.0.0
      See Also:
    • bfMaddAndAwait

      public io.vertx.redis.client.Response bfMaddAndAwait(List<String> args)
      Adds one or more items to a Bloom Filter. A filter will be created if it does not exist.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 1.0.0
      See Also:
    • bfMaddAndForget

      public RedisAPI bfMaddAndForget(List<String> args)
      Adds one or more items to a Bloom Filter. A filter will be created if it does not exist.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 1.0.0
      See Also:
    • bfMexists

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> bfMexists(List<String> args)
      Checks whether one or more items exist in a Bloom Filter.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 1.0.0
      See Also:
    • bfMexistsAndAwait

      public io.vertx.redis.client.Response bfMexistsAndAwait(List<String> args)
      Checks whether one or more items exist in a Bloom Filter.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 1.0.0
      See Also:
    • bfMexistsAndForget

      public RedisAPI bfMexistsAndForget(List<String> args)
      Checks whether one or more items exist in a Bloom Filter.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 1.0.0
      See Also:
    • bfReserve

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> bfReserve(List<String> args)
      Creates a new Bloom Filter.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 1.0.0
      See Also:
    • bfReserveAndAwait

      public io.vertx.redis.client.Response bfReserveAndAwait(List<String> args)
      Creates a new Bloom Filter.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 1.0.0
      See Also:
    • bfReserveAndForget

      public RedisAPI bfReserveAndForget(List<String> args)
      Creates a new Bloom Filter.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 1.0.0
      See Also:
    • bfScandump

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> bfScandump(String arg0, String arg1)
      Begins an incremental save of the bloom filter.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 1.0.0
      See Also:
    • bfScandumpAndAwait

      public io.vertx.redis.client.Response bfScandumpAndAwait(String arg0, String arg1)
      Begins an incremental save of the bloom filter.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 1.0.0
      See Also:
    • bfScandumpAndForget

      public RedisAPI bfScandumpAndForget(String arg0, String arg1)
      Begins an incremental save of the bloom filter.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 1.0.0
      See Also:
    • bfScandump

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> bfScandump(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • RedisAPI.bfScandump(List)
    • bfScandumpAndAwait

      public io.vertx.redis.client.Response bfScandumpAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
      • RedisAPI.bfScandump(List)
    • bfScandumpAndForget

      public RedisAPI bfScandumpAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • RedisAPI.bfScandump(List)
    • bgrewriteaof

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> bgrewriteaof()
      Asynchronously rewrites the append-only file to disk.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
    • bgrewriteaofAndAwait

      public io.vertx.redis.client.Response bgrewriteaofAndAwait()
      Asynchronously rewrites the append-only file to disk.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
    • bgrewriteaofAndForget

      public RedisAPI bgrewriteaofAndForget()
      Asynchronously rewrites the append-only file to disk.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
    • bgsave

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> bgsave(List<String> args)
      Asynchronously saves the database(s) to disk.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • BGSAVE
      • RedisAPI.bgsave(List)
    • bgsaveAndAwait

      public io.vertx.redis.client.Response bgsaveAndAwait(List<String> args)
      Asynchronously saves the database(s) to disk.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • BGSAVE
      • RedisAPI.bgsave(List)
    • bgsaveAndForget

      public RedisAPI bgsaveAndForget(List<String> args)
      Asynchronously saves the database(s) to disk.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • BGSAVE
      • RedisAPI.bgsave(List)
    • bitcount

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> bitcount(List<String> args)
      Counts the number of set bits (population counting) in a string.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.6.0
      See Also:
    • bitcountAndAwait

      public io.vertx.redis.client.Response bitcountAndAwait(List<String> args)
      Counts the number of set bits (population counting) in a string.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.6.0
      See Also:
    • bitcountAndForget

      public RedisAPI bitcountAndForget(List<String> args)
      Counts the number of set bits (population counting) in a string.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.6.0
      See Also:
    • bitfield

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> bitfield(List<String> args)
      Performs arbitrary bitfield integer operations on strings.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 3.2.0
      See Also:
    • bitfieldAndAwait

      public io.vertx.redis.client.Response bitfieldAndAwait(List<String> args)
      Performs arbitrary bitfield integer operations on strings.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 3.2.0
      See Also:
    • bitfieldAndForget

      public RedisAPI bitfieldAndForget(List<String> args)
      Performs arbitrary bitfield integer operations on strings.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 3.2.0
      See Also:
    • bitfieldRo

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> bitfieldRo(List<String> args)
      Performs arbitrary read-only bitfield integer operations on strings.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 6.0.0
      See Also:
    • bitfieldRoAndAwait

      public io.vertx.redis.client.Response bitfieldRoAndAwait(List<String> args)
      Performs arbitrary read-only bitfield integer operations on strings.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 6.0.0
      See Also:
    • bitfieldRoAndForget

      public RedisAPI bitfieldRoAndForget(List<String> args)
      Performs arbitrary read-only bitfield integer operations on strings.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 6.0.0
      See Also:
    • bitop

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> bitop(List<String> args)
      Performs bitwise operations on multiple strings, and stores the result.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.6.0
      See Also:
      • BITOP
      • RedisAPI.bitop(List)
    • bitopAndAwait

      public io.vertx.redis.client.Response bitopAndAwait(List<String> args)
      Performs bitwise operations on multiple strings, and stores the result.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.6.0
      See Also:
      • BITOP
      • RedisAPI.bitop(List)
    • bitopAndForget

      public RedisAPI bitopAndForget(List<String> args)
      Performs bitwise operations on multiple strings, and stores the result.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.6.0
      See Also:
      • BITOP
      • RedisAPI.bitop(List)
    • bitpos

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> bitpos(List<String> args)
      Finds the first set (1) or clear (0) bit in a string.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.8.7
      See Also:
      • BITPOS
      • RedisAPI.bitpos(List)
    • bitposAndAwait

      public io.vertx.redis.client.Response bitposAndAwait(List<String> args)
      Finds the first set (1) or clear (0) bit in a string.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.8.7
      See Also:
      • BITPOS
      • RedisAPI.bitpos(List)
    • bitposAndForget

      public RedisAPI bitposAndForget(List<String> args)
      Finds the first set (1) or clear (0) bit in a string.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.8.7
      See Also:
      • BITPOS
      • RedisAPI.bitpos(List)
    • blmove

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> blmove(String arg0, String arg1, String arg2, String arg3, String arg4)
      Pops an element from a list, pushes it to another list and returns it. Blocks until an element is available otherwise. Deletes the list if the last element was moved.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 6.2.0
      See Also:
      • BLMOVE
      • RedisAPI.blmove(String, String, String, String, String)
    • blmoveAndAwait

      public io.vertx.redis.client.Response blmoveAndAwait(String arg0, String arg1, String arg2, String arg3, String arg4)
      Pops an element from a list, pushes it to another list and returns it. Blocks until an element is available otherwise. Deletes the list if the last element was moved.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 6.2.0
      See Also:
      • BLMOVE
      • RedisAPI.blmove(String, String, String, String, String)
    • blmoveAndForget

      public RedisAPI blmoveAndForget(String arg0, String arg1, String arg2, String arg3, String arg4)
      Pops an element from a list, pushes it to another list and returns it. Blocks until an element is available otherwise. Deletes the list if the last element was moved.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 6.2.0
      See Also:
      • BLMOVE
      • RedisAPI.blmove(String, String, String, String, String)
    • blmpop

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> blmpop(List<String> args)
      Pops the first element from one of multiple lists. Blocks until an element is available otherwise. Deletes the list if the last element was popped.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 7.0.0
      See Also:
      • BLMPOP
      • RedisAPI.blmpop(List)
    • blmpopAndAwait

      public io.vertx.redis.client.Response blmpopAndAwait(List<String> args)
      Pops the first element from one of multiple lists. Blocks until an element is available otherwise. Deletes the list if the last element was popped.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 7.0.0
      See Also:
      • BLMPOP
      • RedisAPI.blmpop(List)
    • blmpopAndForget

      public RedisAPI blmpopAndForget(List<String> args)
      Pops the first element from one of multiple lists. Blocks until an element is available otherwise. Deletes the list if the last element was popped.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 7.0.0
      See Also:
      • BLMPOP
      • RedisAPI.blmpop(List)
    • blpop

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> blpop(List<String> args)
      Removes and returns the first element in a list. Blocks until an element is available otherwise. Deletes the list if the last element was popped.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.0.0
      See Also:
      • BLPOP
      • RedisAPI.blpop(List)
    • blpopAndAwait

      public io.vertx.redis.client.Response blpopAndAwait(List<String> args)
      Removes and returns the first element in a list. Blocks until an element is available otherwise. Deletes the list if the last element was popped.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.0.0
      See Also:
      • BLPOP
      • RedisAPI.blpop(List)
    • blpopAndForget

      public RedisAPI blpopAndForget(List<String> args)
      Removes and returns the first element in a list. Blocks until an element is available otherwise. Deletes the list if the last element was popped.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.0.0
      See Also:
      • BLPOP
      • RedisAPI.blpop(List)
    • brpop

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> brpop(List<String> args)
      Removes and returns the last element in a list. Blocks until an element is available otherwise. Deletes the list if the last element was popped.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.0.0
      See Also:
      • BRPOP
      • RedisAPI.brpop(List)
    • brpopAndAwait

      public io.vertx.redis.client.Response brpopAndAwait(List<String> args)
      Removes and returns the last element in a list. Blocks until an element is available otherwise. Deletes the list if the last element was popped.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.0.0
      See Also:
      • BRPOP
      • RedisAPI.brpop(List)
    • brpopAndForget

      public RedisAPI brpopAndForget(List<String> args)
      Removes and returns the last element in a list. Blocks until an element is available otherwise. Deletes the list if the last element was popped.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.0.0
      See Also:
      • BRPOP
      • RedisAPI.brpop(List)
    • brpoplpush

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> brpoplpush(String arg0, String arg1, String arg2)
      Deprecated.
      since Redis 6.2.0, replaced by: BLMOVE with the RIGHT and LEFT arguments
      Pops an element from a list, pushes it to another list and returns it. Block until an element is available otherwise. Deletes the list if the last element was popped.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.2.0
      See Also:
      • BRPOPLPUSH
      • RedisAPI.brpoplpush(String, String, String)
    • brpoplpushAndAwait

      public io.vertx.redis.client.Response brpoplpushAndAwait(String arg0, String arg1, String arg2)
      Deprecated.
      since Redis 6.2.0, replaced by: BLMOVE with the RIGHT and LEFT arguments
      Pops an element from a list, pushes it to another list and returns it. Block until an element is available otherwise. Deletes the list if the last element was popped.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.2.0
      See Also:
      • BRPOPLPUSH
      • RedisAPI.brpoplpush(String, String, String)
    • brpoplpushAndForget

      public RedisAPI brpoplpushAndForget(String arg0, String arg1, String arg2)
      Deprecated.
      since Redis 6.2.0, replaced by: BLMOVE with the RIGHT and LEFT arguments
      Pops an element from a list, pushes it to another list and returns it. Block until an element is available otherwise. Deletes the list if the last element was popped.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.2.0
      See Also:
      • BRPOPLPUSH
      • RedisAPI.brpoplpush(String, String, String)
    • bzmpop

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> bzmpop(List<String> args)
      Removes and returns a member by score from one or more sorted sets. Blocks until a member is available otherwise. Deletes the sorted set if the last element was popped.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 7.0.0
      See Also:
      • BZMPOP
      • RedisAPI.bzmpop(List)
    • bzmpopAndAwait

      public io.vertx.redis.client.Response bzmpopAndAwait(List<String> args)
      Removes and returns a member by score from one or more sorted sets. Blocks until a member is available otherwise. Deletes the sorted set if the last element was popped.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 7.0.0
      See Also:
      • BZMPOP
      • RedisAPI.bzmpop(List)
    • bzmpopAndForget

      public RedisAPI bzmpopAndForget(List<String> args)
      Removes and returns a member by score from one or more sorted sets. Blocks until a member is available otherwise. Deletes the sorted set if the last element was popped.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 7.0.0
      See Also:
      • BZMPOP
      • RedisAPI.bzmpop(List)
    • bzpopmax

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> bzpopmax(List<String> args)
      Removes and returns the member with the highest score from one or more sorted sets. Blocks until a member available otherwise. Deletes the sorted set if the last element was popped.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 5.0.0
      See Also:
    • bzpopmaxAndAwait

      public io.vertx.redis.client.Response bzpopmaxAndAwait(List<String> args)
      Removes and returns the member with the highest score from one or more sorted sets. Blocks until a member available otherwise. Deletes the sorted set if the last element was popped.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 5.0.0
      See Also:
    • bzpopmaxAndForget

      public RedisAPI bzpopmaxAndForget(List<String> args)
      Removes and returns the member with the highest score from one or more sorted sets. Blocks until a member available otherwise. Deletes the sorted set if the last element was popped.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 5.0.0
      See Also:
    • bzpopmin

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> bzpopmin(List<String> args)
      Removes and returns the member with the lowest score from one or more sorted sets. Blocks until a member is available otherwise. Deletes the sorted set if the last element was popped.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 5.0.0
      See Also:
    • bzpopminAndAwait

      public io.vertx.redis.client.Response bzpopminAndAwait(List<String> args)
      Removes and returns the member with the lowest score from one or more sorted sets. Blocks until a member is available otherwise. Deletes the sorted set if the last element was popped.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 5.0.0
      See Also:
    • bzpopminAndForget

      public RedisAPI bzpopminAndForget(List<String> args)
      Removes and returns the member with the lowest score from one or more sorted sets. Blocks until a member is available otherwise. Deletes the sorted set if the last element was popped.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 5.0.0
      See Also:
    • cfAdd

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> cfAdd(String arg0, String arg1)
      Adds an item to a Cuckoo Filter.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 1.0.0
      See Also:
      • CF.ADD
      • RedisAPI.cfAdd(String, String)
    • cfAddAndAwait

      public io.vertx.redis.client.Response cfAddAndAwait(String arg0, String arg1)
      Adds an item to a Cuckoo Filter.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 1.0.0
      See Also:
      • CF.ADD
      • RedisAPI.cfAdd(String, String)
    • cfAddAndForget

      public RedisAPI cfAddAndForget(String arg0, String arg1)
      Adds an item to a Cuckoo Filter.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 1.0.0
      See Also:
      • CF.ADD
      • RedisAPI.cfAdd(String, String)
    • cfAdd

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> cfAdd(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • RedisAPI.cfAdd(List)
    • cfAddAndAwait

      public io.vertx.redis.client.Response cfAddAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
      • RedisAPI.cfAdd(List)
    • cfAddAndForget

      public RedisAPI cfAddAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • RedisAPI.cfAdd(List)
    • cfAddnx

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> cfAddnx(String arg0, String arg1)
      Adds an item to a Cuckoo Filter if the item did not exist previously.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 1.0.0
      See Also:
      • CF.ADDNX
      • RedisAPI.cfAddnx(String, String)
    • cfAddnxAndAwait

      public io.vertx.redis.client.Response cfAddnxAndAwait(String arg0, String arg1)
      Adds an item to a Cuckoo Filter if the item did not exist previously.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 1.0.0
      See Also:
      • CF.ADDNX
      • RedisAPI.cfAddnx(String, String)
    • cfAddnxAndForget

      public RedisAPI cfAddnxAndForget(String arg0, String arg1)
      Adds an item to a Cuckoo Filter if the item did not exist previously.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 1.0.0
      See Also:
      • CF.ADDNX
      • RedisAPI.cfAddnx(String, String)
    • cfAddnx

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> cfAddnx(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • RedisAPI.cfAddnx(List)
    • cfAddnxAndAwait

      public io.vertx.redis.client.Response cfAddnxAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
      • RedisAPI.cfAddnx(List)
    • cfAddnxAndForget

      public RedisAPI cfAddnxAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • RedisAPI.cfAddnx(List)
    • cfCompact

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> cfCompact(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
    • cfCompactAndAwait

      public io.vertx.redis.client.Response cfCompactAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
    • cfCompactAndForget

      public RedisAPI cfCompactAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
    • cfCount

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> cfCount(String arg0, String arg1)
      Return the number of times an item might be in a Cuckoo Filter.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 1.0.0
      See Also:
      • CF.COUNT
      • RedisAPI.cfCount(String, String)
    • cfCountAndAwait

      public io.vertx.redis.client.Response cfCountAndAwait(String arg0, String arg1)
      Return the number of times an item might be in a Cuckoo Filter.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 1.0.0
      See Also:
      • CF.COUNT
      • RedisAPI.cfCount(String, String)
    • cfCountAndForget

      public RedisAPI cfCountAndForget(String arg0, String arg1)
      Return the number of times an item might be in a Cuckoo Filter.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 1.0.0
      See Also:
      • CF.COUNT
      • RedisAPI.cfCount(String, String)
    • cfCount

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> cfCount(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • RedisAPI.cfCount(List)
    • cfCountAndAwait

      public io.vertx.redis.client.Response cfCountAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
      • RedisAPI.cfCount(List)
    • cfCountAndForget

      public RedisAPI cfCountAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • RedisAPI.cfCount(List)
    • cfDebug

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> cfDebug(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
    • cfDebugAndAwait

      public io.vertx.redis.client.Response cfDebugAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
    • cfDebugAndForget

      public RedisAPI cfDebugAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
    • cfDel

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> cfDel(String arg0, String arg1)
      Deletes an item from a Cuckoo Filter.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 1.0.0
      See Also:
      • CF.DEL
      • RedisAPI.cfDel(String, String)
    • cfDelAndAwait

      public io.vertx.redis.client.Response cfDelAndAwait(String arg0, String arg1)
      Deletes an item from a Cuckoo Filter.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 1.0.0
      See Also:
      • CF.DEL
      • RedisAPI.cfDel(String, String)
    • cfDelAndForget

      public RedisAPI cfDelAndForget(String arg0, String arg1)
      Deletes an item from a Cuckoo Filter.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 1.0.0
      See Also:
      • CF.DEL
      • RedisAPI.cfDel(String, String)
    • cfDel

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> cfDel(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • RedisAPI.cfDel(List)
    • cfDelAndAwait

      public io.vertx.redis.client.Response cfDelAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
      • RedisAPI.cfDel(List)
    • cfDelAndForget

      public RedisAPI cfDelAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • RedisAPI.cfDel(List)
    • cfExists

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> cfExists(String arg0, String arg1)
      Checks whether one or more items exist in a Cuckoo Filter.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 1.0.0
      See Also:
      • CF.EXISTS
      • RedisAPI.cfExists(String, String)
    • cfExistsAndAwait

      public io.vertx.redis.client.Response cfExistsAndAwait(String arg0, String arg1)
      Checks whether one or more items exist in a Cuckoo Filter.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 1.0.0
      See Also:
      • CF.EXISTS
      • RedisAPI.cfExists(String, String)
    • cfExistsAndForget

      public RedisAPI cfExistsAndForget(String arg0, String arg1)
      Checks whether one or more items exist in a Cuckoo Filter.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 1.0.0
      See Also:
      • CF.EXISTS
      • RedisAPI.cfExists(String, String)
    • cfExists

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> cfExists(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • RedisAPI.cfExists(List)
    • cfExistsAndAwait

      public io.vertx.redis.client.Response cfExistsAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
      • RedisAPI.cfExists(List)
    • cfExistsAndForget

      public RedisAPI cfExistsAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • RedisAPI.cfExists(List)
    • cfInfo

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> cfInfo(String arg0)
      Returns information about a Cuckoo Filter.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 1.0.0
      See Also:
    • cfInfoAndAwait

      public io.vertx.redis.client.Response cfInfoAndAwait(String arg0)
      Returns information about a Cuckoo Filter.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 1.0.0
      See Also:
    • cfInfoAndForget

      public RedisAPI cfInfoAndForget(String arg0)
      Returns information about a Cuckoo Filter.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 1.0.0
      See Also:
    • cfInfo

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> cfInfo(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • RedisAPI.cfInfo(List)
    • cfInfoAndAwait

      public io.vertx.redis.client.Response cfInfoAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
      • RedisAPI.cfInfo(List)
    • cfInfoAndForget

      public RedisAPI cfInfoAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • RedisAPI.cfInfo(List)
    • cfInsert

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> cfInsert(List<String> args)
      Adds one or more items to a Cuckoo Filter. A filter will be created if it does not exist.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 1.0.0
      See Also:
    • cfInsertAndAwait

      public io.vertx.redis.client.Response cfInsertAndAwait(List<String> args)
      Adds one or more items to a Cuckoo Filter. A filter will be created if it does not exist.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 1.0.0
      See Also:
    • cfInsertAndForget

      public RedisAPI cfInsertAndForget(List<String> args)
      Adds one or more items to a Cuckoo Filter. A filter will be created if it does not exist.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 1.0.0
      See Also:
    • cfInsertnx

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> cfInsertnx(List<String> args)
      Adds one or more items to a Cuckoo Filter if the items did not exist previously. A filter will be created if it does not exist.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 1.0.0
      See Also:
    • cfInsertnxAndAwait

      public io.vertx.redis.client.Response cfInsertnxAndAwait(List<String> args)
      Adds one or more items to a Cuckoo Filter if the items did not exist previously. A filter will be created if it does not exist.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 1.0.0
      See Also:
    • cfInsertnxAndForget

      public RedisAPI cfInsertnxAndForget(List<String> args)
      Adds one or more items to a Cuckoo Filter if the items did not exist previously. A filter will be created if it does not exist.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 1.0.0
      See Also:
    • cfLoadchunk

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> cfLoadchunk(String arg0, String arg1, String arg2)
      Restores a filter previously saved using SCANDUMP.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 1.0.0
      See Also:
    • cfLoadchunkAndAwait

      public io.vertx.redis.client.Response cfLoadchunkAndAwait(String arg0, String arg1, String arg2)
      Restores a filter previously saved using SCANDUMP.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 1.0.0
      See Also:
    • cfLoadchunkAndForget

      public RedisAPI cfLoadchunkAndForget(String arg0, String arg1, String arg2)
      Restores a filter previously saved using SCANDUMP.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 1.0.0
      See Also:
    • cfLoadchunk

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> cfLoadchunk(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • RedisAPI.cfLoadchunk(List)
    • cfLoadchunkAndAwait

      public io.vertx.redis.client.Response cfLoadchunkAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
      • RedisAPI.cfLoadchunk(List)
    • cfLoadchunkAndForget

      public RedisAPI cfLoadchunkAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • RedisAPI.cfLoadchunk(List)
    • cfMexists

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> cfMexists(List<String> args)
      Checks whether one or more items exist in a Cuckoo Filter.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 1.0.0
      See Also:
    • cfMexistsAndAwait

      public io.vertx.redis.client.Response cfMexistsAndAwait(List<String> args)
      Checks whether one or more items exist in a Cuckoo Filter.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 1.0.0
      See Also:
    • cfMexistsAndForget

      public RedisAPI cfMexistsAndForget(List<String> args)
      Checks whether one or more items exist in a Cuckoo Filter.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 1.0.0
      See Also:
    • cfReserve

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> cfReserve(List<String> args)
      Creates a new Cuckoo Filter.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 1.0.0
      See Also:
    • cfReserveAndAwait

      public io.vertx.redis.client.Response cfReserveAndAwait(List<String> args)
      Creates a new Cuckoo Filter.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 1.0.0
      See Also:
    • cfReserveAndForget

      public RedisAPI cfReserveAndForget(List<String> args)
      Creates a new Cuckoo Filter.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 1.0.0
      See Also:
    • cfScandump

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> cfScandump(String arg0, String arg1)
      Begins an incremental save of the bloom filter.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 1.0.0
      See Also:
    • cfScandumpAndAwait

      public io.vertx.redis.client.Response cfScandumpAndAwait(String arg0, String arg1)
      Begins an incremental save of the bloom filter.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 1.0.0
      See Also:
    • cfScandumpAndForget

      public RedisAPI cfScandumpAndForget(String arg0, String arg1)
      Begins an incremental save of the bloom filter.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 1.0.0
      See Also:
    • cfScandump

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> cfScandump(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • RedisAPI.cfScandump(List)
    • cfScandumpAndAwait

      public io.vertx.redis.client.Response cfScandumpAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
      • RedisAPI.cfScandump(List)
    • cfScandumpAndForget

      public RedisAPI cfScandumpAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • RedisAPI.cfScandump(List)
    • client

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> client(List<String> args)
      A container for client connection commands.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.4.0
      See Also:
      • CLIENT
      • RedisAPI.client(List)
    • clientAndAwait

      public io.vertx.redis.client.Response clientAndAwait(List<String> args)
      A container for client connection commands.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.4.0
      See Also:
      • CLIENT
      • RedisAPI.client(List)
    • clientAndForget

      public RedisAPI clientAndForget(List<String> args)
      A container for client connection commands.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.4.0
      See Also:
      • CLIENT
      • RedisAPI.client(List)
    • cluster

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> cluster(List<String> args)
      A container for Redis Cluster commands.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 3.0.0
      See Also:
    • clusterAndAwait

      public io.vertx.redis.client.Response clusterAndAwait(List<String> args)
      A container for Redis Cluster commands.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 3.0.0
      See Also:
    • clusterAndForget

      public RedisAPI clusterAndForget(List<String> args)
      A container for Redis Cluster commands.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 3.0.0
      See Also:
    • cmsIncrby

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> cmsIncrby(List<String> args)
      Increases the count of one or more items by increment.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 2.0.0
      See Also:
    • cmsIncrbyAndAwait

      public io.vertx.redis.client.Response cmsIncrbyAndAwait(List<String> args)
      Increases the count of one or more items by increment.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 2.0.0
      See Also:
    • cmsIncrbyAndForget

      public RedisAPI cmsIncrbyAndForget(List<String> args)
      Increases the count of one or more items by increment.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 2.0.0
      See Also:
    • cmsInfo

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> cmsInfo(String arg0)
      Returns information about a sketch.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 2.0.0
      See Also:
    • cmsInfoAndAwait

      public io.vertx.redis.client.Response cmsInfoAndAwait(String arg0)
      Returns information about a sketch.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 2.0.0
      See Also:
    • cmsInfoAndForget

      public RedisAPI cmsInfoAndForget(String arg0)
      Returns information about a sketch.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 2.0.0
      See Also:
    • cmsInfo

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> cmsInfo(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • RedisAPI.cmsInfo(List)
    • cmsInfoAndAwait

      public io.vertx.redis.client.Response cmsInfoAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
      • RedisAPI.cmsInfo(List)
    • cmsInfoAndForget

      public RedisAPI cmsInfoAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • RedisAPI.cmsInfo(List)
    • cmsInitbydim

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> cmsInitbydim(String arg0, String arg1, String arg2)
      Initializes a Count-Min Sketch to dimensions specified by user.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 2.0.0
      See Also:
    • cmsInitbydimAndAwait

      public io.vertx.redis.client.Response cmsInitbydimAndAwait(String arg0, String arg1, String arg2)
      Initializes a Count-Min Sketch to dimensions specified by user.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 2.0.0
      See Also:
    • cmsInitbydimAndForget

      public RedisAPI cmsInitbydimAndForget(String arg0, String arg1, String arg2)
      Initializes a Count-Min Sketch to dimensions specified by user.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 2.0.0
      See Also:
    • cmsInitbydim

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> cmsInitbydim(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • RedisAPI.cmsInitbydim(List)
    • cmsInitbydimAndAwait

      public io.vertx.redis.client.Response cmsInitbydimAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
      • RedisAPI.cmsInitbydim(List)
    • cmsInitbydimAndForget

      public RedisAPI cmsInitbydimAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • RedisAPI.cmsInitbydim(List)
    • cmsInitbyprob

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> cmsInitbyprob(String arg0, String arg1, String arg2)
      Initializes a Count-Min Sketch to accommodate requested tolerances.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 2.0.0
      See Also:
    • cmsInitbyprobAndAwait

      public io.vertx.redis.client.Response cmsInitbyprobAndAwait(String arg0, String arg1, String arg2)
      Initializes a Count-Min Sketch to accommodate requested tolerances.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 2.0.0
      See Also:
    • cmsInitbyprobAndForget

      public RedisAPI cmsInitbyprobAndForget(String arg0, String arg1, String arg2)
      Initializes a Count-Min Sketch to accommodate requested tolerances.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 2.0.0
      See Also:
    • cmsInitbyprob

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> cmsInitbyprob(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • RedisAPI.cmsInitbyprob(List)
    • cmsInitbyprobAndAwait

      public io.vertx.redis.client.Response cmsInitbyprobAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
      • RedisAPI.cmsInitbyprob(List)
    • cmsInitbyprobAndForget

      public RedisAPI cmsInitbyprobAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • RedisAPI.cmsInitbyprob(List)
    • cmsMerge

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> cmsMerge(List<String> args)
      Merges several sketches into one sketch.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 2.0.0
      See Also:
    • cmsMergeAndAwait

      public io.vertx.redis.client.Response cmsMergeAndAwait(List<String> args)
      Merges several sketches into one sketch.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 2.0.0
      See Also:
    • cmsMergeAndForget

      public RedisAPI cmsMergeAndForget(List<String> args)
      Merges several sketches into one sketch.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 2.0.0
      See Also:
    • cmsQuery

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> cmsQuery(List<String> args)
      Returns the count for one or more items in a sketch.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 2.0.0
      See Also:
    • cmsQueryAndAwait

      public io.vertx.redis.client.Response cmsQueryAndAwait(List<String> args)
      Returns the count for one or more items in a sketch.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 2.0.0
      See Also:
    • cmsQueryAndForget

      public RedisAPI cmsQueryAndForget(List<String> args)
      Returns the count for one or more items in a sketch.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 2.0.0
      See Also:
    • command

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> command(List<String> args)
      Returns detailed information about all commands.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.8.13
      See Also:
    • commandAndAwait

      public io.vertx.redis.client.Response commandAndAwait(List<String> args)
      Returns detailed information about all commands.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.8.13
      See Also:
    • commandAndForget

      public RedisAPI commandAndForget(List<String> args)
      Returns detailed information about all commands.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.8.13
      See Also:
    • config

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> config(List<String> args)
      A container for server configuration commands.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.0.0
      See Also:
      • CONFIG
      • RedisAPI.config(List)
    • configAndAwait

      public io.vertx.redis.client.Response configAndAwait(List<String> args)
      A container for server configuration commands.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.0.0
      See Also:
      • CONFIG
      • RedisAPI.config(List)
    • configAndForget

      public RedisAPI configAndForget(List<String> args)
      A container for server configuration commands.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.0.0
      See Also:
      • CONFIG
      • RedisAPI.config(List)
    • copy

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> copy(List<String> args)
      Copies the value of a key to a new key.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 6.2.0
      See Also:
      • COPY
      • RedisAPI.copy(List)
    • copyAndAwait

      public io.vertx.redis.client.Response copyAndAwait(List<String> args)
      Copies the value of a key to a new key.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 6.2.0
      See Also:
      • COPY
      • RedisAPI.copy(List)
    • copyAndForget

      public RedisAPI copyAndForget(List<String> args)
      Copies the value of a key to a new key.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 6.2.0
      See Also:
      • COPY
      • RedisAPI.copy(List)
    • dbsize

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> dbsize()
      Returns the number of keys in the database.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
    • dbsizeAndAwait

      public io.vertx.redis.client.Response dbsizeAndAwait()
      Returns the number of keys in the database.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
    • dbsizeAndForget

      public RedisAPI dbsizeAndForget()
      Returns the number of keys in the database.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
    • debug

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> debug(List<String> args)
      A container for debugging commands.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • DEBUG
      • RedisAPI.debug(List)
    • debugAndAwait

      public io.vertx.redis.client.Response debugAndAwait(List<String> args)
      A container for debugging commands.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • DEBUG
      • RedisAPI.debug(List)
    • debugAndForget

      public RedisAPI debugAndForget(List<String> args)
      A container for debugging commands.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • DEBUG
      • RedisAPI.debug(List)
    • decr

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> decr(String arg0)
      Decrements the integer value of a key by one. Uses 0 as initial value if the key doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • DECR
      • RedisAPI.decr(String)
    • decrAndAwait

      public io.vertx.redis.client.Response decrAndAwait(String arg0)
      Decrements the integer value of a key by one. Uses 0 as initial value if the key doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • DECR
      • RedisAPI.decr(String)
    • decrAndForget

      public RedisAPI decrAndForget(String arg0)
      Decrements the integer value of a key by one. Uses 0 as initial value if the key doesn't exist.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • DECR
      • RedisAPI.decr(String)
    • decrby

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> decrby(String arg0, String arg1)
      Decrements a number from the integer value of a key. Uses 0 as initial value if the key doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • DECRBY
      • RedisAPI.decrby(String, String)
    • decrbyAndAwait

      public io.vertx.redis.client.Response decrbyAndAwait(String arg0, String arg1)
      Decrements a number from the integer value of a key. Uses 0 as initial value if the key doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • DECRBY
      • RedisAPI.decrby(String, String)
    • decrbyAndForget

      public RedisAPI decrbyAndForget(String arg0, String arg1)
      Decrements a number from the integer value of a key. Uses 0 as initial value if the key doesn't exist.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • DECRBY
      • RedisAPI.decrby(String, String)
    • del

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> del(List<String> args)
      Deletes one or more keys.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • DEL
      • RedisAPI.del(List)
    • delAndAwait

      public io.vertx.redis.client.Response delAndAwait(List<String> args)
      Deletes one or more keys.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • DEL
      • RedisAPI.del(List)
    • delAndForget

      public RedisAPI delAndForget(List<String> args)
      Deletes one or more keys.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • DEL
      • RedisAPI.del(List)
    • delex

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> delex(List<String> args)
      Conditionally removes the specified key based on value or digest comparison.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 8.4.0
      See Also:
      • DELEX
      • RedisAPI.delex(List)
    • delexAndAwait

      public io.vertx.redis.client.Response delexAndAwait(List<String> args)
      Conditionally removes the specified key based on value or digest comparison.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 8.4.0
      See Also:
      • DELEX
      • RedisAPI.delex(List)
    • delexAndForget

      public RedisAPI delexAndForget(List<String> args)
      Conditionally removes the specified key based on value or digest comparison.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 8.4.0
      See Also:
      • DELEX
      • RedisAPI.delex(List)
    • digest

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> digest(String arg0)
      Returns the XXH3 hash of a string value.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 8.4.0
      See Also:
      • DIGEST
      • RedisAPI.digest(String)
    • digestAndAwait

      public io.vertx.redis.client.Response digestAndAwait(String arg0)
      Returns the XXH3 hash of a string value.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 8.4.0
      See Also:
      • DIGEST
      • RedisAPI.digest(String)
    • digestAndForget

      public RedisAPI digestAndForget(String arg0)
      Returns the XXH3 hash of a string value.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 8.4.0
      See Also:
      • DIGEST
      • RedisAPI.digest(String)
    • discard

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> discard()
      Discards a transaction.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.0.0
      See Also:
    • discardAndAwait

      public io.vertx.redis.client.Response discardAndAwait()
      Discards a transaction.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.0.0
      See Also:
    • discardAndForget

      public RedisAPI discardAndForget()
      Discards a transaction.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.0.0
      See Also:
    • dump

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> dump(String arg0)
      Returns a serialized representation of the value stored at a key.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.6.0
      See Also:
      • DUMP
      • RedisAPI.dump(String)
    • dumpAndAwait

      public io.vertx.redis.client.Response dumpAndAwait(String arg0)
      Returns a serialized representation of the value stored at a key.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.6.0
      See Also:
      • DUMP
      • RedisAPI.dump(String)
    • dumpAndForget

      public RedisAPI dumpAndForget(String arg0)
      Returns a serialized representation of the value stored at a key.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.6.0
      See Also:
      • DUMP
      • RedisAPI.dump(String)
    • echo

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> echo(String arg0)
      Returns the given string.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • ECHO
      • RedisAPI.echo(String)
    • echoAndAwait

      public io.vertx.redis.client.Response echoAndAwait(String arg0)
      Returns the given string.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • ECHO
      • RedisAPI.echo(String)
    • echoAndForget

      public RedisAPI echoAndForget(String arg0)
      Returns the given string.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • ECHO
      • RedisAPI.echo(String)
    • eval

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> eval(List<String> args)
      Executes a server-side Lua script.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.6.0
      See Also:
      • EVAL
      • RedisAPI.eval(List)
    • evalAndAwait

      public io.vertx.redis.client.Response evalAndAwait(List<String> args)
      Executes a server-side Lua script.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.6.0
      See Also:
      • EVAL
      • RedisAPI.eval(List)
    • evalAndForget

      public RedisAPI evalAndForget(List<String> args)
      Executes a server-side Lua script.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.6.0
      See Also:
      • EVAL
      • RedisAPI.eval(List)
    • evalRo

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> evalRo(List<String> args)
      Executes a read-only server-side Lua script.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 7.0.0
      See Also:
    • evalRoAndAwait

      public io.vertx.redis.client.Response evalRoAndAwait(List<String> args)
      Executes a read-only server-side Lua script.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 7.0.0
      See Also:
    • evalRoAndForget

      public RedisAPI evalRoAndForget(List<String> args)
      Executes a read-only server-side Lua script.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 7.0.0
      See Also:
    • evalsha

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> evalsha(List<String> args)
      Executes a server-side Lua script by SHA1 digest.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.6.0
      See Also:
    • evalshaAndAwait

      public io.vertx.redis.client.Response evalshaAndAwait(List<String> args)
      Executes a server-side Lua script by SHA1 digest.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.6.0
      See Also:
    • evalshaAndForget

      public RedisAPI evalshaAndForget(List<String> args)
      Executes a server-side Lua script by SHA1 digest.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.6.0
      See Also:
    • evalshaRo

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> evalshaRo(List<String> args)
      Executes a read-only server-side Lua script by SHA1 digest.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 7.0.0
      See Also:
    • evalshaRoAndAwait

      public io.vertx.redis.client.Response evalshaRoAndAwait(List<String> args)
      Executes a read-only server-side Lua script by SHA1 digest.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 7.0.0
      See Also:
    • evalshaRoAndForget

      public RedisAPI evalshaRoAndForget(List<String> args)
      Executes a read-only server-side Lua script by SHA1 digest.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 7.0.0
      See Also:
    • exec

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> exec()
      Executes all commands in a transaction.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.2.0
      See Also:
      • EXEC
      • RedisAPI.exec()
    • execAndAwait

      public io.vertx.redis.client.Response execAndAwait()
      Executes all commands in a transaction.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.2.0
      See Also:
      • EXEC
      • RedisAPI.exec()
    • execAndForget

      public RedisAPI execAndForget()
      Executes all commands in a transaction.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.2.0
      See Also:
      • EXEC
      • RedisAPI.exec()
    • exists

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> exists(List<String> args)
      Determines whether one or more keys exist.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • EXISTS
      • RedisAPI.exists(List)
    • existsAndAwait

      public io.vertx.redis.client.Response existsAndAwait(List<String> args)
      Determines whether one or more keys exist.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • EXISTS
      • RedisAPI.exists(List)
    • existsAndForget

      public RedisAPI existsAndForget(List<String> args)
      Determines whether one or more keys exist.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • EXISTS
      • RedisAPI.exists(List)
    • expire

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> expire(List<String> args)
      Sets the expiration time of a key in seconds.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • EXPIRE
      • RedisAPI.expire(List)
    • expireAndAwait

      public io.vertx.redis.client.Response expireAndAwait(List<String> args)
      Sets the expiration time of a key in seconds.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • EXPIRE
      • RedisAPI.expire(List)
    • expireAndForget

      public RedisAPI expireAndForget(List<String> args)
      Sets the expiration time of a key in seconds.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • EXPIRE
      • RedisAPI.expire(List)
    • expireat

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> expireat(List<String> args)
      Sets the expiration time of a key to a Unix timestamp.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.2.0
      See Also:
    • expireatAndAwait

      public io.vertx.redis.client.Response expireatAndAwait(List<String> args)
      Sets the expiration time of a key to a Unix timestamp.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.2.0
      See Also:
    • expireatAndForget

      public RedisAPI expireatAndForget(List<String> args)
      Sets the expiration time of a key to a Unix timestamp.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.2.0
      See Also:
    • expiretime

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> expiretime(String arg0)
      Returns the expiration time of a key as a Unix timestamp.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 7.0.0
      See Also:
    • expiretimeAndAwait

      public io.vertx.redis.client.Response expiretimeAndAwait(String arg0)
      Returns the expiration time of a key as a Unix timestamp.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 7.0.0
      See Also:
    • expiretimeAndForget

      public RedisAPI expiretimeAndForget(String arg0)
      Returns the expiration time of a key as a Unix timestamp.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 7.0.0
      See Also:
    • failover

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> failover(List<String> args)
      Starts a coordinated failover from a server to one of its replicas.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 6.2.0
      See Also:
    • failoverAndAwait

      public io.vertx.redis.client.Response failoverAndAwait(List<String> args)
      Starts a coordinated failover from a server to one of its replicas.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 6.2.0
      See Also:
    • failoverAndForget

      public RedisAPI failoverAndForget(List<String> args)
      Starts a coordinated failover from a server to one of its replicas.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 6.2.0
      See Also:
    • fcall

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> fcall(List<String> args)
      Invokes a function.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 7.0.0
      See Also:
      • FCALL
      • RedisAPI.fcall(List)
    • fcallAndAwait

      public io.vertx.redis.client.Response fcallAndAwait(List<String> args)
      Invokes a function.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 7.0.0
      See Also:
      • FCALL
      • RedisAPI.fcall(List)
    • fcallAndForget

      public RedisAPI fcallAndForget(List<String> args)
      Invokes a function.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 7.0.0
      See Also:
      • FCALL
      • RedisAPI.fcall(List)
    • fcallRo

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> fcallRo(List<String> args)
      Invokes a read-only function.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 7.0.0
      See Also:
    • fcallRoAndAwait

      public io.vertx.redis.client.Response fcallRoAndAwait(List<String> args)
      Invokes a read-only function.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 7.0.0
      See Also:
    • fcallRoAndForget

      public RedisAPI fcallRoAndForget(List<String> args)
      Invokes a read-only function.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 7.0.0
      See Also:
    • flushall

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> flushall(List<String> args)
      Removes all keys from all databases.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
    • flushallAndAwait

      public io.vertx.redis.client.Response flushallAndAwait(List<String> args)
      Removes all keys from all databases.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
    • flushallAndForget

      public RedisAPI flushallAndForget(List<String> args)
      Removes all keys from all databases.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
    • flushdb

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> flushdb(List<String> args)
      Remove all keys from the current database.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
    • flushdbAndAwait

      public io.vertx.redis.client.Response flushdbAndAwait(List<String> args)
      Remove all keys from the current database.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
    • flushdbAndForget

      public RedisAPI flushdbAndForget(List<String> args)
      Remove all keys from the current database.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
    • function

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> function(List<String> args)
      A container for function commands.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 7.0.0
      See Also:
    • functionAndAwait

      public io.vertx.redis.client.Response functionAndAwait(List<String> args)
      A container for function commands.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 7.0.0
      See Also:
    • functionAndForget

      public RedisAPI functionAndForget(List<String> args)
      A container for function commands.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 7.0.0
      See Also:
    • geoadd

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> geoadd(List<String> args)
      Adds one or more members to a geospatial index. The key is created if it doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 3.2.0
      See Also:
      • GEOADD
      • RedisAPI.geoadd(List)
    • geoaddAndAwait

      public io.vertx.redis.client.Response geoaddAndAwait(List<String> args)
      Adds one or more members to a geospatial index. The key is created if it doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 3.2.0
      See Also:
      • GEOADD
      • RedisAPI.geoadd(List)
    • geoaddAndForget

      public RedisAPI geoaddAndForget(List<String> args)
      Adds one or more members to a geospatial index. The key is created if it doesn't exist.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 3.2.0
      See Also:
      • GEOADD
      • RedisAPI.geoadd(List)
    • geodist

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> geodist(List<String> args)
      Returns the distance between two members of a geospatial index.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 3.2.0
      See Also:
    • geodistAndAwait

      public io.vertx.redis.client.Response geodistAndAwait(List<String> args)
      Returns the distance between two members of a geospatial index.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 3.2.0
      See Also:
    • geodistAndForget

      public RedisAPI geodistAndForget(List<String> args)
      Returns the distance between two members of a geospatial index.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 3.2.0
      See Also:
    • geohash

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> geohash(List<String> args)
      Returns members from a geospatial index as geohash strings.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 3.2.0
      See Also:
    • geohashAndAwait

      public io.vertx.redis.client.Response geohashAndAwait(List<String> args)
      Returns members from a geospatial index as geohash strings.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 3.2.0
      See Also:
    • geohashAndForget

      public RedisAPI geohashAndForget(List<String> args)
      Returns members from a geospatial index as geohash strings.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 3.2.0
      See Also:
    • geopos

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> geopos(List<String> args)
      Returns the longitude and latitude of members from a geospatial index.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 3.2.0
      See Also:
      • GEOPOS
      • RedisAPI.geopos(List)
    • geoposAndAwait

      public io.vertx.redis.client.Response geoposAndAwait(List<String> args)
      Returns the longitude and latitude of members from a geospatial index.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 3.2.0
      See Also:
      • GEOPOS
      • RedisAPI.geopos(List)
    • geoposAndForget

      public RedisAPI geoposAndForget(List<String> args)
      Returns the longitude and latitude of members from a geospatial index.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 3.2.0
      See Also:
      • GEOPOS
      • RedisAPI.geopos(List)
    • georadius

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> georadius(List<String> args)
      Deprecated.
      since Redis 6.2.0, replaced by: GEOSEARCH and GEOSEARCHSTORE with the BYRADIUS argument
      Queries a geospatial index for members within a distance from a coordinate, optionally stores the result.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 3.2.0
      See Also:
    • georadiusAndAwait

      public io.vertx.redis.client.Response georadiusAndAwait(List<String> args)
      Deprecated.
      since Redis 6.2.0, replaced by: GEOSEARCH and GEOSEARCHSTORE with the BYRADIUS argument
      Queries a geospatial index for members within a distance from a coordinate, optionally stores the result.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 3.2.0
      See Also:
    • georadiusAndForget

      public RedisAPI georadiusAndForget(List<String> args)
      Deprecated.
      since Redis 6.2.0, replaced by: GEOSEARCH and GEOSEARCHSTORE with the BYRADIUS argument
      Queries a geospatial index for members within a distance from a coordinate, optionally stores the result.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 3.2.0
      See Also:
    • georadiusRo

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> georadiusRo(List<String> args)
      Deprecated.
      since Redis 6.2.0, replaced by: GEOSEARCH with the BYRADIUS argument
      Returns members from a geospatial index that are within a distance from a coordinate.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 3.2.10
      See Also:
    • georadiusRoAndAwait

      public io.vertx.redis.client.Response georadiusRoAndAwait(List<String> args)
      Deprecated.
      since Redis 6.2.0, replaced by: GEOSEARCH with the BYRADIUS argument
      Returns members from a geospatial index that are within a distance from a coordinate.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 3.2.10
      See Also:
    • georadiusRoAndForget

      public RedisAPI georadiusRoAndForget(List<String> args)
      Deprecated.
      since Redis 6.2.0, replaced by: GEOSEARCH with the BYRADIUS argument
      Returns members from a geospatial index that are within a distance from a coordinate.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 3.2.10
      See Also:
    • georadiusbymember

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> georadiusbymember(List<String> args)
      Deprecated.
      since Redis 6.2.0, replaced by: GEOSEARCH and GEOSEARCHSTORE with the BYRADIUS and FROMMEMBER arguments
      Queries a geospatial index for members within a distance from a member, optionally stores the result.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 3.2.0
      See Also:
    • georadiusbymemberAndAwait

      public io.vertx.redis.client.Response georadiusbymemberAndAwait(List<String> args)
      Deprecated.
      since Redis 6.2.0, replaced by: GEOSEARCH and GEOSEARCHSTORE with the BYRADIUS and FROMMEMBER arguments
      Queries a geospatial index for members within a distance from a member, optionally stores the result.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 3.2.0
      See Also:
    • georadiusbymemberAndForget

      public RedisAPI georadiusbymemberAndForget(List<String> args)
      Deprecated.
      since Redis 6.2.0, replaced by: GEOSEARCH and GEOSEARCHSTORE with the BYRADIUS and FROMMEMBER arguments
      Queries a geospatial index for members within a distance from a member, optionally stores the result.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 3.2.0
      See Also:
    • georadiusbymemberRo

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> georadiusbymemberRo(List<String> args)
      Deprecated.
      since Redis 6.2.0, replaced by: GEOSEARCH with the BYRADIUS and FROMMEMBER arguments
      Returns members from a geospatial index that are within a distance from a member.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 3.2.10
      See Also:
    • georadiusbymemberRoAndAwait

      public io.vertx.redis.client.Response georadiusbymemberRoAndAwait(List<String> args)
      Deprecated.
      since Redis 6.2.0, replaced by: GEOSEARCH with the BYRADIUS and FROMMEMBER arguments
      Returns members from a geospatial index that are within a distance from a member.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 3.2.10
      See Also:
    • georadiusbymemberRoAndForget

      public RedisAPI georadiusbymemberRoAndForget(List<String> args)
      Deprecated.
      since Redis 6.2.0, replaced by: GEOSEARCH with the BYRADIUS and FROMMEMBER arguments
      Returns members from a geospatial index that are within a distance from a member.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 3.2.10
      See Also:
    • geosearch

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> geosearch(List<String> args)
      Queries a geospatial index for members inside an area of a box or a circle.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 6.2.0
      See Also:
    • geosearchAndAwait

      public io.vertx.redis.client.Response geosearchAndAwait(List<String> args)
      Queries a geospatial index for members inside an area of a box or a circle.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 6.2.0
      See Also:
    • geosearchAndForget

      public RedisAPI geosearchAndForget(List<String> args)
      Queries a geospatial index for members inside an area of a box or a circle.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 6.2.0
      See Also:
    • geosearchstore

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> geosearchstore(List<String> args)
      Queries a geospatial index for members inside an area of a box or a circle, optionally stores the result.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 6.2.0
      See Also:
    • geosearchstoreAndAwait

      public io.vertx.redis.client.Response geosearchstoreAndAwait(List<String> args)
      Queries a geospatial index for members inside an area of a box or a circle, optionally stores the result.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 6.2.0
      See Also:
    • geosearchstoreAndForget

      public RedisAPI geosearchstoreAndForget(List<String> args)
      Queries a geospatial index for members inside an area of a box or a circle, optionally stores the result.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 6.2.0
      See Also:
    • get

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> get(String arg0)
      Returns the string value of a key.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • GET
      • RedisAPI.get(String)
    • getAndAwait

      public io.vertx.redis.client.Response getAndAwait(String arg0)
      Returns the string value of a key.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • GET
      • RedisAPI.get(String)
    • getAndForget

      public RedisAPI getAndForget(String arg0)
      Returns the string value of a key.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • GET
      • RedisAPI.get(String)
    • getbit

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> getbit(String arg0, String arg1)
      Returns a bit value by offset.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.2.0
      See Also:
      • GETBIT
      • RedisAPI.getbit(String, String)
    • getbitAndAwait

      public io.vertx.redis.client.Response getbitAndAwait(String arg0, String arg1)
      Returns a bit value by offset.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.2.0
      See Also:
      • GETBIT
      • RedisAPI.getbit(String, String)
    • getbitAndForget

      public RedisAPI getbitAndForget(String arg0, String arg1)
      Returns a bit value by offset.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.2.0
      See Also:
      • GETBIT
      • RedisAPI.getbit(String, String)
    • getdel

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> getdel(String arg0)
      Returns the string value of a key after deleting the key.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 6.2.0
      See Also:
      • GETDEL
      • RedisAPI.getdel(String)
    • getdelAndAwait

      public io.vertx.redis.client.Response getdelAndAwait(String arg0)
      Returns the string value of a key after deleting the key.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 6.2.0
      See Also:
      • GETDEL
      • RedisAPI.getdel(String)
    • getdelAndForget

      public RedisAPI getdelAndForget(String arg0)
      Returns the string value of a key after deleting the key.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 6.2.0
      See Also:
      • GETDEL
      • RedisAPI.getdel(String)
    • getex

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> getex(List<String> args)
      Returns the string value of a key after setting its expiration time.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 6.2.0
      See Also:
      • GETEX
      • RedisAPI.getex(List)
    • getexAndAwait

      public io.vertx.redis.client.Response getexAndAwait(List<String> args)
      Returns the string value of a key after setting its expiration time.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 6.2.0
      See Also:
      • GETEX
      • RedisAPI.getex(List)
    • getexAndForget

      public RedisAPI getexAndForget(List<String> args)
      Returns the string value of a key after setting its expiration time.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 6.2.0
      See Also:
      • GETEX
      • RedisAPI.getex(List)
    • getrange

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> getrange(String arg0, String arg1, String arg2)
      Returns a substring of the string stored at a key.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.4.0
      See Also:
      • GETRANGE
      • RedisAPI.getrange(String, String, String)
    • getrangeAndAwait

      public io.vertx.redis.client.Response getrangeAndAwait(String arg0, String arg1, String arg2)
      Returns a substring of the string stored at a key.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.4.0
      See Also:
      • GETRANGE
      • RedisAPI.getrange(String, String, String)
    • getrangeAndForget

      public RedisAPI getrangeAndForget(String arg0, String arg1, String arg2)
      Returns a substring of the string stored at a key.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.4.0
      See Also:
      • GETRANGE
      • RedisAPI.getrange(String, String, String)
    • getset

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> getset(String arg0, String arg1)
      Deprecated.
      since Redis 6.2.0, replaced by: SET with the !GET argument
      Returns the previous string value of a key after setting it to a new value.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • GETSET
      • RedisAPI.getset(String, String)
    • getsetAndAwait

      public io.vertx.redis.client.Response getsetAndAwait(String arg0, String arg1)
      Deprecated.
      since Redis 6.2.0, replaced by: SET with the !GET argument
      Returns the previous string value of a key after setting it to a new value.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • GETSET
      • RedisAPI.getset(String, String)
    • getsetAndForget

      public RedisAPI getsetAndForget(String arg0, String arg1)
      Deprecated.
      since Redis 6.2.0, replaced by: SET with the !GET argument
      Returns the previous string value of a key after setting it to a new value.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • GETSET
      • RedisAPI.getset(String, String)
    • graphBulk

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> graphBulk(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
    • graphBulkAndAwait

      public io.vertx.redis.client.Response graphBulkAndAwait(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
    • graphBulkAndForget

      public RedisAPI graphBulkAndForget(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
    • graphConfig

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> graphConfig(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
    • graphConfigAndAwait

      public io.vertx.redis.client.Response graphConfigAndAwait(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
    • graphConfigAndForget

      public RedisAPI graphConfigAndForget(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
    • graphDebug

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> graphDebug(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
    • graphDebugAndAwait

      public io.vertx.redis.client.Response graphDebugAndAwait(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
    • graphDebugAndForget

      public RedisAPI graphDebugAndForget(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
    • graphDelete

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> graphDelete(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
    • graphDeleteAndAwait

      public io.vertx.redis.client.Response graphDeleteAndAwait(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
    • graphDeleteAndForget

      public RedisAPI graphDeleteAndForget(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
    • graphExplain

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> graphExplain(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
    • graphExplainAndAwait

      public io.vertx.redis.client.Response graphExplainAndAwait(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
    • graphExplainAndForget

      public RedisAPI graphExplainAndForget(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
    • graphList

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> graphList(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
    • graphListAndAwait

      public io.vertx.redis.client.Response graphListAndAwait(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
    • graphListAndForget

      public RedisAPI graphListAndForget(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
    • graphProfile

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> graphProfile(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
    • graphProfileAndAwait

      public io.vertx.redis.client.Response graphProfileAndAwait(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
    • graphProfileAndForget

      public RedisAPI graphProfileAndForget(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
    • graphQuery

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> graphQuery(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
    • graphQueryAndAwait

      public io.vertx.redis.client.Response graphQueryAndAwait(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
    • graphQueryAndForget

      public RedisAPI graphQueryAndForget(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
    • graphRoQuery

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> graphRoQuery(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
    • graphRoQueryAndAwait

      public io.vertx.redis.client.Response graphRoQueryAndAwait(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
    • graphRoQueryAndForget

      public RedisAPI graphRoQueryAndForget(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
    • graphSlowlog

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> graphSlowlog(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
    • graphSlowlogAndAwait

      public io.vertx.redis.client.Response graphSlowlogAndAwait(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
    • graphSlowlogAndForget

      public RedisAPI graphSlowlogAndForget(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
    • hdel

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> hdel(List<String> args)
      Deletes one or more fields and their values from a hash. Deletes the hash if no fields remain.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.0.0
      See Also:
      • HDEL
      • RedisAPI.hdel(List)
    • hdelAndAwait

      public io.vertx.redis.client.Response hdelAndAwait(List<String> args)
      Deletes one or more fields and their values from a hash. Deletes the hash if no fields remain.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.0.0
      See Also:
      • HDEL
      • RedisAPI.hdel(List)
    • hdelAndForget

      public RedisAPI hdelAndForget(List<String> args)
      Deletes one or more fields and their values from a hash. Deletes the hash if no fields remain.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.0.0
      See Also:
      • HDEL
      • RedisAPI.hdel(List)
    • hello

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> hello(List<String> args)
      Handshakes with the Redis server.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 6.0.0
      See Also:
      • HELLO
      • RedisAPI.hello(List)
    • helloAndAwait

      public io.vertx.redis.client.Response helloAndAwait(List<String> args)
      Handshakes with the Redis server.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 6.0.0
      See Also:
      • HELLO
      • RedisAPI.hello(List)
    • helloAndForget

      public RedisAPI helloAndForget(List<String> args)
      Handshakes with the Redis server.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 6.0.0
      See Also:
      • HELLO
      • RedisAPI.hello(List)
    • hexists

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> hexists(String arg0, String arg1)
      Determines whether a field exists in a hash.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.0.0
      See Also:
      • HEXISTS
      • RedisAPI.hexists(String, String)
    • hexistsAndAwait

      public io.vertx.redis.client.Response hexistsAndAwait(String arg0, String arg1)
      Determines whether a field exists in a hash.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.0.0
      See Also:
      • HEXISTS
      • RedisAPI.hexists(String, String)
    • hexistsAndForget

      public RedisAPI hexistsAndForget(String arg0, String arg1)
      Determines whether a field exists in a hash.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.0.0
      See Also:
      • HEXISTS
      • RedisAPI.hexists(String, String)
    • hexpire

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> hexpire(List<String> args)
      Set expiry for hash field using relative time to expire (seconds).

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 7.4.0
      See Also:
    • hexpireAndAwait

      public io.vertx.redis.client.Response hexpireAndAwait(List<String> args)
      Set expiry for hash field using relative time to expire (seconds).

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 7.4.0
      See Also:
    • hexpireAndForget

      public RedisAPI hexpireAndForget(List<String> args)
      Set expiry for hash field using relative time to expire (seconds).

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 7.4.0
      See Also:
    • hexpireat

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> hexpireat(List<String> args)
      Set expiry for hash field using an absolute Unix timestamp (seconds).

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 7.4.0
      See Also:
    • hexpireatAndAwait

      public io.vertx.redis.client.Response hexpireatAndAwait(List<String> args)
      Set expiry for hash field using an absolute Unix timestamp (seconds).

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 7.4.0
      See Also:
    • hexpireatAndForget

      public RedisAPI hexpireatAndForget(List<String> args)
      Set expiry for hash field using an absolute Unix timestamp (seconds).

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 7.4.0
      See Also:
    • hexpiretime

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> hexpiretime(List<String> args)
      Returns the expiration time of a hash field as a Unix timestamp, in seconds.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 7.4.0
      See Also:
    • hexpiretimeAndAwait

      public io.vertx.redis.client.Response hexpiretimeAndAwait(List<String> args)
      Returns the expiration time of a hash field as a Unix timestamp, in seconds.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 7.4.0
      See Also:
    • hexpiretimeAndForget

      public RedisAPI hexpiretimeAndForget(List<String> args)
      Returns the expiration time of a hash field as a Unix timestamp, in seconds.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 7.4.0
      See Also:
    • hget

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> hget(String arg0, String arg1)
      Returns the value of a field in a hash.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.0.0
      See Also:
      • HGET
      • RedisAPI.hget(String, String)
    • hgetAndAwait

      public io.vertx.redis.client.Response hgetAndAwait(String arg0, String arg1)
      Returns the value of a field in a hash.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.0.0
      See Also:
      • HGET
      • RedisAPI.hget(String, String)
    • hgetAndForget

      public RedisAPI hgetAndForget(String arg0, String arg1)
      Returns the value of a field in a hash.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.0.0
      See Also:
      • HGET
      • RedisAPI.hget(String, String)
    • hgetall

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> hgetall(String arg0)
      Returns all fields and values in a hash.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.0.0
      See Also:
    • hgetallAndAwait

      public io.vertx.redis.client.Response hgetallAndAwait(String arg0)
      Returns all fields and values in a hash.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.0.0
      See Also:
    • hgetallAndForget

      public RedisAPI hgetallAndForget(String arg0)
      Returns all fields and values in a hash.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.0.0
      See Also:
    • hgetdel

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> hgetdel(List<String> args)
      Returns the value of a field and deletes it from the hash.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 8.0.0
      See Also:
    • hgetdelAndAwait

      public io.vertx.redis.client.Response hgetdelAndAwait(List<String> args)
      Returns the value of a field and deletes it from the hash.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 8.0.0
      See Also:
    • hgetdelAndForget

      public RedisAPI hgetdelAndForget(List<String> args)
      Returns the value of a field and deletes it from the hash.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 8.0.0
      See Also:
    • hgetex

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> hgetex(List<String> args)
      Get the value of one or more fields of a given hash key, and optionally set their expiration.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 8.0.0
      See Also:
      • HGETEX
      • RedisAPI.hgetex(List)
    • hgetexAndAwait

      public io.vertx.redis.client.Response hgetexAndAwait(List<String> args)
      Get the value of one or more fields of a given hash key, and optionally set their expiration.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 8.0.0
      See Also:
      • HGETEX
      • RedisAPI.hgetex(List)
    • hgetexAndForget

      public RedisAPI hgetexAndForget(List<String> args)
      Get the value of one or more fields of a given hash key, and optionally set their expiration.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 8.0.0
      See Also:
      • HGETEX
      • RedisAPI.hgetex(List)
    • hincrby

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> hincrby(String arg0, String arg1, String arg2)
      Increments the integer value of a field in a hash by a number. Uses 0 as initial value if the field doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.0.0
      See Also:
      • HINCRBY
      • RedisAPI.hincrby(String, String, String)
    • hincrbyAndAwait

      public io.vertx.redis.client.Response hincrbyAndAwait(String arg0, String arg1, String arg2)
      Increments the integer value of a field in a hash by a number. Uses 0 as initial value if the field doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.0.0
      See Also:
      • HINCRBY
      • RedisAPI.hincrby(String, String, String)
    • hincrbyAndForget

      public RedisAPI hincrbyAndForget(String arg0, String arg1, String arg2)
      Increments the integer value of a field in a hash by a number. Uses 0 as initial value if the field doesn't exist.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.0.0
      See Also:
      • HINCRBY
      • RedisAPI.hincrby(String, String, String)
    • hincrbyfloat

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> hincrbyfloat(String arg0, String arg1, String arg2)
      Increments the floating point value of a field by a number. Uses 0 as initial value if the field doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.6.0
      See Also:
      • HINCRBYFLOAT
      • RedisAPI.hincrbyfloat(String, String, String)
    • hincrbyfloatAndAwait

      public io.vertx.redis.client.Response hincrbyfloatAndAwait(String arg0, String arg1, String arg2)
      Increments the floating point value of a field by a number. Uses 0 as initial value if the field doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.6.0
      See Also:
      • HINCRBYFLOAT
      • RedisAPI.hincrbyfloat(String, String, String)
    • hincrbyfloatAndForget

      public RedisAPI hincrbyfloatAndForget(String arg0, String arg1, String arg2)
      Increments the floating point value of a field by a number. Uses 0 as initial value if the field doesn't exist.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.6.0
      See Also:
      • HINCRBYFLOAT
      • RedisAPI.hincrbyfloat(String, String, String)
    • hkeys

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> hkeys(String arg0)
      Returns all fields in a hash.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.0.0
      See Also:
      • HKEYS
      • RedisAPI.hkeys(String)
    • hkeysAndAwait

      public io.vertx.redis.client.Response hkeysAndAwait(String arg0)
      Returns all fields in a hash.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.0.0
      See Also:
      • HKEYS
      • RedisAPI.hkeys(String)
    • hkeysAndForget

      public RedisAPI hkeysAndForget(String arg0)
      Returns all fields in a hash.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.0.0
      See Also:
      • HKEYS
      • RedisAPI.hkeys(String)
    • hlen

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> hlen(String arg0)
      Returns the number of fields in a hash.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.0.0
      See Also:
      • HLEN
      • RedisAPI.hlen(String)
    • hlenAndAwait

      public io.vertx.redis.client.Response hlenAndAwait(String arg0)
      Returns the number of fields in a hash.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.0.0
      See Also:
      • HLEN
      • RedisAPI.hlen(String)
    • hlenAndForget

      public RedisAPI hlenAndForget(String arg0)
      Returns the number of fields in a hash.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.0.0
      See Also:
      • HLEN
      • RedisAPI.hlen(String)
    • hmget

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> hmget(List<String> args)
      Returns the values of all fields in a hash.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.0.0
      See Also:
      • HMGET
      • RedisAPI.hmget(List)
    • hmgetAndAwait

      public io.vertx.redis.client.Response hmgetAndAwait(List<String> args)
      Returns the values of all fields in a hash.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.0.0
      See Also:
      • HMGET
      • RedisAPI.hmget(List)
    • hmgetAndForget

      public RedisAPI hmgetAndForget(List<String> args)
      Returns the values of all fields in a hash.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.0.0
      See Also:
      • HMGET
      • RedisAPI.hmget(List)
    • hmset

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> hmset(List<String> args)
      Deprecated.
      since Redis 4.0.0, replaced by: HSET with multiple field-value pairs
      Sets the values of multiple fields.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.0.0
      See Also:
      • HMSET
      • RedisAPI.hmset(List)
    • hmsetAndAwait

      public io.vertx.redis.client.Response hmsetAndAwait(List<String> args)
      Deprecated.
      since Redis 4.0.0, replaced by: HSET with multiple field-value pairs
      Sets the values of multiple fields.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.0.0
      See Also:
      • HMSET
      • RedisAPI.hmset(List)
    • hmsetAndForget

      public RedisAPI hmsetAndForget(List<String> args)
      Deprecated.
      since Redis 4.0.0, replaced by: HSET with multiple field-value pairs
      Sets the values of multiple fields.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.0.0
      See Also:
      • HMSET
      • RedisAPI.hmset(List)
    • hotkeys

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> hotkeys(List<String> args)
      A container for hotkeys tracking commands.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 8.6.0
      See Also:
    • hotkeysAndAwait

      public io.vertx.redis.client.Response hotkeysAndAwait(List<String> args)
      A container for hotkeys tracking commands.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 8.6.0
      See Also:
    • hotkeysAndForget

      public RedisAPI hotkeysAndForget(List<String> args)
      A container for hotkeys tracking commands.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 8.6.0
      See Also:
    • hpersist

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> hpersist(List<String> args)
      Removes the expiration time for each specified field.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 7.4.0
      See Also:
    • hpersistAndAwait

      public io.vertx.redis.client.Response hpersistAndAwait(List<String> args)
      Removes the expiration time for each specified field.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 7.4.0
      See Also:
    • hpersistAndForget

      public RedisAPI hpersistAndForget(List<String> args)
      Removes the expiration time for each specified field.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 7.4.0
      See Also:
    • hpexpire

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> hpexpire(List<String> args)
      Set expiry for hash field using relative time to expire (milliseconds).

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 7.4.0
      See Also:
    • hpexpireAndAwait

      public io.vertx.redis.client.Response hpexpireAndAwait(List<String> args)
      Set expiry for hash field using relative time to expire (milliseconds).

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 7.4.0
      See Also:
    • hpexpireAndForget

      public RedisAPI hpexpireAndForget(List<String> args)
      Set expiry for hash field using relative time to expire (milliseconds).

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 7.4.0
      See Also:
    • hpexpireat

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> hpexpireat(List<String> args)
      Set expiry for hash field using an absolute Unix timestamp (milliseconds).

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 7.4.0
      See Also:
    • hpexpireatAndAwait

      public io.vertx.redis.client.Response hpexpireatAndAwait(List<String> args)
      Set expiry for hash field using an absolute Unix timestamp (milliseconds).

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 7.4.0
      See Also:
    • hpexpireatAndForget

      public RedisAPI hpexpireatAndForget(List<String> args)
      Set expiry for hash field using an absolute Unix timestamp (milliseconds).

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 7.4.0
      See Also:
    • hpexpiretime

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> hpexpiretime(List<String> args)
      Returns the expiration time of a hash field as a Unix timestamp, in msec.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 7.4.0
      See Also:
    • hpexpiretimeAndAwait

      public io.vertx.redis.client.Response hpexpiretimeAndAwait(List<String> args)
      Returns the expiration time of a hash field as a Unix timestamp, in msec.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 7.4.0
      See Also:
    • hpexpiretimeAndForget

      public RedisAPI hpexpiretimeAndForget(List<String> args)
      Returns the expiration time of a hash field as a Unix timestamp, in msec.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 7.4.0
      See Also:
    • hpttl

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> hpttl(List<String> args)
      Returns the TTL in milliseconds of a hash field.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 7.4.0
      See Also:
      • HPTTL
      • RedisAPI.hpttl(List)
    • hpttlAndAwait

      public io.vertx.redis.client.Response hpttlAndAwait(List<String> args)
      Returns the TTL in milliseconds of a hash field.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 7.4.0
      See Also:
      • HPTTL
      • RedisAPI.hpttl(List)
    • hpttlAndForget

      public RedisAPI hpttlAndForget(List<String> args)
      Returns the TTL in milliseconds of a hash field.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 7.4.0
      See Also:
      • HPTTL
      • RedisAPI.hpttl(List)
    • hrandfield

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> hrandfield(List<String> args)
      Returns one or more random fields from a hash.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 6.2.0
      See Also:
    • hrandfieldAndAwait

      public io.vertx.redis.client.Response hrandfieldAndAwait(List<String> args)
      Returns one or more random fields from a hash.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 6.2.0
      See Also:
    • hrandfieldAndForget

      public RedisAPI hrandfieldAndForget(List<String> args)
      Returns one or more random fields from a hash.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 6.2.0
      See Also:
    • hscan

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> hscan(List<String> args)
      Iterates over fields and values of a hash.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.8.0
      See Also:
      • HSCAN
      • RedisAPI.hscan(List)
    • hscanAndAwait

      public io.vertx.redis.client.Response hscanAndAwait(List<String> args)
      Iterates over fields and values of a hash.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.8.0
      See Also:
      • HSCAN
      • RedisAPI.hscan(List)
    • hscanAndForget

      public RedisAPI hscanAndForget(List<String> args)
      Iterates over fields and values of a hash.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.8.0
      See Also:
      • HSCAN
      • RedisAPI.hscan(List)
    • hset

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> hset(List<String> args)
      Creates or modifies the value of a field in a hash.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.0.0
      See Also:
      • HSET
      • RedisAPI.hset(List)
    • hsetAndAwait

      public io.vertx.redis.client.Response hsetAndAwait(List<String> args)
      Creates or modifies the value of a field in a hash.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.0.0
      See Also:
      • HSET
      • RedisAPI.hset(List)
    • hsetAndForget

      public RedisAPI hsetAndForget(List<String> args)
      Creates or modifies the value of a field in a hash.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.0.0
      See Also:
      • HSET
      • RedisAPI.hset(List)
    • hsetex

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> hsetex(List<String> args)
      Set the value of one or more fields of a given hash key, and optionally set their expiration.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 8.0.0
      See Also:
      • HSETEX
      • RedisAPI.hsetex(List)
    • hsetexAndAwait

      public io.vertx.redis.client.Response hsetexAndAwait(List<String> args)
      Set the value of one or more fields of a given hash key, and optionally set their expiration.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 8.0.0
      See Also:
      • HSETEX
      • RedisAPI.hsetex(List)
    • hsetexAndForget

      public RedisAPI hsetexAndForget(List<String> args)
      Set the value of one or more fields of a given hash key, and optionally set their expiration.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 8.0.0
      See Also:
      • HSETEX
      • RedisAPI.hsetex(List)
    • hsetnx

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> hsetnx(String arg0, String arg1, String arg2)
      Sets the value of a field in a hash only when the field doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.0.0
      See Also:
      • HSETNX
      • RedisAPI.hsetnx(String, String, String)
    • hsetnxAndAwait

      public io.vertx.redis.client.Response hsetnxAndAwait(String arg0, String arg1, String arg2)
      Sets the value of a field in a hash only when the field doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.0.0
      See Also:
      • HSETNX
      • RedisAPI.hsetnx(String, String, String)
    • hsetnxAndForget

      public RedisAPI hsetnxAndForget(String arg0, String arg1, String arg2)
      Sets the value of a field in a hash only when the field doesn't exist.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.0.0
      See Also:
      • HSETNX
      • RedisAPI.hsetnx(String, String, String)
    • hstrlen

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> hstrlen(String arg0, String arg1)
      Returns the length of the value of a field.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 3.2.0
      See Also:
      • HSTRLEN
      • RedisAPI.hstrlen(String, String)
    • hstrlenAndAwait

      public io.vertx.redis.client.Response hstrlenAndAwait(String arg0, String arg1)
      Returns the length of the value of a field.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 3.2.0
      See Also:
      • HSTRLEN
      • RedisAPI.hstrlen(String, String)
    • hstrlenAndForget

      public RedisAPI hstrlenAndForget(String arg0, String arg1)
      Returns the length of the value of a field.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 3.2.0
      See Also:
      • HSTRLEN
      • RedisAPI.hstrlen(String, String)
    • httl

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> httl(List<String> args)
      Returns the TTL in seconds of a hash field.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 7.4.0
      See Also:
      • HTTL
      • RedisAPI.httl(List)
    • httlAndAwait

      public io.vertx.redis.client.Response httlAndAwait(List<String> args)
      Returns the TTL in seconds of a hash field.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 7.4.0
      See Also:
      • HTTL
      • RedisAPI.httl(List)
    • httlAndForget

      public RedisAPI httlAndForget(List<String> args)
      Returns the TTL in seconds of a hash field.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 7.4.0
      See Also:
      • HTTL
      • RedisAPI.httl(List)
    • hvals

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> hvals(String arg0)
      Returns all values in a hash.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.0.0
      See Also:
      • HVALS
      • RedisAPI.hvals(String)
    • hvalsAndAwait

      public io.vertx.redis.client.Response hvalsAndAwait(String arg0)
      Returns all values in a hash.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.0.0
      See Also:
      • HVALS
      • RedisAPI.hvals(String)
    • hvalsAndForget

      public RedisAPI hvalsAndForget(String arg0)
      Returns all values in a hash.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.0.0
      See Also:
      • HVALS
      • RedisAPI.hvals(String)
    • incr

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> incr(String arg0)
      Increments the integer value of a key by one. Uses 0 as initial value if the key doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • INCR
      • RedisAPI.incr(String)
    • incrAndAwait

      public io.vertx.redis.client.Response incrAndAwait(String arg0)
      Increments the integer value of a key by one. Uses 0 as initial value if the key doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • INCR
      • RedisAPI.incr(String)
    • incrAndForget

      public RedisAPI incrAndForget(String arg0)
      Increments the integer value of a key by one. Uses 0 as initial value if the key doesn't exist.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • INCR
      • RedisAPI.incr(String)
    • incrby

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> incrby(String arg0, String arg1)
      Increments the integer value of a key by a number. Uses 0 as initial value if the key doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • INCRBY
      • RedisAPI.incrby(String, String)
    • incrbyAndAwait

      public io.vertx.redis.client.Response incrbyAndAwait(String arg0, String arg1)
      Increments the integer value of a key by a number. Uses 0 as initial value if the key doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • INCRBY
      • RedisAPI.incrby(String, String)
    • incrbyAndForget

      public RedisAPI incrbyAndForget(String arg0, String arg1)
      Increments the integer value of a key by a number. Uses 0 as initial value if the key doesn't exist.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • INCRBY
      • RedisAPI.incrby(String, String)
    • incrbyfloat

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> incrbyfloat(String arg0, String arg1)
      Increment the floating point value of a key by a number. Uses 0 as initial value if the key doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.6.0
      See Also:
    • incrbyfloatAndAwait

      public io.vertx.redis.client.Response incrbyfloatAndAwait(String arg0, String arg1)
      Increment the floating point value of a key by a number. Uses 0 as initial value if the key doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.6.0
      See Also:
    • incrbyfloatAndForget

      public RedisAPI incrbyfloatAndForget(String arg0, String arg1)
      Increment the floating point value of a key by a number. Uses 0 as initial value if the key doesn't exist.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.6.0
      See Also:
    • info

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> info(List<String> args)
      Returns information and statistics about the server.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • INFO
      • RedisAPI.info(List)
    • infoAndAwait

      public io.vertx.redis.client.Response infoAndAwait(List<String> args)
      Returns information and statistics about the server.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • INFO
      • RedisAPI.info(List)
    • infoAndForget

      public RedisAPI infoAndForget(List<String> args)
      Returns information and statistics about the server.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • INFO
      • RedisAPI.info(List)
    • jsonArrappend

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> jsonArrappend(List<String> args)
      Append the JSON values into the array at path after the last element in it.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonArrappendAndAwait

      public io.vertx.redis.client.Response jsonArrappendAndAwait(List<String> args)
      Append the JSON values into the array at path after the last element in it.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonArrappendAndForget

      public RedisAPI jsonArrappendAndForget(List<String> args)
      Append the JSON values into the array at path after the last element in it.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonArrindex

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> jsonArrindex(List<String> args)
      Search for the first occurrence of a JSON value in an array.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonArrindexAndAwait

      public io.vertx.redis.client.Response jsonArrindexAndAwait(List<String> args)
      Search for the first occurrence of a JSON value in an array.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonArrindexAndForget

      public RedisAPI jsonArrindexAndForget(List<String> args)
      Search for the first occurrence of a JSON value in an array.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonArrinsert

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> jsonArrinsert(List<String> args)
      Insert the json values into the array at path before the index (shifts to the right).

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonArrinsertAndAwait

      public io.vertx.redis.client.Response jsonArrinsertAndAwait(List<String> args)
      Insert the json values into the array at path before the index (shifts to the right).

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonArrinsertAndForget

      public RedisAPI jsonArrinsertAndForget(List<String> args)
      Insert the json values into the array at path before the index (shifts to the right).

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonArrlen

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> jsonArrlen(List<String> args)
      Report the length of the JSON array at path in key.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonArrlenAndAwait

      public io.vertx.redis.client.Response jsonArrlenAndAwait(List<String> args)
      Report the length of the JSON array at path in key.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonArrlenAndForget

      public RedisAPI jsonArrlenAndForget(List<String> args)
      Report the length of the JSON array at path in key.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonArrpop

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> jsonArrpop(List<String> args)
      Remove and return the element at the specified index in the array at path.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonArrpopAndAwait

      public io.vertx.redis.client.Response jsonArrpopAndAwait(List<String> args)
      Remove and return the element at the specified index in the array at path.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonArrpopAndForget

      public RedisAPI jsonArrpopAndForget(List<String> args)
      Remove and return the element at the specified index in the array at path.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonArrtrim

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> jsonArrtrim(String arg0, String arg1, String arg2, String arg3)
      Trim an array so that it contains only the specified inclusive range of elements.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis ReJSON 1.0.0
      See Also:
      • JSON.ARRTRIM
      • RedisAPI.jsonArrtrim(String, String, String, String)
    • jsonArrtrimAndAwait

      public io.vertx.redis.client.Response jsonArrtrimAndAwait(String arg0, String arg1, String arg2, String arg3)
      Trim an array so that it contains only the specified inclusive range of elements.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis ReJSON 1.0.0
      See Also:
      • JSON.ARRTRIM
      • RedisAPI.jsonArrtrim(String, String, String, String)
    • jsonArrtrimAndForget

      public RedisAPI jsonArrtrimAndForget(String arg0, String arg1, String arg2, String arg3)
      Trim an array so that it contains only the specified inclusive range of elements.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis ReJSON 1.0.0
      See Also:
      • JSON.ARRTRIM
      • RedisAPI.jsonArrtrim(String, String, String, String)
    • jsonArrtrim

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> jsonArrtrim(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • RedisAPI.jsonArrtrim(List)
    • jsonArrtrimAndAwait

      public io.vertx.redis.client.Response jsonArrtrimAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
      • RedisAPI.jsonArrtrim(List)
    • jsonArrtrimAndForget

      public RedisAPI jsonArrtrimAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • RedisAPI.jsonArrtrim(List)
    • jsonClear

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> jsonClear(List<String> args)
      Clear container values (arrays/objects) and set numeric values to 0.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis ReJSON 2.0.0
      See Also:
    • jsonClearAndAwait

      public io.vertx.redis.client.Response jsonClearAndAwait(List<String> args)
      Clear container values (arrays/objects) and set numeric values to 0.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis ReJSON 2.0.0
      See Also:
    • jsonClearAndForget

      public RedisAPI jsonClearAndForget(List<String> args)
      Clear container values (arrays/objects) and set numeric values to 0.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis ReJSON 2.0.0
      See Also:
    • jsonDebug

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> jsonDebug(List<String> args)
      This is a container command for debugging related tasks.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonDebugAndAwait

      public io.vertx.redis.client.Response jsonDebugAndAwait(List<String> args)
      This is a container command for debugging related tasks.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonDebugAndForget

      public RedisAPI jsonDebugAndForget(List<String> args)
      This is a container command for debugging related tasks.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonDel

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> jsonDel(List<String> args)
      Delete a value.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonDelAndAwait

      public io.vertx.redis.client.Response jsonDelAndAwait(List<String> args)
      Delete a value.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonDelAndForget

      public RedisAPI jsonDelAndForget(List<String> args)
      Delete a value.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonForget

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> jsonForget(List<String> args)
      Delete a value.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonForgetAndAwait

      public io.vertx.redis.client.Response jsonForgetAndAwait(List<String> args)
      Delete a value.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonForgetAndForget

      public RedisAPI jsonForgetAndForget(List<String> args)
      Delete a value.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonGet

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> jsonGet(List<String> args)
      Get JSON value at path.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonGetAndAwait

      public io.vertx.redis.client.Response jsonGetAndAwait(List<String> args)
      Get JSON value at path.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonGetAndForget

      public RedisAPI jsonGetAndForget(List<String> args)
      Get JSON value at path.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonMerge

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> jsonMerge(List<String> args)
      Merge a given JSON value into matching paths. Consequently, JSON values at matching paths are updated, deleted, or expanded with new children.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis ReJSON 2.6.0
      See Also:
    • jsonMergeAndAwait

      public io.vertx.redis.client.Response jsonMergeAndAwait(List<String> args)
      Merge a given JSON value into matching paths. Consequently, JSON values at matching paths are updated, deleted, or expanded with new children.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis ReJSON 2.6.0
      See Also:
    • jsonMergeAndForget

      public RedisAPI jsonMergeAndForget(List<String> args)
      Merge a given JSON value into matching paths. Consequently, JSON values at matching paths are updated, deleted, or expanded with new children.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis ReJSON 2.6.0
      See Also:
    • jsonMget

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> jsonMget(List<String> args)
      Return the values at path from multiple key arguments.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonMgetAndAwait

      public io.vertx.redis.client.Response jsonMgetAndAwait(List<String> args)
      Return the values at path from multiple key arguments.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonMgetAndForget

      public RedisAPI jsonMgetAndForget(List<String> args)
      Return the values at path from multiple key arguments.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonMset

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> jsonMset(List<String> args)
      Set or update one or more JSON values according to the specified key-path-value triplets.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis ReJSON 2.6.0
      See Also:
    • jsonMsetAndAwait

      public io.vertx.redis.client.Response jsonMsetAndAwait(List<String> args)
      Set or update one or more JSON values according to the specified key-path-value triplets.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis ReJSON 2.6.0
      See Also:
    • jsonMsetAndForget

      public RedisAPI jsonMsetAndForget(List<String> args)
      Set or update one or more JSON values according to the specified key-path-value triplets.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis ReJSON 2.6.0
      See Also:
    • jsonNumincrby

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> jsonNumincrby(String arg0, String arg1, String arg2)
      Increment the number value stored at path by number.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonNumincrbyAndAwait

      public io.vertx.redis.client.Response jsonNumincrbyAndAwait(String arg0, String arg1, String arg2)
      Increment the number value stored at path by number.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonNumincrbyAndForget

      public RedisAPI jsonNumincrbyAndForget(String arg0, String arg1, String arg2)
      Increment the number value stored at path by number.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonNumincrby

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> jsonNumincrby(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • RedisAPI.jsonNumincrby(List)
    • jsonNumincrbyAndAwait

      public io.vertx.redis.client.Response jsonNumincrbyAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
      • RedisAPI.jsonNumincrby(List)
    • jsonNumincrbyAndForget

      public RedisAPI jsonNumincrbyAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • RedisAPI.jsonNumincrby(List)
    • jsonNummultby

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> jsonNummultby(String arg0, String arg1, String arg2)
      Multiply the number value stored at path by number.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonNummultbyAndAwait

      public io.vertx.redis.client.Response jsonNummultbyAndAwait(String arg0, String arg1, String arg2)
      Multiply the number value stored at path by number.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonNummultbyAndForget

      public RedisAPI jsonNummultbyAndForget(String arg0, String arg1, String arg2)
      Multiply the number value stored at path by number.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonNummultby

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> jsonNummultby(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • RedisAPI.jsonNummultby(List)
    • jsonNummultbyAndAwait

      public io.vertx.redis.client.Response jsonNummultbyAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
      • RedisAPI.jsonNummultby(List)
    • jsonNummultbyAndForget

      public RedisAPI jsonNummultbyAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • RedisAPI.jsonNummultby(List)
    • jsonNumpowby

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> jsonNumpowby(String arg0, String arg1, String arg2)
      Raise the number value stored at path to the power of number.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonNumpowbyAndAwait

      public io.vertx.redis.client.Response jsonNumpowbyAndAwait(String arg0, String arg1, String arg2)
      Raise the number value stored at path to the power of number.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonNumpowbyAndForget

      public RedisAPI jsonNumpowbyAndForget(String arg0, String arg1, String arg2)
      Raise the number value stored at path to the power of number.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonNumpowby

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> jsonNumpowby(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • RedisAPI.jsonNumpowby(List)
    • jsonNumpowbyAndAwait

      public io.vertx.redis.client.Response jsonNumpowbyAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
      • RedisAPI.jsonNumpowby(List)
    • jsonNumpowbyAndForget

      public RedisAPI jsonNumpowbyAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • RedisAPI.jsonNumpowby(List)
    • jsonObjkeys

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> jsonObjkeys(List<String> args)
      Return the keys in the object that's referenced by path.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonObjkeysAndAwait

      public io.vertx.redis.client.Response jsonObjkeysAndAwait(List<String> args)
      Return the keys in the object that's referenced by path.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonObjkeysAndForget

      public RedisAPI jsonObjkeysAndForget(List<String> args)
      Return the keys in the object that's referenced by path.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonObjlen

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> jsonObjlen(List<String> args)
      Report the number of keys in the JSON object at path in key.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonObjlenAndAwait

      public io.vertx.redis.client.Response jsonObjlenAndAwait(List<String> args)
      Report the number of keys in the JSON object at path in key.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonObjlenAndForget

      public RedisAPI jsonObjlenAndForget(List<String> args)
      Report the number of keys in the JSON object at path in key.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonResp

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> jsonResp(List<String> args)
      Return the JSON in key in Redis serialization protocol specification form.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonRespAndAwait

      public io.vertx.redis.client.Response jsonRespAndAwait(List<String> args)
      Return the JSON in key in Redis serialization protocol specification form.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonRespAndForget

      public RedisAPI jsonRespAndForget(List<String> args)
      Return the JSON in key in Redis serialization protocol specification form.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonSet

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> jsonSet(List<String> args)
      Set the JSON value at path in key.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonSetAndAwait

      public io.vertx.redis.client.Response jsonSetAndAwait(List<String> args)
      Set the JSON value at path in key.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonSetAndForget

      public RedisAPI jsonSetAndForget(List<String> args)
      Set the JSON value at path in key.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonStrappend

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> jsonStrappend(List<String> args)
      Append the json-string values to the string at path.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonStrappendAndAwait

      public io.vertx.redis.client.Response jsonStrappendAndAwait(List<String> args)
      Append the json-string values to the string at path.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonStrappendAndForget

      public RedisAPI jsonStrappendAndForget(List<String> args)
      Append the json-string values to the string at path.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonStrlen

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> jsonStrlen(List<String> args)
      Report the length of the JSON String at path in key.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonStrlenAndAwait

      public io.vertx.redis.client.Response jsonStrlenAndAwait(List<String> args)
      Report the length of the JSON String at path in key.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonStrlenAndForget

      public RedisAPI jsonStrlenAndForget(List<String> args)
      Report the length of the JSON String at path in key.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonToggle

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> jsonToggle(String arg0, String arg1)
      Toggle the boolean value stored at path.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis ReJSON 2.0.0
      See Also:
    • jsonToggleAndAwait

      public io.vertx.redis.client.Response jsonToggleAndAwait(String arg0, String arg1)
      Toggle the boolean value stored at path.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis ReJSON 2.0.0
      See Also:
    • jsonToggleAndForget

      public RedisAPI jsonToggleAndForget(String arg0, String arg1)
      Toggle the boolean value stored at path.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis ReJSON 2.0.0
      See Also:
    • jsonToggle

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> jsonToggle(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • RedisAPI.jsonToggle(List)
    • jsonToggleAndAwait

      public io.vertx.redis.client.Response jsonToggleAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
      • RedisAPI.jsonToggle(List)
    • jsonToggleAndForget

      public RedisAPI jsonToggleAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • RedisAPI.jsonToggle(List)
    • jsonType

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> jsonType(List<String> args)
      Report the type of JSON value at path.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonTypeAndAwait

      public io.vertx.redis.client.Response jsonTypeAndAwait(List<String> args)
      Report the type of JSON value at path.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • jsonTypeAndForget

      public RedisAPI jsonTypeAndForget(List<String> args)
      Report the type of JSON value at path.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis ReJSON 1.0.0
      See Also:
    • keys

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> keys(String arg0)
      Returns all key names that match a pattern.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • KEYS
      • RedisAPI.keys(String)
    • keysAndAwait

      public io.vertx.redis.client.Response keysAndAwait(String arg0)
      Returns all key names that match a pattern.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • KEYS
      • RedisAPI.keys(String)
    • keysAndForget

      public RedisAPI keysAndForget(String arg0)
      Returns all key names that match a pattern.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • KEYS
      • RedisAPI.keys(String)
    • lastsave

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> lastsave()
      Returns the Unix timestamp of the last successful save to disk.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
    • lastsaveAndAwait

      public io.vertx.redis.client.Response lastsaveAndAwait()
      Returns the Unix timestamp of the last successful save to disk.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
    • lastsaveAndForget

      public RedisAPI lastsaveAndForget()
      Returns the Unix timestamp of the last successful save to disk.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
    • latency

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> latency(List<String> args)
      A container for latency diagnostics commands.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.8.13
      See Also:
    • latencyAndAwait

      public io.vertx.redis.client.Response latencyAndAwait(List<String> args)
      A container for latency diagnostics commands.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.8.13
      See Also:
    • latencyAndForget

      public RedisAPI latencyAndForget(List<String> args)
      A container for latency diagnostics commands.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.8.13
      See Also:
    • lcs

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> lcs(List<String> args)
      Finds the longest common substring.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 7.0.0
      See Also:
      • LCS
      • RedisAPI.lcs(List)
    • lcsAndAwait

      public io.vertx.redis.client.Response lcsAndAwait(List<String> args)
      Finds the longest common substring.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 7.0.0
      See Also:
      • LCS
      • RedisAPI.lcs(List)
    • lcsAndForget

      public RedisAPI lcsAndForget(List<String> args)
      Finds the longest common substring.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 7.0.0
      See Also:
      • LCS
      • RedisAPI.lcs(List)
    • lindex

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> lindex(String arg0, String arg1)
      Returns an element from a list by its index.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • LINDEX
      • RedisAPI.lindex(String, String)
    • lindexAndAwait

      public io.vertx.redis.client.Response lindexAndAwait(String arg0, String arg1)
      Returns an element from a list by its index.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • LINDEX
      • RedisAPI.lindex(String, String)
    • lindexAndForget

      public RedisAPI lindexAndForget(String arg0, String arg1)
      Returns an element from a list by its index.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • LINDEX
      • RedisAPI.lindex(String, String)
    • linsert

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> linsert(String arg0, String arg1, String arg2, String arg3)
      Inserts an element before or after another element in a list.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.2.0
      See Also:
      • LINSERT
      • RedisAPI.linsert(String, String, String, String)
    • linsertAndAwait

      public io.vertx.redis.client.Response linsertAndAwait(String arg0, String arg1, String arg2, String arg3)
      Inserts an element before or after another element in a list.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.2.0
      See Also:
      • LINSERT
      • RedisAPI.linsert(String, String, String, String)
    • linsertAndForget

      public RedisAPI linsertAndForget(String arg0, String arg1, String arg2, String arg3)
      Inserts an element before or after another element in a list.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.2.0
      See Also:
      • LINSERT
      • RedisAPI.linsert(String, String, String, String)
    • llen

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> llen(String arg0)
      Returns the length of a list.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • LLEN
      • RedisAPI.llen(String)
    • llenAndAwait

      public io.vertx.redis.client.Response llenAndAwait(String arg0)
      Returns the length of a list.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • LLEN
      • RedisAPI.llen(String)
    • llenAndForget

      public RedisAPI llenAndForget(String arg0)
      Returns the length of a list.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • LLEN
      • RedisAPI.llen(String)
    • lmove

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> lmove(String arg0, String arg1, String arg2, String arg3)
      Returns an element after popping it from one list and pushing it to another. Deletes the list if the last element was moved.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 6.2.0
      See Also:
      • LMOVE
      • RedisAPI.lmove(String, String, String, String)
    • lmoveAndAwait

      public io.vertx.redis.client.Response lmoveAndAwait(String arg0, String arg1, String arg2, String arg3)
      Returns an element after popping it from one list and pushing it to another. Deletes the list if the last element was moved.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 6.2.0
      See Also:
      • LMOVE
      • RedisAPI.lmove(String, String, String, String)
    • lmoveAndForget

      public RedisAPI lmoveAndForget(String arg0, String arg1, String arg2, String arg3)
      Returns an element after popping it from one list and pushing it to another. Deletes the list if the last element was moved.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 6.2.0
      See Also:
      • LMOVE
      • RedisAPI.lmove(String, String, String, String)
    • lmpop

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> lmpop(List<String> args)
      Returns multiple elements from a list after removing them. Deletes the list if the last element was popped.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 7.0.0
      See Also:
      • LMPOP
      • RedisAPI.lmpop(List)
    • lmpopAndAwait

      public io.vertx.redis.client.Response lmpopAndAwait(List<String> args)
      Returns multiple elements from a list after removing them. Deletes the list if the last element was popped.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 7.0.0
      See Also:
      • LMPOP
      • RedisAPI.lmpop(List)
    • lmpopAndForget

      public RedisAPI lmpopAndForget(List<String> args)
      Returns multiple elements from a list after removing them. Deletes the list if the last element was popped.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 7.0.0
      See Also:
      • LMPOP
      • RedisAPI.lmpop(List)
    • lolwut

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> lolwut(List<String> args)
      Displays computer art and the Redis version.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 5.0.0
      See Also:
      • LOLWUT
      • RedisAPI.lolwut(List)
    • lolwutAndAwait

      public io.vertx.redis.client.Response lolwutAndAwait(List<String> args)
      Displays computer art and the Redis version.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 5.0.0
      See Also:
      • LOLWUT
      • RedisAPI.lolwut(List)
    • lolwutAndForget

      public RedisAPI lolwutAndForget(List<String> args)
      Displays computer art and the Redis version.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 5.0.0
      See Also:
      • LOLWUT
      • RedisAPI.lolwut(List)
    • lpop

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> lpop(List<String> args)
      Returns the first elements in a list after removing it. Deletes the list if the last element was popped.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • LPOP
      • RedisAPI.lpop(List)
    • lpopAndAwait

      public io.vertx.redis.client.Response lpopAndAwait(List<String> args)
      Returns the first elements in a list after removing it. Deletes the list if the last element was popped.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • LPOP
      • RedisAPI.lpop(List)
    • lpopAndForget

      public RedisAPI lpopAndForget(List<String> args)
      Returns the first elements in a list after removing it. Deletes the list if the last element was popped.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • LPOP
      • RedisAPI.lpop(List)
    • lpos

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> lpos(List<String> args)
      Returns the index of matching elements in a list.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 6.0.6
      See Also:
      • LPOS
      • RedisAPI.lpos(List)
    • lposAndAwait

      public io.vertx.redis.client.Response lposAndAwait(List<String> args)
      Returns the index of matching elements in a list.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 6.0.6
      See Also:
      • LPOS
      • RedisAPI.lpos(List)
    • lposAndForget

      public RedisAPI lposAndForget(List<String> args)
      Returns the index of matching elements in a list.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 6.0.6
      See Also:
      • LPOS
      • RedisAPI.lpos(List)
    • lpush

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> lpush(List<String> args)
      Prepends one or more elements to a list. Creates the key if it doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • LPUSH
      • RedisAPI.lpush(List)
    • lpushAndAwait

      public io.vertx.redis.client.Response lpushAndAwait(List<String> args)
      Prepends one or more elements to a list. Creates the key if it doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • LPUSH
      • RedisAPI.lpush(List)
    • lpushAndForget

      public RedisAPI lpushAndForget(List<String> args)
      Prepends one or more elements to a list. Creates the key if it doesn't exist.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • LPUSH
      • RedisAPI.lpush(List)
    • lpushx

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> lpushx(List<String> args)
      Prepends one or more elements to a list only when the list exists.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.2.0
      See Also:
      • LPUSHX
      • RedisAPI.lpushx(List)
    • lpushxAndAwait

      public io.vertx.redis.client.Response lpushxAndAwait(List<String> args)
      Prepends one or more elements to a list only when the list exists.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.2.0
      See Also:
      • LPUSHX
      • RedisAPI.lpushx(List)
    • lpushxAndForget

      public RedisAPI lpushxAndForget(List<String> args)
      Prepends one or more elements to a list only when the list exists.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.2.0
      See Also:
      • LPUSHX
      • RedisAPI.lpushx(List)
    • lrange

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> lrange(String arg0, String arg1, String arg2)
      Returns a range of elements from a list.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • LRANGE
      • RedisAPI.lrange(String, String, String)
    • lrangeAndAwait

      public io.vertx.redis.client.Response lrangeAndAwait(String arg0, String arg1, String arg2)
      Returns a range of elements from a list.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • LRANGE
      • RedisAPI.lrange(String, String, String)
    • lrangeAndForget

      public RedisAPI lrangeAndForget(String arg0, String arg1, String arg2)
      Returns a range of elements from a list.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • LRANGE
      • RedisAPI.lrange(String, String, String)
    • lrem

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> lrem(String arg0, String arg1, String arg2)
      Removes elements from a list. Deletes the list if the last element was removed.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • LREM
      • RedisAPI.lrem(String, String, String)
    • lremAndAwait

      public io.vertx.redis.client.Response lremAndAwait(String arg0, String arg1, String arg2)
      Removes elements from a list. Deletes the list if the last element was removed.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • LREM
      • RedisAPI.lrem(String, String, String)
    • lremAndForget

      public RedisAPI lremAndForget(String arg0, String arg1, String arg2)
      Removes elements from a list. Deletes the list if the last element was removed.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • LREM
      • RedisAPI.lrem(String, String, String)
    • lset

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> lset(String arg0, String arg1, String arg2)
      Sets the value of an element in a list by its index.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • LSET
      • RedisAPI.lset(String, String, String)
    • lsetAndAwait

      public io.vertx.redis.client.Response lsetAndAwait(String arg0, String arg1, String arg2)
      Sets the value of an element in a list by its index.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • LSET
      • RedisAPI.lset(String, String, String)
    • lsetAndForget

      public RedisAPI lsetAndForget(String arg0, String arg1, String arg2)
      Sets the value of an element in a list by its index.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • LSET
      • RedisAPI.lset(String, String, String)
    • ltrim

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ltrim(String arg0, String arg1, String arg2)
      Removes elements from both ends a list. Deletes the list if all elements were trimmed.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • LTRIM
      • RedisAPI.ltrim(String, String, String)
    • ltrimAndAwait

      public io.vertx.redis.client.Response ltrimAndAwait(String arg0, String arg1, String arg2)
      Removes elements from both ends a list. Deletes the list if all elements were trimmed.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • LTRIM
      • RedisAPI.ltrim(String, String, String)
    • ltrimAndForget

      public RedisAPI ltrimAndForget(String arg0, String arg1, String arg2)
      Removes elements from both ends a list. Deletes the list if all elements were trimmed.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • LTRIM
      • RedisAPI.ltrim(String, String, String)
    • memory

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> memory(List<String> args)
      A container for memory diagnostics commands.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 4.0.0
      See Also:
      • MEMORY
      • RedisAPI.memory(List)
    • memoryAndAwait

      public io.vertx.redis.client.Response memoryAndAwait(List<String> args)
      A container for memory diagnostics commands.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 4.0.0
      See Also:
      • MEMORY
      • RedisAPI.memory(List)
    • memoryAndForget

      public RedisAPI memoryAndForget(List<String> args)
      A container for memory diagnostics commands.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 4.0.0
      See Also:
      • MEMORY
      • RedisAPI.memory(List)
    • mget

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> mget(List<String> args)
      Atomically returns the string values of one or more keys.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • MGET
      • RedisAPI.mget(List)
    • mgetAndAwait

      public io.vertx.redis.client.Response mgetAndAwait(List<String> args)
      Atomically returns the string values of one or more keys.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • MGET
      • RedisAPI.mget(List)
    • mgetAndForget

      public RedisAPI mgetAndForget(List<String> args)
      Atomically returns the string values of one or more keys.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • MGET
      • RedisAPI.mget(List)
    • migrate

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> migrate(List<String> args)
      Atomically transfers a key from one Redis instance to another.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.6.0
      See Also:
    • migrateAndAwait

      public io.vertx.redis.client.Response migrateAndAwait(List<String> args)
      Atomically transfers a key from one Redis instance to another.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.6.0
      See Also:
    • migrateAndForget

      public RedisAPI migrateAndForget(List<String> args)
      Atomically transfers a key from one Redis instance to another.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.6.0
      See Also:
    • module

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> module(List<String> args)
      A container for module commands.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 4.0.0
      See Also:
      • MODULE
      • RedisAPI.module(List)
    • moduleAndAwait

      public io.vertx.redis.client.Response moduleAndAwait(List<String> args)
      A container for module commands.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 4.0.0
      See Also:
      • MODULE
      • RedisAPI.module(List)
    • moduleAndForget

      public RedisAPI moduleAndForget(List<String> args)
      A container for module commands.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 4.0.0
      See Also:
      • MODULE
      • RedisAPI.module(List)
    • monitor

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> monitor()
      Listens for all requests received by the server in real-time.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
    • monitorAndAwait

      public io.vertx.redis.client.Response monitorAndAwait()
      Listens for all requests received by the server in real-time.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
    • monitorAndForget

      public RedisAPI monitorAndForget()
      Listens for all requests received by the server in real-time.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
    • move

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> move(String arg0, String arg1)
      Moves a key to another database.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • MOVE
      • RedisAPI.move(String, String)
    • moveAndAwait

      public io.vertx.redis.client.Response moveAndAwait(String arg0, String arg1)
      Moves a key to another database.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • MOVE
      • RedisAPI.move(String, String)
    • moveAndForget

      public RedisAPI moveAndForget(String arg0, String arg1)
      Moves a key to another database.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • MOVE
      • RedisAPI.move(String, String)
    • mset

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> mset(List<String> args)
      Atomically creates or modifies the string values of one or more keys.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.1
      See Also:
      • MSET
      • RedisAPI.mset(List)
    • msetAndAwait

      public io.vertx.redis.client.Response msetAndAwait(List<String> args)
      Atomically creates or modifies the string values of one or more keys.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.1
      See Also:
      • MSET
      • RedisAPI.mset(List)
    • msetAndForget

      public RedisAPI msetAndForget(List<String> args)
      Atomically creates or modifies the string values of one or more keys.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.1
      See Also:
      • MSET
      • RedisAPI.mset(List)
    • msetex

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> msetex(List<String> args)
      Atomically sets multiple string keys with a shared expiration in a single operation. Supports flexible argument parsing where condition and expiration flags can appear in any order.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 8.4.0
      See Also:
      • MSETEX
      • RedisAPI.msetex(List)
    • msetexAndAwait

      public io.vertx.redis.client.Response msetexAndAwait(List<String> args)
      Atomically sets multiple string keys with a shared expiration in a single operation. Supports flexible argument parsing where condition and expiration flags can appear in any order.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 8.4.0
      See Also:
      • MSETEX
      • RedisAPI.msetex(List)
    • msetexAndForget

      public RedisAPI msetexAndForget(List<String> args)
      Atomically sets multiple string keys with a shared expiration in a single operation. Supports flexible argument parsing where condition and expiration flags can appear in any order.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 8.4.0
      See Also:
      • MSETEX
      • RedisAPI.msetex(List)
    • msetnx

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> msetnx(List<String> args)
      Atomically modifies the string values of one or more keys only when all keys don't exist.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.1
      See Also:
      • MSETNX
      • RedisAPI.msetnx(List)
    • msetnxAndAwait

      public io.vertx.redis.client.Response msetnxAndAwait(List<String> args)
      Atomically modifies the string values of one or more keys only when all keys don't exist.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.1
      See Also:
      • MSETNX
      • RedisAPI.msetnx(List)
    • msetnxAndForget

      public RedisAPI msetnxAndForget(List<String> args)
      Atomically modifies the string values of one or more keys only when all keys don't exist.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.1
      See Also:
      • MSETNX
      • RedisAPI.msetnx(List)
    • multi

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> multi()
      Starts a transaction.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.2.0
      See Also:
    • multiAndAwait

      public io.vertx.redis.client.Response multiAndAwait()
      Starts a transaction.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.2.0
      See Also:
    • multiAndForget

      public RedisAPI multiAndForget()
      Starts a transaction.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.2.0
      See Also:
    • object

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> object(List<String> args)
      A container for object introspection commands.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.2.3
      See Also:
      • OBJECT
      • RedisAPI.object(List)
    • objectAndAwait

      public io.vertx.redis.client.Response objectAndAwait(List<String> args)
      A container for object introspection commands.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.2.3
      See Also:
      • OBJECT
      • RedisAPI.object(List)
    • objectAndForget

      public RedisAPI objectAndForget(List<String> args)
      A container for object introspection commands.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.2.3
      See Also:
      • OBJECT
      • RedisAPI.object(List)
    • persist

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> persist(String arg0)
      Removes the expiration time of a key.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.2.0
      See Also:
    • persistAndAwait

      public io.vertx.redis.client.Response persistAndAwait(String arg0)
      Removes the expiration time of a key.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.2.0
      See Also:
    • persistAndForget

      public RedisAPI persistAndForget(String arg0)
      Removes the expiration time of a key.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.2.0
      See Also:
    • pexpire

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> pexpire(List<String> args)
      Sets the expiration time of a key in milliseconds.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.6.0
      See Also:
    • pexpireAndAwait

      public io.vertx.redis.client.Response pexpireAndAwait(List<String> args)
      Sets the expiration time of a key in milliseconds.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.6.0
      See Also:
    • pexpireAndForget

      public RedisAPI pexpireAndForget(List<String> args)
      Sets the expiration time of a key in milliseconds.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.6.0
      See Also:
    • pexpireat

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> pexpireat(List<String> args)
      Sets the expiration time of a key to a Unix milliseconds timestamp.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.6.0
      See Also:
    • pexpireatAndAwait

      public io.vertx.redis.client.Response pexpireatAndAwait(List<String> args)
      Sets the expiration time of a key to a Unix milliseconds timestamp.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.6.0
      See Also:
    • pexpireatAndForget

      public RedisAPI pexpireatAndForget(List<String> args)
      Sets the expiration time of a key to a Unix milliseconds timestamp.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.6.0
      See Also:
    • pexpiretime

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> pexpiretime(String arg0)
      Returns the expiration time of a key as a Unix milliseconds timestamp.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 7.0.0
      See Also:
    • pexpiretimeAndAwait

      public io.vertx.redis.client.Response pexpiretimeAndAwait(String arg0)
      Returns the expiration time of a key as a Unix milliseconds timestamp.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 7.0.0
      See Also:
    • pexpiretimeAndForget

      public RedisAPI pexpiretimeAndForget(String arg0)
      Returns the expiration time of a key as a Unix milliseconds timestamp.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 7.0.0
      See Also:
    • pfadd

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> pfadd(List<String> args)
      Adds elements to a HyperLogLog key. Creates the key if it doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.8.9
      See Also:
      • PFADD
      • RedisAPI.pfadd(List)
    • pfaddAndAwait

      public io.vertx.redis.client.Response pfaddAndAwait(List<String> args)
      Adds elements to a HyperLogLog key. Creates the key if it doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.8.9
      See Also:
      • PFADD
      • RedisAPI.pfadd(List)
    • pfaddAndForget

      public RedisAPI pfaddAndForget(List<String> args)
      Adds elements to a HyperLogLog key. Creates the key if it doesn't exist.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.8.9
      See Also:
      • PFADD
      • RedisAPI.pfadd(List)
    • pfcount

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> pfcount(List<String> args)
      Returns the approximated cardinality of the set(s) observed by the HyperLogLog key(s).

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.8.9
      See Also:
    • pfcountAndAwait

      public io.vertx.redis.client.Response pfcountAndAwait(List<String> args)
      Returns the approximated cardinality of the set(s) observed by the HyperLogLog key(s).

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.8.9
      See Also:
    • pfcountAndForget

      public RedisAPI pfcountAndForget(List<String> args)
      Returns the approximated cardinality of the set(s) observed by the HyperLogLog key(s).

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.8.9
      See Also:
    • pfdebug

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> pfdebug(String arg0, String arg1)
      Internal commands for debugging HyperLogLog values.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.8.9
      See Also:
      • PFDEBUG
      • RedisAPI.pfdebug(String, String)
    • pfdebugAndAwait

      public io.vertx.redis.client.Response pfdebugAndAwait(String arg0, String arg1)
      Internal commands for debugging HyperLogLog values.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.8.9
      See Also:
      • PFDEBUG
      • RedisAPI.pfdebug(String, String)
    • pfdebugAndForget

      public RedisAPI pfdebugAndForget(String arg0, String arg1)
      Internal commands for debugging HyperLogLog values.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.8.9
      See Also:
      • PFDEBUG
      • RedisAPI.pfdebug(String, String)
    • pfmerge

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> pfmerge(List<String> args)
      Merges one or more HyperLogLog values into a single key.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.8.9
      See Also:
    • pfmergeAndAwait

      public io.vertx.redis.client.Response pfmergeAndAwait(List<String> args)
      Merges one or more HyperLogLog values into a single key.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.8.9
      See Also:
    • pfmergeAndForget

      public RedisAPI pfmergeAndForget(List<String> args)
      Merges one or more HyperLogLog values into a single key.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.8.9
      See Also:
    • pfselftest

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> pfselftest()
      An internal command for testing HyperLogLog values.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.8.9
      See Also:
    • pfselftestAndAwait

      public io.vertx.redis.client.Response pfselftestAndAwait()
      An internal command for testing HyperLogLog values.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.8.9
      See Also:
    • pfselftestAndForget

      public RedisAPI pfselftestAndForget()
      An internal command for testing HyperLogLog values.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.8.9
      See Also:
    • ping

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ping(List<String> args)
      Returns the server's liveliness response.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • PING
      • RedisAPI.ping(List)
    • pingAndAwait

      public io.vertx.redis.client.Response pingAndAwait(List<String> args)
      Returns the server's liveliness response.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • PING
      • RedisAPI.ping(List)
    • pingAndForget

      public RedisAPI pingAndForget(List<String> args)
      Returns the server's liveliness response.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • PING
      • RedisAPI.ping(List)
    • psetex

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> psetex(String arg0, String arg1, String arg2)
      Deprecated.
      since Redis 2.6.12, replaced by: SET with the PX argument
      Sets both string value and expiration time in milliseconds of a key. The key is created if it doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.6.0
      See Also:
      • PSETEX
      • RedisAPI.psetex(String, String, String)
    • psetexAndAwait

      public io.vertx.redis.client.Response psetexAndAwait(String arg0, String arg1, String arg2)
      Deprecated.
      since Redis 2.6.12, replaced by: SET with the PX argument
      Sets both string value and expiration time in milliseconds of a key. The key is created if it doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.6.0
      See Also:
      • PSETEX
      • RedisAPI.psetex(String, String, String)
    • psetexAndForget

      public RedisAPI psetexAndForget(String arg0, String arg1, String arg2)
      Deprecated.
      since Redis 2.6.12, replaced by: SET with the PX argument
      Sets both string value and expiration time in milliseconds of a key. The key is created if it doesn't exist.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.6.0
      See Also:
      • PSETEX
      • RedisAPI.psetex(String, String, String)
    • psubscribe

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> psubscribe(List<String> args)
      Listens for messages published to channels that match one or more patterns.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.0.0
      See Also:
    • psubscribeAndAwait

      public io.vertx.redis.client.Response psubscribeAndAwait(List<String> args)
      Listens for messages published to channels that match one or more patterns.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.0.0
      See Also:
    • psubscribeAndForget

      public RedisAPI psubscribeAndForget(List<String> args)
      Listens for messages published to channels that match one or more patterns.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.0.0
      See Also:
    • psync

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> psync(List<String> args)
      An internal command used in replication.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.8.0
      See Also:
      • PSYNC
      • RedisAPI.psync(List)
    • psyncAndAwait

      public io.vertx.redis.client.Response psyncAndAwait(List<String> args)
      An internal command used in replication.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.8.0
      See Also:
      • PSYNC
      • RedisAPI.psync(List)
    • psyncAndForget

      public RedisAPI psyncAndForget(List<String> args)
      An internal command used in replication.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.8.0
      See Also:
      • PSYNC
      • RedisAPI.psync(List)
    • pttl

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> pttl(String arg0)
      Returns the expiration time in milliseconds of a key.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.6.0
      See Also:
      • PTTL
      • RedisAPI.pttl(String)
    • pttlAndAwait

      public io.vertx.redis.client.Response pttlAndAwait(String arg0)
      Returns the expiration time in milliseconds of a key.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.6.0
      See Also:
      • PTTL
      • RedisAPI.pttl(String)
    • pttlAndForget

      public RedisAPI pttlAndForget(String arg0)
      Returns the expiration time in milliseconds of a key.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.6.0
      See Also:
      • PTTL
      • RedisAPI.pttl(String)
    • publish

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> publish(String arg0, String arg1)
      Posts a message to a channel.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.0.0
      See Also:
      • PUBLISH
      • RedisAPI.publish(String, String)
    • publishAndAwait

      public io.vertx.redis.client.Response publishAndAwait(String arg0, String arg1)
      Posts a message to a channel.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.0.0
      See Also:
      • PUBLISH
      • RedisAPI.publish(String, String)
    • publishAndForget

      public RedisAPI publishAndForget(String arg0, String arg1)
      Posts a message to a channel.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.0.0
      See Also:
      • PUBLISH
      • RedisAPI.publish(String, String)
    • pubsub

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> pubsub(List<String> args)
      A container for Pub/Sub commands.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.8.0
      See Also:
      • PUBSUB
      • RedisAPI.pubsub(List)
    • pubsubAndAwait

      public io.vertx.redis.client.Response pubsubAndAwait(List<String> args)
      A container for Pub/Sub commands.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.8.0
      See Also:
      • PUBSUB
      • RedisAPI.pubsub(List)
    • pubsubAndForget

      public RedisAPI pubsubAndForget(List<String> args)
      A container for Pub/Sub commands.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.8.0
      See Also:
      • PUBSUB
      • RedisAPI.pubsub(List)
    • punsubscribe

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> punsubscribe(List<String> args)
      Stops listening to messages published to channels that match one or more patterns.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.0.0
      See Also:
    • punsubscribeAndAwait

      public io.vertx.redis.client.Response punsubscribeAndAwait(List<String> args)
      Stops listening to messages published to channels that match one or more patterns.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.0.0
      See Also:
    • punsubscribeAndForget

      public RedisAPI punsubscribeAndForget(List<String> args)
      Stops listening to messages published to channels that match one or more patterns.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.0.0
      See Also:
    • quit

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> quit(List<String> args)
      Deprecated.
      since Redis 7.2.0, replaced by: just closing the connection
      Closes the connection.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • QUIT
      • RedisAPI.quit(List)
    • quitAndAwait

      public io.vertx.redis.client.Response quitAndAwait(List<String> args)
      Deprecated.
      since Redis 7.2.0, replaced by: just closing the connection
      Closes the connection.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • QUIT
      • RedisAPI.quit(List)
    • quitAndForget

      public RedisAPI quitAndForget(List<String> args)
      Deprecated.
      since Redis 7.2.0, replaced by: just closing the connection
      Closes the connection.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • QUIT
      • RedisAPI.quit(List)
    • randomkey

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> randomkey()
      Returns a random key name from the database.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
    • randomkeyAndAwait

      public io.vertx.redis.client.Response randomkeyAndAwait()
      Returns a random key name from the database.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
    • randomkeyAndForget

      public RedisAPI randomkeyAndForget()
      Returns a random key name from the database.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
    • readonly

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> readonly()
      Enables read-only queries for a connection to a Redis Cluster replica node.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 3.0.0
      See Also:
    • readonlyAndAwait

      public io.vertx.redis.client.Response readonlyAndAwait()
      Enables read-only queries for a connection to a Redis Cluster replica node.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 3.0.0
      See Also:
    • readonlyAndForget

      public RedisAPI readonlyAndForget()
      Enables read-only queries for a connection to a Redis Cluster replica node.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 3.0.0
      See Also:
    • readwrite

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> readwrite()
      Enables read-write queries for a connection to a Reids Cluster replica node.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 3.0.0
      See Also:
    • readwriteAndAwait

      public io.vertx.redis.client.Response readwriteAndAwait()
      Enables read-write queries for a connection to a Reids Cluster replica node.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 3.0.0
      See Also:
    • readwriteAndForget

      public RedisAPI readwriteAndForget()
      Enables read-write queries for a connection to a Reids Cluster replica node.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 3.0.0
      See Also:
    • rename

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> rename(String arg0, String arg1)
      Renames a key and overwrites the destination.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • RENAME
      • RedisAPI.rename(String, String)
    • renameAndAwait

      public io.vertx.redis.client.Response renameAndAwait(String arg0, String arg1)
      Renames a key and overwrites the destination.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • RENAME
      • RedisAPI.rename(String, String)
    • renameAndForget

      public RedisAPI renameAndForget(String arg0, String arg1)
      Renames a key and overwrites the destination.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • RENAME
      • RedisAPI.rename(String, String)
    • renamenx

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> renamenx(String arg0, String arg1)
      Renames a key only when the target key name doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • RENAMENX
      • RedisAPI.renamenx(String, String)
    • renamenxAndAwait

      public io.vertx.redis.client.Response renamenxAndAwait(String arg0, String arg1)
      Renames a key only when the target key name doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • RENAMENX
      • RedisAPI.renamenx(String, String)
    • renamenxAndForget

      public RedisAPI renamenxAndForget(String arg0, String arg1)
      Renames a key only when the target key name doesn't exist.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • RENAMENX
      • RedisAPI.renamenx(String, String)
    • replconf

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> replconf(List<String> args)
      An internal command for configuring the replication stream.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 3.0.0
      See Also:
    • replconfAndAwait

      public io.vertx.redis.client.Response replconfAndAwait(List<String> args)
      An internal command for configuring the replication stream.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 3.0.0
      See Also:
    • replconfAndForget

      public RedisAPI replconfAndForget(List<String> args)
      An internal command for configuring the replication stream.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 3.0.0
      See Also:
    • replicaof

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> replicaof(String arg0, String arg1)
      Configures a server as replica of another, or promotes it to a master.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 5.0.0
      See Also:
      • REPLICAOF
      • RedisAPI.replicaof(String, String)
    • replicaofAndAwait

      public io.vertx.redis.client.Response replicaofAndAwait(String arg0, String arg1)
      Configures a server as replica of another, or promotes it to a master.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 5.0.0
      See Also:
      • REPLICAOF
      • RedisAPI.replicaof(String, String)
    • replicaofAndForget

      public RedisAPI replicaofAndForget(String arg0, String arg1)
      Configures a server as replica of another, or promotes it to a master.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 5.0.0
      See Also:
      • REPLICAOF
      • RedisAPI.replicaof(String, String)
    • reset

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> reset()
      Resets the connection.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 6.2.0
      See Also:
    • resetAndAwait

      public io.vertx.redis.client.Response resetAndAwait()
      Resets the connection.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 6.2.0
      See Also:
    • resetAndForget

      public RedisAPI resetAndForget()
      Resets the connection.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 6.2.0
      See Also:
    • restore

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> restore(List<String> args)
      Creates a key from the serialized representation of a value.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.6.0
      See Also:
    • restoreAndAwait

      public io.vertx.redis.client.Response restoreAndAwait(List<String> args)
      Creates a key from the serialized representation of a value.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.6.0
      See Also:
    • restoreAndForget

      public RedisAPI restoreAndForget(List<String> args)
      Creates a key from the serialized representation of a value.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.6.0
      See Also:
    • restoreAsking

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> restoreAsking(List<String> args)
      An internal command for migrating keys in a cluster.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 3.0.0
      See Also:
    • restoreAskingAndAwait

      public io.vertx.redis.client.Response restoreAskingAndAwait(List<String> args)
      An internal command for migrating keys in a cluster.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 3.0.0
      See Also:
    • restoreAskingAndForget

      public RedisAPI restoreAskingAndForget(List<String> args)
      An internal command for migrating keys in a cluster.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 3.0.0
      See Also:
    • role

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> role()
      Returns the replication role.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.8.12
      See Also:
      • ROLE
      • RedisAPI.role()
    • roleAndAwait

      public io.vertx.redis.client.Response roleAndAwait()
      Returns the replication role.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.8.12
      See Also:
      • ROLE
      • RedisAPI.role()
    • roleAndForget

      public RedisAPI roleAndForget()
      Returns the replication role.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.8.12
      See Also:
      • ROLE
      • RedisAPI.role()
    • rpop

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> rpop(List<String> args)
      Returns and removes the last elements of a list. Deletes the list if the last element was popped.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • RPOP
      • RedisAPI.rpop(List)
    • rpopAndAwait

      public io.vertx.redis.client.Response rpopAndAwait(List<String> args)
      Returns and removes the last elements of a list. Deletes the list if the last element was popped.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • RPOP
      • RedisAPI.rpop(List)
    • rpopAndForget

      public RedisAPI rpopAndForget(List<String> args)
      Returns and removes the last elements of a list. Deletes the list if the last element was popped.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • RPOP
      • RedisAPI.rpop(List)
    • rpoplpush

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> rpoplpush(String arg0, String arg1)
      Deprecated.
      since Redis 6.2.0, replaced by: LMOVE with the RIGHT and LEFT arguments
      Returns the last element of a list after removing and pushing it to another list. Deletes the list if the last element was popped.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.2.0
      See Also:
      • RPOPLPUSH
      • RedisAPI.rpoplpush(String, String)
    • rpoplpushAndAwait

      public io.vertx.redis.client.Response rpoplpushAndAwait(String arg0, String arg1)
      Deprecated.
      since Redis 6.2.0, replaced by: LMOVE with the RIGHT and LEFT arguments
      Returns the last element of a list after removing and pushing it to another list. Deletes the list if the last element was popped.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.2.0
      See Also:
      • RPOPLPUSH
      • RedisAPI.rpoplpush(String, String)
    • rpoplpushAndForget

      public RedisAPI rpoplpushAndForget(String arg0, String arg1)
      Deprecated.
      since Redis 6.2.0, replaced by: LMOVE with the RIGHT and LEFT arguments
      Returns the last element of a list after removing and pushing it to another list. Deletes the list if the last element was popped.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.2.0
      See Also:
      • RPOPLPUSH
      • RedisAPI.rpoplpush(String, String)
    • rpush

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> rpush(List<String> args)
      Appends one or more elements to a list. Creates the key if it doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • RPUSH
      • RedisAPI.rpush(List)
    • rpushAndAwait

      public io.vertx.redis.client.Response rpushAndAwait(List<String> args)
      Appends one or more elements to a list. Creates the key if it doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • RPUSH
      • RedisAPI.rpush(List)
    • rpushAndForget

      public RedisAPI rpushAndForget(List<String> args)
      Appends one or more elements to a list. Creates the key if it doesn't exist.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • RPUSH
      • RedisAPI.rpush(List)
    • rpushx

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> rpushx(List<String> args)
      Appends an element to a list only when the list exists.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.2.0
      See Also:
      • RPUSHX
      • RedisAPI.rpushx(List)
    • rpushxAndAwait

      public io.vertx.redis.client.Response rpushxAndAwait(List<String> args)
      Appends an element to a list only when the list exists.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.2.0
      See Also:
      • RPUSHX
      • RedisAPI.rpushx(List)
    • rpushxAndForget

      public RedisAPI rpushxAndForget(List<String> args)
      Appends an element to a list only when the list exists.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.2.0
      See Also:
      • RPUSHX
      • RedisAPI.rpushx(List)
    • sadd

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> sadd(List<String> args)
      Adds one or more members to a set. Creates the key if it doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • SADD
      • RedisAPI.sadd(List)
    • saddAndAwait

      public io.vertx.redis.client.Response saddAndAwait(List<String> args)
      Adds one or more members to a set. Creates the key if it doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • SADD
      • RedisAPI.sadd(List)
    • saddAndForget

      public RedisAPI saddAndForget(List<String> args)
      Adds one or more members to a set. Creates the key if it doesn't exist.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • SADD
      • RedisAPI.sadd(List)
    • save

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> save()
      Synchronously saves the database(s) to disk.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • SAVE
      • RedisAPI.save()
    • saveAndAwait

      public io.vertx.redis.client.Response saveAndAwait()
      Synchronously saves the database(s) to disk.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • SAVE
      • RedisAPI.save()
    • saveAndForget

      public RedisAPI saveAndForget()
      Synchronously saves the database(s) to disk.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • SAVE
      • RedisAPI.save()
    • scan

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> scan(List<String> args)
      Iterates over the key names in the database.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.8.0
      See Also:
      • SCAN
      • RedisAPI.scan(List)
    • scanAndAwait

      public io.vertx.redis.client.Response scanAndAwait(List<String> args)
      Iterates over the key names in the database.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.8.0
      See Also:
      • SCAN
      • RedisAPI.scan(List)
    • scanAndForget

      public RedisAPI scanAndForget(List<String> args)
      Iterates over the key names in the database.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.8.0
      See Also:
      • SCAN
      • RedisAPI.scan(List)
    • scard

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> scard(String arg0)
      Returns the number of members in a set.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • SCARD
      • RedisAPI.scard(String)
    • scardAndAwait

      public io.vertx.redis.client.Response scardAndAwait(String arg0)
      Returns the number of members in a set.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • SCARD
      • RedisAPI.scard(String)
    • scardAndForget

      public RedisAPI scardAndForget(String arg0)
      Returns the number of members in a set.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • SCARD
      • RedisAPI.scard(String)
    • script

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> script(List<String> args)
      A container for Lua scripts management commands.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.6.0
      See Also:
      • SCRIPT
      • RedisAPI.script(List)
    • scriptAndAwait

      public io.vertx.redis.client.Response scriptAndAwait(List<String> args)
      A container for Lua scripts management commands.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.6.0
      See Also:
      • SCRIPT
      • RedisAPI.script(List)
    • scriptAndForget

      public RedisAPI scriptAndForget(List<String> args)
      A container for Lua scripts management commands.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.6.0
      See Also:
      • SCRIPT
      • RedisAPI.script(List)
    • sdiff

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> sdiff(List<String> args)
      Returns the difference of multiple sets.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • SDIFF
      • RedisAPI.sdiff(List)
    • sdiffAndAwait

      public io.vertx.redis.client.Response sdiffAndAwait(List<String> args)
      Returns the difference of multiple sets.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • SDIFF
      • RedisAPI.sdiff(List)
    • sdiffAndForget

      public RedisAPI sdiffAndForget(List<String> args)
      Returns the difference of multiple sets.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • SDIFF
      • RedisAPI.sdiff(List)
    • sdiffstore

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> sdiffstore(List<String> args)
      Stores the difference of multiple sets in a key.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
    • sdiffstoreAndAwait

      public io.vertx.redis.client.Response sdiffstoreAndAwait(List<String> args)
      Stores the difference of multiple sets in a key.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
    • sdiffstoreAndForget

      public RedisAPI sdiffstoreAndForget(List<String> args)
      Stores the difference of multiple sets in a key.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
    • searchClusterinfo

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> searchClusterinfo(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
    • searchClusterinfoAndAwait

      public io.vertx.redis.client.Response searchClusterinfoAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
    • searchClusterinfoAndForget

      public RedisAPI searchClusterinfoAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
    • searchClusterrefresh

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> searchClusterrefresh(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
    • searchClusterrefreshAndAwait

      public io.vertx.redis.client.Response searchClusterrefreshAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
    • searchClusterrefreshAndForget

      public RedisAPI searchClusterrefreshAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
    • searchClusterset

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> searchClusterset(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
    • searchClustersetAndAwait

      public io.vertx.redis.client.Response searchClustersetAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
    • searchClustersetAndForget

      public RedisAPI searchClustersetAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
    • select

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> select(String arg0)
      Changes the selected database.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • SELECT
      • RedisAPI.select(String)
    • selectAndAwait

      public io.vertx.redis.client.Response selectAndAwait(String arg0)
      Changes the selected database.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • SELECT
      • RedisAPI.select(String)
    • selectAndForget

      public RedisAPI selectAndForget(String arg0)
      Changes the selected database.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • SELECT
      • RedisAPI.select(String)
    • set

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> set(List<String> args)
      Sets the string value of a key, ignoring its type. The key is created if it doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • SET
      • RedisAPI.set(List)
    • setAndAwait

      public io.vertx.redis.client.Response setAndAwait(List<String> args)
      Sets the string value of a key, ignoring its type. The key is created if it doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • SET
      • RedisAPI.set(List)
    • setAndForget

      public RedisAPI setAndForget(List<String> args)
      Sets the string value of a key, ignoring its type. The key is created if it doesn't exist.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • SET
      • RedisAPI.set(List)
    • setbit

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> setbit(String arg0, String arg1, String arg2)
      Sets or clears the bit at offset of the string value. Creates the key if it doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.2.0
      See Also:
      • SETBIT
      • RedisAPI.setbit(String, String, String)
    • setbitAndAwait

      public io.vertx.redis.client.Response setbitAndAwait(String arg0, String arg1, String arg2)
      Sets or clears the bit at offset of the string value. Creates the key if it doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.2.0
      See Also:
      • SETBIT
      • RedisAPI.setbit(String, String, String)
    • setbitAndForget

      public RedisAPI setbitAndForget(String arg0, String arg1, String arg2)
      Sets or clears the bit at offset of the string value. Creates the key if it doesn't exist.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.2.0
      See Also:
      • SETBIT
      • RedisAPI.setbit(String, String, String)
    • setex

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> setex(String arg0, String arg1, String arg2)
      Deprecated.
      since Redis 2.6.12, replaced by: SET with the EX argument
      Sets the string value and expiration time of a key. Creates the key if it doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.0.0
      See Also:
      • SETEX
      • RedisAPI.setex(String, String, String)
    • setexAndAwait

      public io.vertx.redis.client.Response setexAndAwait(String arg0, String arg1, String arg2)
      Deprecated.
      since Redis 2.6.12, replaced by: SET with the EX argument
      Sets the string value and expiration time of a key. Creates the key if it doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.0.0
      See Also:
      • SETEX
      • RedisAPI.setex(String, String, String)
    • setexAndForget

      public RedisAPI setexAndForget(String arg0, String arg1, String arg2)
      Deprecated.
      since Redis 2.6.12, replaced by: SET with the EX argument
      Sets the string value and expiration time of a key. Creates the key if it doesn't exist.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.0.0
      See Also:
      • SETEX
      • RedisAPI.setex(String, String, String)
    • setnx

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> setnx(String arg0, String arg1)
      Deprecated.
      since Redis 2.6.12, replaced by: SET with the NX argument
      Set the string value of a key only when the key doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • SETNX
      • RedisAPI.setnx(String, String)
    • setnxAndAwait

      public io.vertx.redis.client.Response setnxAndAwait(String arg0, String arg1)
      Deprecated.
      since Redis 2.6.12, replaced by: SET with the NX argument
      Set the string value of a key only when the key doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • SETNX
      • RedisAPI.setnx(String, String)
    • setnxAndForget

      public RedisAPI setnxAndForget(String arg0, String arg1)
      Deprecated.
      since Redis 2.6.12, replaced by: SET with the NX argument
      Set the string value of a key only when the key doesn't exist.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • SETNX
      • RedisAPI.setnx(String, String)
    • setrange

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> setrange(String arg0, String arg1, String arg2)
      Overwrites a part of a string value with another by an offset. Creates the key if it doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.2.0
      See Also:
      • SETRANGE
      • RedisAPI.setrange(String, String, String)
    • setrangeAndAwait

      public io.vertx.redis.client.Response setrangeAndAwait(String arg0, String arg1, String arg2)
      Overwrites a part of a string value with another by an offset. Creates the key if it doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.2.0
      See Also:
      • SETRANGE
      • RedisAPI.setrange(String, String, String)
    • setrangeAndForget

      public RedisAPI setrangeAndForget(String arg0, String arg1, String arg2)
      Overwrites a part of a string value with another by an offset. Creates the key if it doesn't exist.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.2.0
      See Also:
      • SETRANGE
      • RedisAPI.setrange(String, String, String)
    • shutdown

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> shutdown(List<String> args)
      Synchronously saves the database(s) to disk and shuts down the Redis server.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
    • shutdownAndAwait

      public io.vertx.redis.client.Response shutdownAndAwait(List<String> args)
      Synchronously saves the database(s) to disk and shuts down the Redis server.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
    • shutdownAndForget

      public RedisAPI shutdownAndForget(List<String> args)
      Synchronously saves the database(s) to disk and shuts down the Redis server.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
    • sinter

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> sinter(List<String> args)
      Returns the intersect of multiple sets.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • SINTER
      • RedisAPI.sinter(List)
    • sinterAndAwait

      public io.vertx.redis.client.Response sinterAndAwait(List<String> args)
      Returns the intersect of multiple sets.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • SINTER
      • RedisAPI.sinter(List)
    • sinterAndForget

      public RedisAPI sinterAndForget(List<String> args)
      Returns the intersect of multiple sets.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • SINTER
      • RedisAPI.sinter(List)
    • sintercard

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> sintercard(List<String> args)
      Returns the number of members of the intersect of multiple sets.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 7.0.0
      See Also:
    • sintercardAndAwait

      public io.vertx.redis.client.Response sintercardAndAwait(List<String> args)
      Returns the number of members of the intersect of multiple sets.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 7.0.0
      See Also:
    • sintercardAndForget

      public RedisAPI sintercardAndForget(List<String> args)
      Returns the number of members of the intersect of multiple sets.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 7.0.0
      See Also:
    • sinterstore

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> sinterstore(List<String> args)
      Stores the intersect of multiple sets in a key.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
    • sinterstoreAndAwait

      public io.vertx.redis.client.Response sinterstoreAndAwait(List<String> args)
      Stores the intersect of multiple sets in a key.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
    • sinterstoreAndForget

      public RedisAPI sinterstoreAndForget(List<String> args)
      Stores the intersect of multiple sets in a key.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
    • sismember

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> sismember(String arg0, String arg1)
      Determines whether a member belongs to a set.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • SISMEMBER
      • RedisAPI.sismember(String, String)
    • sismemberAndAwait

      public io.vertx.redis.client.Response sismemberAndAwait(String arg0, String arg1)
      Determines whether a member belongs to a set.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • SISMEMBER
      • RedisAPI.sismember(String, String)
    • sismemberAndForget

      public RedisAPI sismemberAndForget(String arg0, String arg1)
      Determines whether a member belongs to a set.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • SISMEMBER
      • RedisAPI.sismember(String, String)
    • slaveof

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> slaveof(String arg0, String arg1)
      Deprecated.
      since Redis 5.0.0, replaced by: REPLICAOF
      Sets a Redis server as a replica of another, or promotes it to being a master.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • SLAVEOF
      • RedisAPI.slaveof(String, String)
    • slaveofAndAwait

      public io.vertx.redis.client.Response slaveofAndAwait(String arg0, String arg1)
      Deprecated.
      since Redis 5.0.0, replaced by: REPLICAOF
      Sets a Redis server as a replica of another, or promotes it to being a master.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • SLAVEOF
      • RedisAPI.slaveof(String, String)
    • slaveofAndForget

      public RedisAPI slaveofAndForget(String arg0, String arg1)
      Deprecated.
      since Redis 5.0.0, replaced by: REPLICAOF
      Sets a Redis server as a replica of another, or promotes it to being a master.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • SLAVEOF
      • RedisAPI.slaveof(String, String)
    • slowlog

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> slowlog(List<String> args)
      A container for slow log commands.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.2.12
      See Also:
    • slowlogAndAwait

      public io.vertx.redis.client.Response slowlogAndAwait(List<String> args)
      A container for slow log commands.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.2.12
      See Also:
    • slowlogAndForget

      public RedisAPI slowlogAndForget(List<String> args)
      A container for slow log commands.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.2.12
      See Also:
    • smembers

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> smembers(String arg0)
      Returns all members of a set.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
    • smembersAndAwait

      public io.vertx.redis.client.Response smembersAndAwait(String arg0)
      Returns all members of a set.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
    • smembersAndForget

      public RedisAPI smembersAndForget(String arg0)
      Returns all members of a set.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
    • smismember

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> smismember(List<String> args)
      Determines whether multiple members belong to a set.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 6.2.0
      See Also:
    • smismemberAndAwait

      public io.vertx.redis.client.Response smismemberAndAwait(List<String> args)
      Determines whether multiple members belong to a set.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 6.2.0
      See Also:
    • smismemberAndForget

      public RedisAPI smismemberAndForget(List<String> args)
      Determines whether multiple members belong to a set.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 6.2.0
      See Also:
    • smove

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> smove(String arg0, String arg1, String arg2)
      Moves a member from one set to another.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • SMOVE
      • RedisAPI.smove(String, String, String)
    • smoveAndAwait

      public io.vertx.redis.client.Response smoveAndAwait(String arg0, String arg1, String arg2)
      Moves a member from one set to another.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • SMOVE
      • RedisAPI.smove(String, String, String)
    • smoveAndForget

      public RedisAPI smoveAndForget(String arg0, String arg1, String arg2)
      Moves a member from one set to another.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • SMOVE
      • RedisAPI.smove(String, String, String)
    • sort

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> sort(List<String> args)
      Sorts the elements in a list, a set, or a sorted set, optionally storing the result.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • SORT
      • RedisAPI.sort(List)
    • sortAndAwait

      public io.vertx.redis.client.Response sortAndAwait(List<String> args)
      Sorts the elements in a list, a set, or a sorted set, optionally storing the result.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • SORT
      • RedisAPI.sort(List)
    • sortAndForget

      public RedisAPI sortAndForget(List<String> args)
      Sorts the elements in a list, a set, or a sorted set, optionally storing the result.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • SORT
      • RedisAPI.sort(List)
    • sortRo

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> sortRo(List<String> args)
      Returns the sorted elements of a list, a set, or a sorted set.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 7.0.0
      See Also:
    • sortRoAndAwait

      public io.vertx.redis.client.Response sortRoAndAwait(List<String> args)
      Returns the sorted elements of a list, a set, or a sorted set.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 7.0.0
      See Also:
    • sortRoAndForget

      public RedisAPI sortRoAndForget(List<String> args)
      Returns the sorted elements of a list, a set, or a sorted set.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 7.0.0
      See Also:
    • spop

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> spop(List<String> args)
      Returns one or more random members from a set after removing them. Deletes the set if the last member was popped.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • SPOP
      • RedisAPI.spop(List)
    • spopAndAwait

      public io.vertx.redis.client.Response spopAndAwait(List<String> args)
      Returns one or more random members from a set after removing them. Deletes the set if the last member was popped.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • SPOP
      • RedisAPI.spop(List)
    • spopAndForget

      public RedisAPI spopAndForget(List<String> args)
      Returns one or more random members from a set after removing them. Deletes the set if the last member was popped.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • SPOP
      • RedisAPI.spop(List)
    • spublish

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> spublish(String arg0, String arg1)
      Post a message to a shard channel.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 7.0.0
      See Also:
      • SPUBLISH
      • RedisAPI.spublish(String, String)
    • spublishAndAwait

      public io.vertx.redis.client.Response spublishAndAwait(String arg0, String arg1)
      Post a message to a shard channel.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 7.0.0
      See Also:
      • SPUBLISH
      • RedisAPI.spublish(String, String)
    • spublishAndForget

      public RedisAPI spublishAndForget(String arg0, String arg1)
      Post a message to a shard channel.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 7.0.0
      See Also:
      • SPUBLISH
      • RedisAPI.spublish(String, String)
    • srandmember

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> srandmember(List<String> args)
      Get one or multiple random members from a set.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
    • srandmemberAndAwait

      public io.vertx.redis.client.Response srandmemberAndAwait(List<String> args)
      Get one or multiple random members from a set.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
    • srandmemberAndForget

      public RedisAPI srandmemberAndForget(List<String> args)
      Get one or multiple random members from a set.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
    • srem

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> srem(List<String> args)
      Removes one or more members from a set. Deletes the set if the last member was removed.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • SREM
      • RedisAPI.srem(List)
    • sremAndAwait

      public io.vertx.redis.client.Response sremAndAwait(List<String> args)
      Removes one or more members from a set. Deletes the set if the last member was removed.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • SREM
      • RedisAPI.srem(List)
    • sremAndForget

      public RedisAPI sremAndForget(List<String> args)
      Removes one or more members from a set. Deletes the set if the last member was removed.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • SREM
      • RedisAPI.srem(List)
    • sscan

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> sscan(List<String> args)
      Iterates over members of a set.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.8.0
      See Also:
      • SSCAN
      • RedisAPI.sscan(List)
    • sscanAndAwait

      public io.vertx.redis.client.Response sscanAndAwait(List<String> args)
      Iterates over members of a set.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.8.0
      See Also:
      • SSCAN
      • RedisAPI.sscan(List)
    • sscanAndForget

      public RedisAPI sscanAndForget(List<String> args)
      Iterates over members of a set.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.8.0
      See Also:
      • SSCAN
      • RedisAPI.sscan(List)
    • ssubscribe

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ssubscribe(List<String> args)
      Listens for messages published to shard channels.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 7.0.0
      See Also:
    • ssubscribeAndAwait

      public io.vertx.redis.client.Response ssubscribeAndAwait(List<String> args)
      Listens for messages published to shard channels.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 7.0.0
      See Also:
    • ssubscribeAndForget

      public RedisAPI ssubscribeAndForget(List<String> args)
      Listens for messages published to shard channels.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 7.0.0
      See Also:
    • strlen

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> strlen(String arg0)
      Returns the length of a string value.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.2.0
      See Also:
      • STRLEN
      • RedisAPI.strlen(String)
    • strlenAndAwait

      public io.vertx.redis.client.Response strlenAndAwait(String arg0)
      Returns the length of a string value.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.2.0
      See Also:
      • STRLEN
      • RedisAPI.strlen(String)
    • strlenAndForget

      public RedisAPI strlenAndForget(String arg0)
      Returns the length of a string value.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.2.0
      See Also:
      • STRLEN
      • RedisAPI.strlen(String)
    • subscribe

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> subscribe(List<String> args)
      Listens for messages published to channels.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.0.0
      See Also:
    • subscribeAndAwait

      public io.vertx.redis.client.Response subscribeAndAwait(List<String> args)
      Listens for messages published to channels.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.0.0
      See Also:
    • subscribeAndForget

      public RedisAPI subscribeAndForget(List<String> args)
      Listens for messages published to channels.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.0.0
      See Also:
    • substr

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> substr(String arg0, String arg1, String arg2)
      Deprecated.
      since Redis 2.0.0, replaced by: GETRANGE
      Returns a substring from a string value.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • SUBSTR
      • RedisAPI.substr(String, String, String)
    • substrAndAwait

      public io.vertx.redis.client.Response substrAndAwait(String arg0, String arg1, String arg2)
      Deprecated.
      since Redis 2.0.0, replaced by: GETRANGE
      Returns a substring from a string value.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • SUBSTR
      • RedisAPI.substr(String, String, String)
    • substrAndForget

      public RedisAPI substrAndForget(String arg0, String arg1, String arg2)
      Deprecated.
      since Redis 2.0.0, replaced by: GETRANGE
      Returns a substring from a string value.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • SUBSTR
      • RedisAPI.substr(String, String, String)
    • sunion

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> sunion(List<String> args)
      Returns the union of multiple sets.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • SUNION
      • RedisAPI.sunion(List)
    • sunionAndAwait

      public io.vertx.redis.client.Response sunionAndAwait(List<String> args)
      Returns the union of multiple sets.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • SUNION
      • RedisAPI.sunion(List)
    • sunionAndForget

      public RedisAPI sunionAndForget(List<String> args)
      Returns the union of multiple sets.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • SUNION
      • RedisAPI.sunion(List)
    • sunionstore

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> sunionstore(List<String> args)
      Stores the union of multiple sets in a key.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
    • sunionstoreAndAwait

      public io.vertx.redis.client.Response sunionstoreAndAwait(List<String> args)
      Stores the union of multiple sets in a key.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
    • sunionstoreAndForget

      public RedisAPI sunionstoreAndForget(List<String> args)
      Stores the union of multiple sets in a key.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
    • sunsubscribe

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> sunsubscribe(List<String> args)
      Stops listening to messages posted to shard channels.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 7.0.0
      See Also:
    • sunsubscribeAndAwait

      public io.vertx.redis.client.Response sunsubscribeAndAwait(List<String> args)
      Stops listening to messages posted to shard channels.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 7.0.0
      See Also:
    • sunsubscribeAndForget

      public RedisAPI sunsubscribeAndForget(List<String> args)
      Stops listening to messages posted to shard channels.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 7.0.0
      See Also:
    • swapdb

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> swapdb(String arg0, String arg1)
      Swaps two Redis databases.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 4.0.0
      See Also:
      • SWAPDB
      • RedisAPI.swapdb(String, String)
    • swapdbAndAwait

      public io.vertx.redis.client.Response swapdbAndAwait(String arg0, String arg1)
      Swaps two Redis databases.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 4.0.0
      See Also:
      • SWAPDB
      • RedisAPI.swapdb(String, String)
    • swapdbAndForget

      public RedisAPI swapdbAndForget(String arg0, String arg1)
      Swaps two Redis databases.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 4.0.0
      See Also:
      • SWAPDB
      • RedisAPI.swapdb(String, String)
    • sync

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> sync()
      An internal command used in replication.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • SYNC
      • RedisAPI.sync()
    • syncAndAwait

      public io.vertx.redis.client.Response syncAndAwait()
      An internal command used in replication.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • SYNC
      • RedisAPI.sync()
    • syncAndForget

      public RedisAPI syncAndForget()
      An internal command used in replication.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • SYNC
      • RedisAPI.sync()
    • tdigestAdd

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tdigestAdd(List<String> args)
      Adds one or more observations to a t-digest sketch.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestAddAndAwait

      public io.vertx.redis.client.Response tdigestAddAndAwait(List<String> args)
      Adds one or more observations to a t-digest sketch.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestAddAndForget

      public RedisAPI tdigestAddAndForget(List<String> args)
      Adds one or more observations to a t-digest sketch.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestByrank

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tdigestByrank(List<String> args)
      Returns, for each input rank, an estimation of the value (floating-point) with that rank.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestByrankAndAwait

      public io.vertx.redis.client.Response tdigestByrankAndAwait(List<String> args)
      Returns, for each input rank, an estimation of the value (floating-point) with that rank.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestByrankAndForget

      public RedisAPI tdigestByrankAndForget(List<String> args)
      Returns, for each input rank, an estimation of the value (floating-point) with that rank.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestByrevrank

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tdigestByrevrank(List<String> args)
      Returns, for each input reverse rank, an estimation of the value (floating-point) with that reverse rank.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestByrevrankAndAwait

      public io.vertx.redis.client.Response tdigestByrevrankAndAwait(List<String> args)
      Returns, for each input reverse rank, an estimation of the value (floating-point) with that reverse rank.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestByrevrankAndForget

      public RedisAPI tdigestByrevrankAndForget(List<String> args)
      Returns, for each input reverse rank, an estimation of the value (floating-point) with that reverse rank.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestCdf

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tdigestCdf(List<String> args)
      Returns, for each input value, an estimation of the floating-point fraction of (observations smaller than the given value + half the observations equal to the given value). Multiple fractions can be retrieved in a single call.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestCdfAndAwait

      public io.vertx.redis.client.Response tdigestCdfAndAwait(List<String> args)
      Returns, for each input value, an estimation of the floating-point fraction of (observations smaller than the given value + half the observations equal to the given value). Multiple fractions can be retrieved in a single call.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestCdfAndForget

      public RedisAPI tdigestCdfAndForget(List<String> args)
      Returns, for each input value, an estimation of the floating-point fraction of (observations smaller than the given value + half the observations equal to the given value). Multiple fractions can be retrieved in a single call.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestCreate

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tdigestCreate(List<String> args)
      Allocates memory and initializes a new t-digest sketch.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestCreateAndAwait

      public io.vertx.redis.client.Response tdigestCreateAndAwait(List<String> args)
      Allocates memory and initializes a new t-digest sketch.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestCreateAndForget

      public RedisAPI tdigestCreateAndForget(List<String> args)
      Allocates memory and initializes a new t-digest sketch.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestInfo

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tdigestInfo(String arg0)
      Returns information and statistics about a t-digest sketch.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestInfoAndAwait

      public io.vertx.redis.client.Response tdigestInfoAndAwait(String arg0)
      Returns information and statistics about a t-digest sketch.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestInfoAndForget

      public RedisAPI tdigestInfoAndForget(String arg0)
      Returns information and statistics about a t-digest sketch.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestInfo

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tdigestInfo(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • RedisAPI.tdigestInfo(List)
    • tdigestInfoAndAwait

      public io.vertx.redis.client.Response tdigestInfoAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
      • RedisAPI.tdigestInfo(List)
    • tdigestInfoAndForget

      public RedisAPI tdigestInfoAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • RedisAPI.tdigestInfo(List)
    • tdigestMax

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tdigestMax(String arg0)
      Returns the maximum observation value from a t-digest sketch.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestMaxAndAwait

      public io.vertx.redis.client.Response tdigestMaxAndAwait(String arg0)
      Returns the maximum observation value from a t-digest sketch.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestMaxAndForget

      public RedisAPI tdigestMaxAndForget(String arg0)
      Returns the maximum observation value from a t-digest sketch.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestMax

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tdigestMax(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • RedisAPI.tdigestMax(List)
    • tdigestMaxAndAwait

      public io.vertx.redis.client.Response tdigestMaxAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
      • RedisAPI.tdigestMax(List)
    • tdigestMaxAndForget

      public RedisAPI tdigestMaxAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • RedisAPI.tdigestMax(List)
    • tdigestMerge

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tdigestMerge(List<String> args)
      Merges multiple t-digest sketches into a single sketch.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestMergeAndAwait

      public io.vertx.redis.client.Response tdigestMergeAndAwait(List<String> args)
      Merges multiple t-digest sketches into a single sketch.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestMergeAndForget

      public RedisAPI tdigestMergeAndForget(List<String> args)
      Merges multiple t-digest sketches into a single sketch.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestMin

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tdigestMin(String arg0)
      Returns the minimum observation value from a t-digest sketch.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestMinAndAwait

      public io.vertx.redis.client.Response tdigestMinAndAwait(String arg0)
      Returns the minimum observation value from a t-digest sketch.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestMinAndForget

      public RedisAPI tdigestMinAndForget(String arg0)
      Returns the minimum observation value from a t-digest sketch.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestMin

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tdigestMin(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • RedisAPI.tdigestMin(List)
    • tdigestMinAndAwait

      public io.vertx.redis.client.Response tdigestMinAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
      • RedisAPI.tdigestMin(List)
    • tdigestMinAndForget

      public RedisAPI tdigestMinAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • RedisAPI.tdigestMin(List)
    • tdigestQuantile

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tdigestQuantile(List<String> args)
      Returns, for each input fraction, an estimation of the value (floating point) that is smaller than the given fraction of observations.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestQuantileAndAwait

      public io.vertx.redis.client.Response tdigestQuantileAndAwait(List<String> args)
      Returns, for each input fraction, an estimation of the value (floating point) that is smaller than the given fraction of observations.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestQuantileAndForget

      public RedisAPI tdigestQuantileAndForget(List<String> args)
      Returns, for each input fraction, an estimation of the value (floating point) that is smaller than the given fraction of observations.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestRank

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tdigestRank(List<String> args)
      Returns, for each input value (floating-point), the estimated rank of the value (the number of observations in the sketch that are smaller than the value + half the number of observations that are equal to the value).

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestRankAndAwait

      public io.vertx.redis.client.Response tdigestRankAndAwait(List<String> args)
      Returns, for each input value (floating-point), the estimated rank of the value (the number of observations in the sketch that are smaller than the value + half the number of observations that are equal to the value).

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestRankAndForget

      public RedisAPI tdigestRankAndForget(List<String> args)
      Returns, for each input value (floating-point), the estimated rank of the value (the number of observations in the sketch that are smaller than the value + half the number of observations that are equal to the value).

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestReset

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tdigestReset(String arg0)
      Resets a t-digest sketch: empty the sketch and re-initializes it.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestResetAndAwait

      public io.vertx.redis.client.Response tdigestResetAndAwait(String arg0)
      Resets a t-digest sketch: empty the sketch and re-initializes it.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestResetAndForget

      public RedisAPI tdigestResetAndForget(String arg0)
      Resets a t-digest sketch: empty the sketch and re-initializes it.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestReset

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tdigestReset(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • RedisAPI.tdigestReset(List)
    • tdigestResetAndAwait

      public io.vertx.redis.client.Response tdigestResetAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
      • RedisAPI.tdigestReset(List)
    • tdigestResetAndForget

      public RedisAPI tdigestResetAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • RedisAPI.tdigestReset(List)
    • tdigestRevrank

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tdigestRevrank(List<String> args)
      Returns, for each input value (floating-point), the estimated reverse rank of the value (the number of observations in the sketch that are larger than the value + half the number of observations that are equal to the value).

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestRevrankAndAwait

      public io.vertx.redis.client.Response tdigestRevrankAndAwait(List<String> args)
      Returns, for each input value (floating-point), the estimated reverse rank of the value (the number of observations in the sketch that are larger than the value + half the number of observations that are equal to the value).

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestRevrankAndForget

      public RedisAPI tdigestRevrankAndForget(List<String> args)
      Returns, for each input value (floating-point), the estimated reverse rank of the value (the number of observations in the sketch that are larger than the value + half the number of observations that are equal to the value).

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestTrimmedMean

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tdigestTrimmedMean(String arg0, String arg1, String arg2)
      Returns an estimation of the mean value from the sketch, excluding observation values outside the low and high cutoff quantiles.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestTrimmedMeanAndAwait

      public io.vertx.redis.client.Response tdigestTrimmedMeanAndAwait(String arg0, String arg1, String arg2)
      Returns an estimation of the mean value from the sketch, excluding observation values outside the low and high cutoff quantiles.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestTrimmedMeanAndForget

      public RedisAPI tdigestTrimmedMeanAndForget(String arg0, String arg1, String arg2)
      Returns an estimation of the mean value from the sketch, excluding observation values outside the low and high cutoff quantiles.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 2.4.0
      See Also:
    • tdigestTrimmedMean

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tdigestTrimmedMean(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • RedisAPI.tdigestTrimmedMean(List)
    • tdigestTrimmedMeanAndAwait

      public io.vertx.redis.client.Response tdigestTrimmedMeanAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
      • RedisAPI.tdigestTrimmedMean(List)
    • tdigestTrimmedMeanAndForget

      public RedisAPI tdigestTrimmedMeanAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • RedisAPI.tdigestTrimmedMean(List)
    • time

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> time()
      Returns the server time.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.6.0
      See Also:
      • TIME
      • RedisAPI.time()
    • timeAndAwait

      public io.vertx.redis.client.Response timeAndAwait()
      Returns the server time.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.6.0
      See Also:
      • TIME
      • RedisAPI.time()
    • timeAndForget

      public RedisAPI timeAndForget()
      Returns the server time.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.6.0
      See Also:
      • TIME
      • RedisAPI.time()
    • timeseriesClusterset

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> timeseriesClusterset(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
    • timeseriesClustersetAndAwait

      public io.vertx.redis.client.Response timeseriesClustersetAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
    • timeseriesClustersetAndForget

      public RedisAPI timeseriesClustersetAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
    • timeseriesClustersetfromshard

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> timeseriesClustersetfromshard(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
    • timeseriesClustersetfromshardAndAwait

      public io.vertx.redis.client.Response timeseriesClustersetfromshardAndAwait(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
    • timeseriesClustersetfromshardAndForget

      public RedisAPI timeseriesClustersetfromshardAndForget(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
    • timeseriesHello

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> timeseriesHello(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
    • timeseriesHelloAndAwait

      public io.vertx.redis.client.Response timeseriesHelloAndAwait(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
    • timeseriesHelloAndForget

      public RedisAPI timeseriesHelloAndForget(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
    • timeseriesInfocluster

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> timeseriesInfocluster(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
    • timeseriesInfoclusterAndAwait

      public io.vertx.redis.client.Response timeseriesInfoclusterAndAwait(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
    • timeseriesInfoclusterAndForget

      public RedisAPI timeseriesInfoclusterAndForget(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
    • timeseriesInnercommunication

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> timeseriesInnercommunication(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
    • timeseriesInnercommunicationAndAwait

      public io.vertx.redis.client.Response timeseriesInnercommunicationAndAwait(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
    • timeseriesInnercommunicationAndForget

      public RedisAPI timeseriesInnercommunicationAndForget(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
    • timeseriesNetworktest

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> timeseriesNetworktest(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
    • timeseriesNetworktestAndAwait

      public io.vertx.redis.client.Response timeseriesNetworktestAndAwait(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
    • timeseriesNetworktestAndForget

      public RedisAPI timeseriesNetworktestAndForget(List<String> args)
      Deprecated.
      this command no longer exists in the latest Redis release

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
    • timeseriesRefreshcluster

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> timeseriesRefreshcluster(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
    • timeseriesRefreshclusterAndAwait

      public io.vertx.redis.client.Response timeseriesRefreshclusterAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
    • timeseriesRefreshclusterAndForget

      public RedisAPI timeseriesRefreshclusterAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
    • topkAdd

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> topkAdd(List<String> args)
      Adds an item to a Top-k sketch. Multiple items can be added at the same time.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 2.0.0
      See Also:
    • topkAddAndAwait

      public io.vertx.redis.client.Response topkAddAndAwait(List<String> args)
      Adds an item to a Top-k sketch. Multiple items can be added at the same time.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 2.0.0
      See Also:
    • topkAddAndForget

      public RedisAPI topkAddAndForget(List<String> args)
      Adds an item to a Top-k sketch. Multiple items can be added at the same time.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 2.0.0
      See Also:
    • topkCount

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> topkCount(List<String> args)
      Return the count for one or more items are in a sketch.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 2.0.0
      See Also:
    • topkCountAndAwait

      public io.vertx.redis.client.Response topkCountAndAwait(List<String> args)
      Return the count for one or more items are in a sketch.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 2.0.0
      See Also:
    • topkCountAndForget

      public RedisAPI topkCountAndForget(List<String> args)
      Return the count for one or more items are in a sketch.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 2.0.0
      See Also:
    • topkIncrby

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> topkIncrby(List<String> args)
      Increases the count of one or more items by increment.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 2.0.0
      See Also:
    • topkIncrbyAndAwait

      public io.vertx.redis.client.Response topkIncrbyAndAwait(List<String> args)
      Increases the count of one or more items by increment.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 2.0.0
      See Also:
    • topkIncrbyAndForget

      public RedisAPI topkIncrbyAndForget(List<String> args)
      Increases the count of one or more items by increment.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 2.0.0
      See Also:
    • topkInfo

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> topkInfo(String arg0)
      Returns information about a sketch.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 2.0.0
      See Also:
    • topkInfoAndAwait

      public io.vertx.redis.client.Response topkInfoAndAwait(String arg0)
      Returns information about a sketch.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 2.0.0
      See Also:
    • topkInfoAndForget

      public RedisAPI topkInfoAndForget(String arg0)
      Returns information about a sketch.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 2.0.0
      See Also:
    • topkInfo

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> topkInfo(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • RedisAPI.topkInfo(List)
    • topkInfoAndAwait

      public io.vertx.redis.client.Response topkInfoAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
      • RedisAPI.topkInfo(List)
    • topkInfoAndForget

      public RedisAPI topkInfoAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • RedisAPI.topkInfo(List)
    • topkList

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> topkList(List<String> args)
      Return the full list of items in Top-K sketch.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 2.0.0
      See Also:
    • topkListAndAwait

      public io.vertx.redis.client.Response topkListAndAwait(List<String> args)
      Return the full list of items in Top-K sketch.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 2.0.0
      See Also:
    • topkListAndForget

      public RedisAPI topkListAndForget(List<String> args)
      Return the full list of items in Top-K sketch.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 2.0.0
      See Also:
    • topkQuery

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> topkQuery(List<String> args)
      Checks whether one or more items are in a sketch.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 2.0.0
      See Also:
    • topkQueryAndAwait

      public io.vertx.redis.client.Response topkQueryAndAwait(List<String> args)
      Checks whether one or more items are in a sketch.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 2.0.0
      See Also:
    • topkQueryAndForget

      public RedisAPI topkQueryAndForget(List<String> args)
      Checks whether one or more items are in a sketch.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 2.0.0
      See Also:
    • topkReserve

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> topkReserve(List<String> args)
      Initializes a Top-K sketch with specified parameters.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis Bloom 2.0.0
      See Also:
    • topkReserveAndAwait

      public io.vertx.redis.client.Response topkReserveAndAwait(List<String> args)
      Initializes a Top-K sketch with specified parameters.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis Bloom 2.0.0
      See Also:
    • topkReserveAndForget

      public RedisAPI topkReserveAndForget(List<String> args)
      Initializes a Top-K sketch with specified parameters.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis Bloom 2.0.0
      See Also:
    • touch

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> touch(List<String> args)
      Returns the number of existing keys out of those specified after updating the time they were last accessed.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 3.2.1
      See Also:
      • TOUCH
      • RedisAPI.touch(List)
    • touchAndAwait

      public io.vertx.redis.client.Response touchAndAwait(List<String> args)
      Returns the number of existing keys out of those specified after updating the time they were last accessed.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 3.2.1
      See Also:
      • TOUCH
      • RedisAPI.touch(List)
    • touchAndForget

      public RedisAPI touchAndForget(List<String> args)
      Returns the number of existing keys out of those specified after updating the time they were last accessed.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 3.2.1
      See Also:
      • TOUCH
      • RedisAPI.touch(List)
    • trimslots

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> trimslots(List<String> args)
      Trim the keys that belong to specified slots.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 8.4.0
      See Also:
    • trimslotsAndAwait

      public io.vertx.redis.client.Response trimslotsAndAwait(List<String> args)
      Trim the keys that belong to specified slots.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 8.4.0
      See Also:
    • trimslotsAndForget

      public RedisAPI trimslotsAndForget(List<String> args)
      Trim the keys that belong to specified slots.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 8.4.0
      See Also:
    • tsAdd

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tsAdd(List<String> args)
      Append a sample to a time series.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsAddAndAwait

      public io.vertx.redis.client.Response tsAddAndAwait(List<String> args)
      Append a sample to a time series.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsAddAndForget

      public RedisAPI tsAddAndForget(List<String> args)
      Append a sample to a time series.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsAlter

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tsAlter(List<String> args)
      Update the retention, chunk size, duplicate policy, and labels of an existing time series.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsAlterAndAwait

      public io.vertx.redis.client.Response tsAlterAndAwait(List<String> args)
      Update the retention, chunk size, duplicate policy, and labels of an existing time series.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsAlterAndForget

      public RedisAPI tsAlterAndForget(List<String> args)
      Update the retention, chunk size, duplicate policy, and labels of an existing time series.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsCreate

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tsCreate(List<String> args)
      Create a new time series.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsCreateAndAwait

      public io.vertx.redis.client.Response tsCreateAndAwait(List<String> args)
      Create a new time series.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsCreateAndForget

      public RedisAPI tsCreateAndForget(List<String> args)
      Create a new time series.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsCreaterule

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tsCreaterule(List<String> args)
      Create a compaction rule.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsCreateruleAndAwait

      public io.vertx.redis.client.Response tsCreateruleAndAwait(List<String> args)
      Create a compaction rule.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsCreateruleAndForget

      public RedisAPI tsCreateruleAndForget(List<String> args)
      Create a compaction rule.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsDecrby

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tsDecrby(List<String> args)
      Decrease the value of the latest sample.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsDecrbyAndAwait

      public io.vertx.redis.client.Response tsDecrbyAndAwait(List<String> args)
      Decrease the value of the latest sample.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsDecrbyAndForget

      public RedisAPI tsDecrbyAndForget(List<String> args)
      Decrease the value of the latest sample.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsDel

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tsDel(String arg0, String arg1, String arg2)
      Delete all samples between two timestamps for a given time series.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis TimeSeries 1.6.0
      See Also:
      • TS.DEL
      • RedisAPI.tsDel(String, String, String)
    • tsDelAndAwait

      public io.vertx.redis.client.Response tsDelAndAwait(String arg0, String arg1, String arg2)
      Delete all samples between two timestamps for a given time series.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis TimeSeries 1.6.0
      See Also:
      • TS.DEL
      • RedisAPI.tsDel(String, String, String)
    • tsDelAndForget

      public RedisAPI tsDelAndForget(String arg0, String arg1, String arg2)
      Delete all samples between two timestamps for a given time series.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis TimeSeries 1.6.0
      See Also:
      • TS.DEL
      • RedisAPI.tsDel(String, String, String)
    • tsDel

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tsDel(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • RedisAPI.tsDel(List)
    • tsDelAndAwait

      public io.vertx.redis.client.Response tsDelAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
      • RedisAPI.tsDel(List)
    • tsDelAndForget

      public RedisAPI tsDelAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • RedisAPI.tsDel(List)
    • tsDeleterule

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tsDeleterule(String arg0, String arg1)
      Delete a compaction rule.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsDeleteruleAndAwait

      public io.vertx.redis.client.Response tsDeleteruleAndAwait(String arg0, String arg1)
      Delete a compaction rule.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsDeleteruleAndForget

      public RedisAPI tsDeleteruleAndForget(String arg0, String arg1)
      Delete a compaction rule.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsDeleterule

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tsDeleterule(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • RedisAPI.tsDeleterule(List)
    • tsDeleteruleAndAwait

      public io.vertx.redis.client.Response tsDeleteruleAndAwait(List<String> args)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
      • RedisAPI.tsDeleterule(List)
    • tsDeleteruleAndForget

      public RedisAPI tsDeleteruleAndForget(List<String> args)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • RedisAPI.tsDeleterule(List)
    • tsGet

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tsGet(List<String> args)
      Get the sample with the highest timestamp from a given time series.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsGetAndAwait

      public io.vertx.redis.client.Response tsGetAndAwait(List<String> args)
      Get the sample with the highest timestamp from a given time series.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsGetAndForget

      public RedisAPI tsGetAndForget(List<String> args)
      Get the sample with the highest timestamp from a given time series.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsIncrby

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tsIncrby(List<String> args)
      Increase the value of the latest sample.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsIncrbyAndAwait

      public io.vertx.redis.client.Response tsIncrbyAndAwait(List<String> args)
      Increase the value of the latest sample.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsIncrbyAndForget

      public RedisAPI tsIncrbyAndForget(List<String> args)
      Increase the value of the latest sample.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsInfo

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tsInfo(List<String> args)
      Returns information and statistics for a time series.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsInfoAndAwait

      public io.vertx.redis.client.Response tsInfoAndAwait(List<String> args)
      Returns information and statistics for a time series.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsInfoAndForget

      public RedisAPI tsInfoAndForget(List<String> args)
      Returns information and statistics for a time series.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsMadd

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tsMadd(List<String> args)
      Append new samples to one or more time series.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsMaddAndAwait

      public io.vertx.redis.client.Response tsMaddAndAwait(List<String> args)
      Append new samples to one or more time series.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsMaddAndForget

      public RedisAPI tsMaddAndForget(List<String> args)
      Append new samples to one or more time series.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsMget

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tsMget(List<String> args)
      Get the sample with the highest timestamp from each time series matching a specific filter.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsMgetAndAwait

      public io.vertx.redis.client.Response tsMgetAndAwait(List<String> args)
      Get the sample with the highest timestamp from each time series matching a specific filter.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsMgetAndForget

      public RedisAPI tsMgetAndForget(List<String> args)
      Get the sample with the highest timestamp from each time series matching a specific filter.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsMrange

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tsMrange(List<String> args)
      Query a range across multiple time series by filters in forward direction.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsMrangeAndAwait

      public io.vertx.redis.client.Response tsMrangeAndAwait(List<String> args)
      Query a range across multiple time series by filters in forward direction.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsMrangeAndForget

      public RedisAPI tsMrangeAndForget(List<String> args)
      Query a range across multiple time series by filters in forward direction.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsMrevrange

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tsMrevrange(List<String> args)
      Query a range across multiple time series by filters in reverse direction.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis TimeSeries 1.4.0
      See Also:
    • tsMrevrangeAndAwait

      public io.vertx.redis.client.Response tsMrevrangeAndAwait(List<String> args)
      Query a range across multiple time series by filters in reverse direction.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis TimeSeries 1.4.0
      See Also:
    • tsMrevrangeAndForget

      public RedisAPI tsMrevrangeAndForget(List<String> args)
      Query a range across multiple time series by filters in reverse direction.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis TimeSeries 1.4.0
      See Also:
    • tsQueryindex

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tsQueryindex(List<String> args)
      Get all time series keys matching a filter list.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsQueryindexAndAwait

      public io.vertx.redis.client.Response tsQueryindexAndAwait(List<String> args)
      Get all time series keys matching a filter list.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsQueryindexAndForget

      public RedisAPI tsQueryindexAndForget(List<String> args)
      Get all time series keys matching a filter list.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsRange

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tsRange(List<String> args)
      Query a range in forward direction.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsRangeAndAwait

      public io.vertx.redis.client.Response tsRangeAndAwait(List<String> args)
      Query a range in forward direction.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsRangeAndForget

      public RedisAPI tsRangeAndForget(List<String> args)
      Query a range in forward direction.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis TimeSeries 1.0.0
      See Also:
    • tsRevrange

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> tsRevrange(List<String> args)
      Query a range in reverse direction.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis TimeSeries 1.4.0
      See Also:
    • tsRevrangeAndAwait

      public io.vertx.redis.client.Response tsRevrangeAndAwait(List<String> args)
      Query a range in reverse direction.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis TimeSeries 1.4.0
      See Also:
    • tsRevrangeAndForget

      public RedisAPI tsRevrangeAndForget(List<String> args)
      Query a range in reverse direction.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis TimeSeries 1.4.0
      See Also:
    • ttl

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> ttl(String arg0)
      Returns the expiration time in seconds of a key.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • TTL
      • RedisAPI.ttl(String)
    • ttlAndAwait

      public io.vertx.redis.client.Response ttlAndAwait(String arg0)
      Returns the expiration time in seconds of a key.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • TTL
      • RedisAPI.ttl(String)
    • ttlAndForget

      public RedisAPI ttlAndForget(String arg0)
      Returns the expiration time in seconds of a key.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • TTL
      • RedisAPI.ttl(String)
    • type

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> type(String arg0)
      Determines the type of value stored at a key.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.0
      See Also:
      • TYPE
      • RedisAPI.type(String)
    • typeAndAwait

      public io.vertx.redis.client.Response typeAndAwait(String arg0)
      Determines the type of value stored at a key.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.0
      See Also:
      • TYPE
      • RedisAPI.type(String)
    • typeAndForget

      public RedisAPI typeAndForget(String arg0)
      Determines the type of value stored at a key.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.0
      See Also:
      • TYPE
      • RedisAPI.type(String)
    • unlink

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> unlink(List<String> args)
      Asynchronously deletes one or more keys.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 4.0.0
      See Also:
      • UNLINK
      • RedisAPI.unlink(List)
    • unlinkAndAwait

      public io.vertx.redis.client.Response unlinkAndAwait(List<String> args)
      Asynchronously deletes one or more keys.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 4.0.0
      See Also:
      • UNLINK
      • RedisAPI.unlink(List)
    • unlinkAndForget

      public RedisAPI unlinkAndForget(List<String> args)
      Asynchronously deletes one or more keys.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 4.0.0
      See Also:
      • UNLINK
      • RedisAPI.unlink(List)
    • unsubscribe

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> unsubscribe(List<String> args)
      Stops listening to messages posted to channels.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.0.0
      See Also:
    • unsubscribeAndAwait

      public io.vertx.redis.client.Response unsubscribeAndAwait(List<String> args)
      Stops listening to messages posted to channels.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.0.0
      See Also:
    • unsubscribeAndForget

      public RedisAPI unsubscribeAndForget(List<String> args)
      Stops listening to messages posted to channels.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.0.0
      See Also:
    • unwatch

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> unwatch()
      Forgets about watched keys of a transaction.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.2.0
      See Also:
    • unwatchAndAwait

      public io.vertx.redis.client.Response unwatchAndAwait()
      Forgets about watched keys of a transaction.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.2.0
      See Also:
    • unwatchAndForget

      public RedisAPI unwatchAndForget()
      Forgets about watched keys of a transaction.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.2.0
      See Also:
    • wait

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> wait(String arg0, String arg1)
      Blocks until the asynchronous replication of all preceding write commands sent by the connection is completed.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 3.0.0
      See Also:
      • WAIT
      • RedisAPI.wait(String, String)
    • waitAndAwait

      public io.vertx.redis.client.Response waitAndAwait(String arg0, String arg1)
      Blocks until the asynchronous replication of all preceding write commands sent by the connection is completed.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 3.0.0
      See Also:
      • WAIT
      • RedisAPI.wait(String, String)
    • waitAndForget

      public RedisAPI waitAndForget(String arg0, String arg1)
      Blocks until the asynchronous replication of all preceding write commands sent by the connection is completed.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 3.0.0
      See Also:
      • WAIT
      • RedisAPI.wait(String, String)
    • waitaof

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> waitaof(String arg0, String arg1, String arg2)
      Blocks until all of the preceding write commands sent by the connection are written to the append-only file of the master and/or replicas.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 7.2.0
      See Also:
      • WAITAOF
      • RedisAPI.waitaof(String, String, String)
    • waitaofAndAwait

      public io.vertx.redis.client.Response waitaofAndAwait(String arg0, String arg1, String arg2)
      Blocks until all of the preceding write commands sent by the connection are written to the append-only file of the master and/or replicas.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 7.2.0
      See Also:
      • WAITAOF
      • RedisAPI.waitaof(String, String, String)
    • waitaofAndForget

      public RedisAPI waitaofAndForget(String arg0, String arg1, String arg2)
      Blocks until all of the preceding write commands sent by the connection are written to the append-only file of the master and/or replicas.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 7.2.0
      See Also:
      • WAITAOF
      • RedisAPI.waitaof(String, String, String)
    • watch

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> watch(List<String> args)
      Monitors changes to keys to determine the execution of a transaction.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.2.0
      See Also:
      • WATCH
      • RedisAPI.watch(List)
    • watchAndAwait

      public io.vertx.redis.client.Response watchAndAwait(List<String> args)
      Monitors changes to keys to determine the execution of a transaction.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.2.0
      See Also:
      • WATCH
      • RedisAPI.watch(List)
    • watchAndForget

      public RedisAPI watchAndForget(List<String> args)
      Monitors changes to keys to determine the execution of a transaction.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.2.0
      See Also:
      • WATCH
      • RedisAPI.watch(List)
    • xack

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> xack(List<String> args)
      Returns the number of messages that were successfully acknowledged by the consumer group member of a stream.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 5.0.0
      See Also:
      • XACK
      • RedisAPI.xack(List)
    • xackAndAwait

      public io.vertx.redis.client.Response xackAndAwait(List<String> args)
      Returns the number of messages that were successfully acknowledged by the consumer group member of a stream.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 5.0.0
      See Also:
      • XACK
      • RedisAPI.xack(List)
    • xackAndForget

      public RedisAPI xackAndForget(List<String> args)
      Returns the number of messages that were successfully acknowledged by the consumer group member of a stream.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 5.0.0
      See Also:
      • XACK
      • RedisAPI.xack(List)
    • xackdel

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> xackdel(List<String> args)
      Acknowledges and deletes one or multiple messages for a stream consumer group.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 8.2.0
      See Also:
    • xackdelAndAwait

      public io.vertx.redis.client.Response xackdelAndAwait(List<String> args)
      Acknowledges and deletes one or multiple messages for a stream consumer group.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 8.2.0
      See Also:
    • xackdelAndForget

      public RedisAPI xackdelAndForget(List<String> args)
      Acknowledges and deletes one or multiple messages for a stream consumer group.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 8.2.0
      See Also:
    • xadd

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> xadd(List<String> args)
      Appends a new message to a stream. Creates the key if it doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 5.0.0
      See Also:
      • XADD
      • RedisAPI.xadd(List)
    • xaddAndAwait

      public io.vertx.redis.client.Response xaddAndAwait(List<String> args)
      Appends a new message to a stream. Creates the key if it doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 5.0.0
      See Also:
      • XADD
      • RedisAPI.xadd(List)
    • xaddAndForget

      public RedisAPI xaddAndForget(List<String> args)
      Appends a new message to a stream. Creates the key if it doesn't exist.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 5.0.0
      See Also:
      • XADD
      • RedisAPI.xadd(List)
    • xautoclaim

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> xautoclaim(List<String> args)
      Changes, or acquires, ownership of messages in a consumer group, as if the messages were delivered to as consumer group member.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 6.2.0
      See Also:
    • xautoclaimAndAwait

      public io.vertx.redis.client.Response xautoclaimAndAwait(List<String> args)
      Changes, or acquires, ownership of messages in a consumer group, as if the messages were delivered to as consumer group member.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 6.2.0
      See Also:
    • xautoclaimAndForget

      public RedisAPI xautoclaimAndForget(List<String> args)
      Changes, or acquires, ownership of messages in a consumer group, as if the messages were delivered to as consumer group member.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 6.2.0
      See Also:
    • xcfgset

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> xcfgset(List<String> args)
      Sets the IDMP configuration parameters for a stream.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 8.6.0
      See Also:
    • xcfgsetAndAwait

      public io.vertx.redis.client.Response xcfgsetAndAwait(List<String> args)
      Sets the IDMP configuration parameters for a stream.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 8.6.0
      See Also:
    • xcfgsetAndForget

      public RedisAPI xcfgsetAndForget(List<String> args)
      Sets the IDMP configuration parameters for a stream.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 8.6.0
      See Also:
    • xclaim

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> xclaim(List<String> args)
      Changes, or acquires, ownership of a message in a consumer group, as if the message was delivered a consumer group member.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 5.0.0
      See Also:
      • XCLAIM
      • RedisAPI.xclaim(List)
    • xclaimAndAwait

      public io.vertx.redis.client.Response xclaimAndAwait(List<String> args)
      Changes, or acquires, ownership of a message in a consumer group, as if the message was delivered a consumer group member.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 5.0.0
      See Also:
      • XCLAIM
      • RedisAPI.xclaim(List)
    • xclaimAndForget

      public RedisAPI xclaimAndForget(List<String> args)
      Changes, or acquires, ownership of a message in a consumer group, as if the message was delivered a consumer group member.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 5.0.0
      See Also:
      • XCLAIM
      • RedisAPI.xclaim(List)
    • xdel

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> xdel(List<String> args)
      Returns the number of messages after removing them from a stream.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 5.0.0
      See Also:
      • XDEL
      • RedisAPI.xdel(List)
    • xdelAndAwait

      public io.vertx.redis.client.Response xdelAndAwait(List<String> args)
      Returns the number of messages after removing them from a stream.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 5.0.0
      See Also:
      • XDEL
      • RedisAPI.xdel(List)
    • xdelAndForget

      public RedisAPI xdelAndForget(List<String> args)
      Returns the number of messages after removing them from a stream.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 5.0.0
      See Also:
      • XDEL
      • RedisAPI.xdel(List)
    • xdelex

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> xdelex(List<String> args)
      Deletes one or multiple entries from the stream.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 8.2.0
      See Also:
      • XDELEX
      • RedisAPI.xdelex(List)
    • xdelexAndAwait

      public io.vertx.redis.client.Response xdelexAndAwait(List<String> args)
      Deletes one or multiple entries from the stream.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 8.2.0
      See Also:
      • XDELEX
      • RedisAPI.xdelex(List)
    • xdelexAndForget

      public RedisAPI xdelexAndForget(List<String> args)
      Deletes one or multiple entries from the stream.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 8.2.0
      See Also:
      • XDELEX
      • RedisAPI.xdelex(List)
    • xgroup

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> xgroup(List<String> args)
      A container for consumer groups commands.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 5.0.0
      See Also:
      • XGROUP
      • RedisAPI.xgroup(List)
    • xgroupAndAwait

      public io.vertx.redis.client.Response xgroupAndAwait(List<String> args)
      A container for consumer groups commands.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 5.0.0
      See Also:
      • XGROUP
      • RedisAPI.xgroup(List)
    • xgroupAndForget

      public RedisAPI xgroupAndForget(List<String> args)
      A container for consumer groups commands.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 5.0.0
      See Also:
      • XGROUP
      • RedisAPI.xgroup(List)
    • xidmprecord

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> xidmprecord(String arg0, String arg1, String arg2, String arg3)
      An internal command for setting IDMP metadata on an existing stream message.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 8.6.2
      See Also:
      • XIDMPRECORD
      • RedisAPI.xidmprecord(String, String, String, String)
    • xidmprecordAndAwait

      public io.vertx.redis.client.Response xidmprecordAndAwait(String arg0, String arg1, String arg2, String arg3)
      An internal command for setting IDMP metadata on an existing stream message.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 8.6.2
      See Also:
      • XIDMPRECORD
      • RedisAPI.xidmprecord(String, String, String, String)
    • xidmprecordAndForget

      public RedisAPI xidmprecordAndForget(String arg0, String arg1, String arg2, String arg3)
      An internal command for setting IDMP metadata on an existing stream message.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 8.6.2
      See Also:
      • XIDMPRECORD
      • RedisAPI.xidmprecord(String, String, String, String)
    • xinfo

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> xinfo(List<String> args)
      A container for stream introspection commands.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 5.0.0
      See Also:
      • XINFO
      • RedisAPI.xinfo(List)
    • xinfoAndAwait

      public io.vertx.redis.client.Response xinfoAndAwait(List<String> args)
      A container for stream introspection commands.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 5.0.0
      See Also:
      • XINFO
      • RedisAPI.xinfo(List)
    • xinfoAndForget

      public RedisAPI xinfoAndForget(List<String> args)
      A container for stream introspection commands.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 5.0.0
      See Also:
      • XINFO
      • RedisAPI.xinfo(List)
    • xlen

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> xlen(String arg0)
      Return the number of messages in a stream.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 5.0.0
      See Also:
      • XLEN
      • RedisAPI.xlen(String)
    • xlenAndAwait

      public io.vertx.redis.client.Response xlenAndAwait(String arg0)
      Return the number of messages in a stream.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 5.0.0
      See Also:
      • XLEN
      • RedisAPI.xlen(String)
    • xlenAndForget

      public RedisAPI xlenAndForget(String arg0)
      Return the number of messages in a stream.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 5.0.0
      See Also:
      • XLEN
      • RedisAPI.xlen(String)
    • xpending

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> xpending(List<String> args)
      Returns the information and entries from a stream consumer group's pending entries list.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 5.0.0
      See Also:
    • xpendingAndAwait

      public io.vertx.redis.client.Response xpendingAndAwait(List<String> args)
      Returns the information and entries from a stream consumer group's pending entries list.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 5.0.0
      See Also:
    • xpendingAndForget

      public RedisAPI xpendingAndForget(List<String> args)
      Returns the information and entries from a stream consumer group's pending entries list.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 5.0.0
      See Also:
    • xrange

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> xrange(List<String> args)
      Returns the messages from a stream within a range of IDs.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 5.0.0
      See Also:
      • XRANGE
      • RedisAPI.xrange(List)
    • xrangeAndAwait

      public io.vertx.redis.client.Response xrangeAndAwait(List<String> args)
      Returns the messages from a stream within a range of IDs.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 5.0.0
      See Also:
      • XRANGE
      • RedisAPI.xrange(List)
    • xrangeAndForget

      public RedisAPI xrangeAndForget(List<String> args)
      Returns the messages from a stream within a range of IDs.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 5.0.0
      See Also:
      • XRANGE
      • RedisAPI.xrange(List)
    • xread

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> xread(List<String> args)
      Returns messages from multiple streams with IDs greater than the ones requested. Blocks until a message is available otherwise.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 5.0.0
      See Also:
      • XREAD
      • RedisAPI.xread(List)
    • xreadAndAwait

      public io.vertx.redis.client.Response xreadAndAwait(List<String> args)
      Returns messages from multiple streams with IDs greater than the ones requested. Blocks until a message is available otherwise.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 5.0.0
      See Also:
      • XREAD
      • RedisAPI.xread(List)
    • xreadAndForget

      public RedisAPI xreadAndForget(List<String> args)
      Returns messages from multiple streams with IDs greater than the ones requested. Blocks until a message is available otherwise.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 5.0.0
      See Also:
      • XREAD
      • RedisAPI.xread(List)
    • xreadgroup

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> xreadgroup(List<String> args)
      Returns new or historical messages from a stream for a consumer in a group. Blocks until a message is available otherwise.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 5.0.0
      See Also:
    • xreadgroupAndAwait

      public io.vertx.redis.client.Response xreadgroupAndAwait(List<String> args)
      Returns new or historical messages from a stream for a consumer in a group. Blocks until a message is available otherwise.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 5.0.0
      See Also:
    • xreadgroupAndForget

      public RedisAPI xreadgroupAndForget(List<String> args)
      Returns new or historical messages from a stream for a consumer in a group. Blocks until a message is available otherwise.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 5.0.0
      See Also:
    • xrevrange

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> xrevrange(List<String> args)
      Returns the messages from a stream within a range of IDs in reverse order.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 5.0.0
      See Also:
    • xrevrangeAndAwait

      public io.vertx.redis.client.Response xrevrangeAndAwait(List<String> args)
      Returns the messages from a stream within a range of IDs in reverse order.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 5.0.0
      See Also:
    • xrevrangeAndForget

      public RedisAPI xrevrangeAndForget(List<String> args)
      Returns the messages from a stream within a range of IDs in reverse order.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 5.0.0
      See Also:
    • xsetid

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> xsetid(List<String> args)
      An internal command for replicating stream values.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 5.0.0
      See Also:
      • XSETID
      • RedisAPI.xsetid(List)
    • xsetidAndAwait

      public io.vertx.redis.client.Response xsetidAndAwait(List<String> args)
      An internal command for replicating stream values.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 5.0.0
      See Also:
      • XSETID
      • RedisAPI.xsetid(List)
    • xsetidAndForget

      public RedisAPI xsetidAndForget(List<String> args)
      An internal command for replicating stream values.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 5.0.0
      See Also:
      • XSETID
      • RedisAPI.xsetid(List)
    • xtrim

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> xtrim(List<String> args)
      Deletes messages from the beginning of a stream.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 5.0.0
      See Also:
      • XTRIM
      • RedisAPI.xtrim(List)
    • xtrimAndAwait

      public io.vertx.redis.client.Response xtrimAndAwait(List<String> args)
      Deletes messages from the beginning of a stream.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 5.0.0
      See Also:
      • XTRIM
      • RedisAPI.xtrim(List)
    • xtrimAndForget

      public RedisAPI xtrimAndForget(List<String> args)
      Deletes messages from the beginning of a stream.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 5.0.0
      See Also:
      • XTRIM
      • RedisAPI.xtrim(List)
    • zadd

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> zadd(List<String> args)
      Adds one or more members to a sorted set, or updates their scores. Creates the key if it doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.2.0
      See Also:
      • ZADD
      • RedisAPI.zadd(List)
    • zaddAndAwait

      public io.vertx.redis.client.Response zaddAndAwait(List<String> args)
      Adds one or more members to a sorted set, or updates their scores. Creates the key if it doesn't exist.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.2.0
      See Also:
      • ZADD
      • RedisAPI.zadd(List)
    • zaddAndForget

      public RedisAPI zaddAndForget(List<String> args)
      Adds one or more members to a sorted set, or updates their scores. Creates the key if it doesn't exist.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.2.0
      See Also:
      • ZADD
      • RedisAPI.zadd(List)
    • zcard

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> zcard(String arg0)
      Returns the number of members in a sorted set.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.2.0
      See Also:
      • ZCARD
      • RedisAPI.zcard(String)
    • zcardAndAwait

      public io.vertx.redis.client.Response zcardAndAwait(String arg0)
      Returns the number of members in a sorted set.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.2.0
      See Also:
      • ZCARD
      • RedisAPI.zcard(String)
    • zcardAndForget

      public RedisAPI zcardAndForget(String arg0)
      Returns the number of members in a sorted set.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.2.0
      See Also:
      • ZCARD
      • RedisAPI.zcard(String)
    • zcount

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> zcount(String arg0, String arg1, String arg2)
      Returns the count of members in a sorted set that have scores within a range.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.0.0
      See Also:
      • ZCOUNT
      • RedisAPI.zcount(String, String, String)
    • zcountAndAwait

      public io.vertx.redis.client.Response zcountAndAwait(String arg0, String arg1, String arg2)
      Returns the count of members in a sorted set that have scores within a range.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.0.0
      See Also:
      • ZCOUNT
      • RedisAPI.zcount(String, String, String)
    • zcountAndForget

      public RedisAPI zcountAndForget(String arg0, String arg1, String arg2)
      Returns the count of members in a sorted set that have scores within a range.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.0.0
      See Also:
      • ZCOUNT
      • RedisAPI.zcount(String, String, String)
    • zdiff

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> zdiff(List<String> args)
      Returns the difference between multiple sorted sets.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 6.2.0
      See Also:
      • ZDIFF
      • RedisAPI.zdiff(List)
    • zdiffAndAwait

      public io.vertx.redis.client.Response zdiffAndAwait(List<String> args)
      Returns the difference between multiple sorted sets.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 6.2.0
      See Also:
      • ZDIFF
      • RedisAPI.zdiff(List)
    • zdiffAndForget

      public RedisAPI zdiffAndForget(List<String> args)
      Returns the difference between multiple sorted sets.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 6.2.0
      See Also:
      • ZDIFF
      • RedisAPI.zdiff(List)
    • zdiffstore

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> zdiffstore(List<String> args)
      Stores the difference of multiple sorted sets in a key.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 6.2.0
      See Also:
    • zdiffstoreAndAwait

      public io.vertx.redis.client.Response zdiffstoreAndAwait(List<String> args)
      Stores the difference of multiple sorted sets in a key.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 6.2.0
      See Also:
    • zdiffstoreAndForget

      public RedisAPI zdiffstoreAndForget(List<String> args)
      Stores the difference of multiple sorted sets in a key.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 6.2.0
      See Also:
    • zincrby

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> zincrby(String arg0, String arg1, String arg2)
      Increments the score of a member in a sorted set.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.2.0
      See Also:
      • ZINCRBY
      • RedisAPI.zincrby(String, String, String)
    • zincrbyAndAwait

      public io.vertx.redis.client.Response zincrbyAndAwait(String arg0, String arg1, String arg2)
      Increments the score of a member in a sorted set.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.2.0
      See Also:
      • ZINCRBY
      • RedisAPI.zincrby(String, String, String)
    • zincrbyAndForget

      public RedisAPI zincrbyAndForget(String arg0, String arg1, String arg2)
      Increments the score of a member in a sorted set.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.2.0
      See Also:
      • ZINCRBY
      • RedisAPI.zincrby(String, String, String)
    • zinter

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> zinter(List<String> args)
      Returns the intersect of multiple sorted sets.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 6.2.0
      See Also:
      • ZINTER
      • RedisAPI.zinter(List)
    • zinterAndAwait

      public io.vertx.redis.client.Response zinterAndAwait(List<String> args)
      Returns the intersect of multiple sorted sets.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 6.2.0
      See Also:
      • ZINTER
      • RedisAPI.zinter(List)
    • zinterAndForget

      public RedisAPI zinterAndForget(List<String> args)
      Returns the intersect of multiple sorted sets.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 6.2.0
      See Also:
      • ZINTER
      • RedisAPI.zinter(List)
    • zintercard

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> zintercard(List<String> args)
      Returns the number of members of the intersect of multiple sorted sets.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 7.0.0
      See Also:
    • zintercardAndAwait

      public io.vertx.redis.client.Response zintercardAndAwait(List<String> args)
      Returns the number of members of the intersect of multiple sorted sets.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 7.0.0
      See Also:
    • zintercardAndForget

      public RedisAPI zintercardAndForget(List<String> args)
      Returns the number of members of the intersect of multiple sorted sets.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 7.0.0
      See Also:
    • zinterstore

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> zinterstore(List<String> args)
      Stores the intersect of multiple sorted sets in a key.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.0.0
      See Also:
    • zinterstoreAndAwait

      public io.vertx.redis.client.Response zinterstoreAndAwait(List<String> args)
      Stores the intersect of multiple sorted sets in a key.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.0.0
      See Also:
    • zinterstoreAndForget

      public RedisAPI zinterstoreAndForget(List<String> args)
      Stores the intersect of multiple sorted sets in a key.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.0.0
      See Also:
    • zlexcount

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> zlexcount(String arg0, String arg1, String arg2)
      Returns the number of members in a sorted set within a lexicographical range.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.8.9
      See Also:
      • ZLEXCOUNT
      • RedisAPI.zlexcount(String, String, String)
    • zlexcountAndAwait

      public io.vertx.redis.client.Response zlexcountAndAwait(String arg0, String arg1, String arg2)
      Returns the number of members in a sorted set within a lexicographical range.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.8.9
      See Also:
      • ZLEXCOUNT
      • RedisAPI.zlexcount(String, String, String)
    • zlexcountAndForget

      public RedisAPI zlexcountAndForget(String arg0, String arg1, String arg2)
      Returns the number of members in a sorted set within a lexicographical range.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.8.9
      See Also:
      • ZLEXCOUNT
      • RedisAPI.zlexcount(String, String, String)
    • zmpop

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> zmpop(List<String> args)
      Returns the highest- or lowest-scoring members from one or more sorted sets after removing them. Deletes the sorted set if the last member was popped.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 7.0.0
      See Also:
      • ZMPOP
      • RedisAPI.zmpop(List)
    • zmpopAndAwait

      public io.vertx.redis.client.Response zmpopAndAwait(List<String> args)
      Returns the highest- or lowest-scoring members from one or more sorted sets after removing them. Deletes the sorted set if the last member was popped.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 7.0.0
      See Also:
      • ZMPOP
      • RedisAPI.zmpop(List)
    • zmpopAndForget

      public RedisAPI zmpopAndForget(List<String> args)
      Returns the highest- or lowest-scoring members from one or more sorted sets after removing them. Deletes the sorted set if the last member was popped.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 7.0.0
      See Also:
      • ZMPOP
      • RedisAPI.zmpop(List)
    • zmscore

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> zmscore(List<String> args)
      Returns the score of one or more members in a sorted set.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 6.2.0
      See Also:
    • zmscoreAndAwait

      public io.vertx.redis.client.Response zmscoreAndAwait(List<String> args)
      Returns the score of one or more members in a sorted set.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 6.2.0
      See Also:
    • zmscoreAndForget

      public RedisAPI zmscoreAndForget(List<String> args)
      Returns the score of one or more members in a sorted set.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 6.2.0
      See Also:
    • zpopmax

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> zpopmax(List<String> args)
      Returns the highest-scoring members from a sorted set after removing them. Deletes the sorted set if the last member was popped.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 5.0.0
      See Also:
    • zpopmaxAndAwait

      public io.vertx.redis.client.Response zpopmaxAndAwait(List<String> args)
      Returns the highest-scoring members from a sorted set after removing them. Deletes the sorted set if the last member was popped.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 5.0.0
      See Also:
    • zpopmaxAndForget

      public RedisAPI zpopmaxAndForget(List<String> args)
      Returns the highest-scoring members from a sorted set after removing them. Deletes the sorted set if the last member was popped.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 5.0.0
      See Also:
    • zpopmin

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> zpopmin(List<String> args)
      Returns the lowest-scoring members from a sorted set after removing them. Deletes the sorted set if the last member was popped.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 5.0.0
      See Also:
    • zpopminAndAwait

      public io.vertx.redis.client.Response zpopminAndAwait(List<String> args)
      Returns the lowest-scoring members from a sorted set after removing them. Deletes the sorted set if the last member was popped.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 5.0.0
      See Also:
    • zpopminAndForget

      public RedisAPI zpopminAndForget(List<String> args)
      Returns the lowest-scoring members from a sorted set after removing them. Deletes the sorted set if the last member was popped.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 5.0.0
      See Also:
    • zrandmember

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> zrandmember(List<String> args)
      Returns one or more random members from a sorted set.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 6.2.0
      See Also:
    • zrandmemberAndAwait

      public io.vertx.redis.client.Response zrandmemberAndAwait(List<String> args)
      Returns one or more random members from a sorted set.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 6.2.0
      See Also:
    • zrandmemberAndForget

      public RedisAPI zrandmemberAndForget(List<String> args)
      Returns one or more random members from a sorted set.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 6.2.0
      See Also:
    • zrange

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> zrange(List<String> args)
      Returns members in a sorted set within a range of indexes.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.2.0
      See Also:
      • ZRANGE
      • RedisAPI.zrange(List)
    • zrangeAndAwait

      public io.vertx.redis.client.Response zrangeAndAwait(List<String> args)
      Returns members in a sorted set within a range of indexes.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.2.0
      See Also:
      • ZRANGE
      • RedisAPI.zrange(List)
    • zrangeAndForget

      public RedisAPI zrangeAndForget(List<String> args)
      Returns members in a sorted set within a range of indexes.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.2.0
      See Also:
      • ZRANGE
      • RedisAPI.zrange(List)
    • zrangebylex

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> zrangebylex(List<String> args)
      Deprecated.
      since Redis 6.2.0, replaced by: ZRANGE with the BYLEX argument
      Returns members in a sorted set within a lexicographical range.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.8.9
      See Also:
    • zrangebylexAndAwait

      public io.vertx.redis.client.Response zrangebylexAndAwait(List<String> args)
      Deprecated.
      since Redis 6.2.0, replaced by: ZRANGE with the BYLEX argument
      Returns members in a sorted set within a lexicographical range.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.8.9
      See Also:
    • zrangebylexAndForget

      public RedisAPI zrangebylexAndForget(List<String> args)
      Deprecated.
      since Redis 6.2.0, replaced by: ZRANGE with the BYLEX argument
      Returns members in a sorted set within a lexicographical range.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.8.9
      See Also:
    • zrangebyscore

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> zrangebyscore(List<String> args)
      Deprecated.
      since Redis 6.2.0, replaced by: ZRANGE with the BYSCORE argument
      Returns members in a sorted set within a range of scores.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.0.5
      See Also:
    • zrangebyscoreAndAwait

      public io.vertx.redis.client.Response zrangebyscoreAndAwait(List<String> args)
      Deprecated.
      since Redis 6.2.0, replaced by: ZRANGE with the BYSCORE argument
      Returns members in a sorted set within a range of scores.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.0.5
      See Also:
    • zrangebyscoreAndForget

      public RedisAPI zrangebyscoreAndForget(List<String> args)
      Deprecated.
      since Redis 6.2.0, replaced by: ZRANGE with the BYSCORE argument
      Returns members in a sorted set within a range of scores.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.0.5
      See Also:
    • zrangestore

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> zrangestore(List<String> args)
      Stores a range of members from sorted set in a key.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 6.2.0
      See Also:
    • zrangestoreAndAwait

      public io.vertx.redis.client.Response zrangestoreAndAwait(List<String> args)
      Stores a range of members from sorted set in a key.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 6.2.0
      See Also:
    • zrangestoreAndForget

      public RedisAPI zrangestoreAndForget(List<String> args)
      Stores a range of members from sorted set in a key.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 6.2.0
      See Also:
    • zrank

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> zrank(List<String> args)
      Returns the index of a member in a sorted set ordered by ascending scores.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.0.0
      See Also:
      • ZRANK
      • RedisAPI.zrank(List)
    • zrankAndAwait

      public io.vertx.redis.client.Response zrankAndAwait(List<String> args)
      Returns the index of a member in a sorted set ordered by ascending scores.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.0.0
      See Also:
      • ZRANK
      • RedisAPI.zrank(List)
    • zrankAndForget

      public RedisAPI zrankAndForget(List<String> args)
      Returns the index of a member in a sorted set ordered by ascending scores.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.0.0
      See Also:
      • ZRANK
      • RedisAPI.zrank(List)
    • zrank

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> zrank(String arg0, String arg1)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • RedisAPI.zrank(String, String)
    • zrankAndAwait

      public io.vertx.redis.client.Response zrankAndAwait(String arg0, String arg1)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
      • RedisAPI.zrank(String, String)
    • zrankAndForget

      public RedisAPI zrankAndForget(String arg0, String arg1)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • RedisAPI.zrank(String, String)
    • zrem

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> zrem(List<String> args)
      Removes one or more members from a sorted set. Deletes the sorted set if all members were removed.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.2.0
      See Also:
      • ZREM
      • RedisAPI.zrem(List)
    • zremAndAwait

      public io.vertx.redis.client.Response zremAndAwait(List<String> args)
      Removes one or more members from a sorted set. Deletes the sorted set if all members were removed.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.2.0
      See Also:
      • ZREM
      • RedisAPI.zrem(List)
    • zremAndForget

      public RedisAPI zremAndForget(List<String> args)
      Removes one or more members from a sorted set. Deletes the sorted set if all members were removed.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.2.0
      See Also:
      • ZREM
      • RedisAPI.zrem(List)
    • zremrangebylex

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> zremrangebylex(String arg0, String arg1, String arg2)
      Removes members in a sorted set within a lexicographical range. Deletes the sorted set if all members were removed.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.8.9
      See Also:
    • zremrangebylexAndAwait

      public io.vertx.redis.client.Response zremrangebylexAndAwait(String arg0, String arg1, String arg2)
      Removes members in a sorted set within a lexicographical range. Deletes the sorted set if all members were removed.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.8.9
      See Also:
    • zremrangebylexAndForget

      public RedisAPI zremrangebylexAndForget(String arg0, String arg1, String arg2)
      Removes members in a sorted set within a lexicographical range. Deletes the sorted set if all members were removed.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.8.9
      See Also:
    • zremrangebyrank

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> zremrangebyrank(String arg0, String arg1, String arg2)
      Removes members in a sorted set within a range of indexes. Deletes the sorted set if all members were removed.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.0.0
      See Also:
    • zremrangebyrankAndAwait

      public io.vertx.redis.client.Response zremrangebyrankAndAwait(String arg0, String arg1, String arg2)
      Removes members in a sorted set within a range of indexes. Deletes the sorted set if all members were removed.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.0.0
      See Also:
    • zremrangebyrankAndForget

      public RedisAPI zremrangebyrankAndForget(String arg0, String arg1, String arg2)
      Removes members in a sorted set within a range of indexes. Deletes the sorted set if all members were removed.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.0.0
      See Also:
    • zremrangebyscore

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> zremrangebyscore(String arg0, String arg1, String arg2)
      Removes members in a sorted set within a range of scores. Deletes the sorted set if all members were removed.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.2.0
      See Also:
    • zremrangebyscoreAndAwait

      public io.vertx.redis.client.Response zremrangebyscoreAndAwait(String arg0, String arg1, String arg2)
      Removes members in a sorted set within a range of scores. Deletes the sorted set if all members were removed.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.2.0
      See Also:
    • zremrangebyscoreAndForget

      public RedisAPI zremrangebyscoreAndForget(String arg0, String arg1, String arg2)
      Removes members in a sorted set within a range of scores. Deletes the sorted set if all members were removed.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.2.0
      See Also:
    • zrevrange

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> zrevrange(List<String> args)
      Deprecated.
      since Redis 6.2.0, replaced by: ZRANGE with the REV argument
      Returns members in a sorted set within a range of indexes in reverse order.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.2.0
      See Also:
    • zrevrangeAndAwait

      public io.vertx.redis.client.Response zrevrangeAndAwait(List<String> args)
      Deprecated.
      since Redis 6.2.0, replaced by: ZRANGE with the REV argument
      Returns members in a sorted set within a range of indexes in reverse order.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.2.0
      See Also:
    • zrevrangeAndForget

      public RedisAPI zrevrangeAndForget(List<String> args)
      Deprecated.
      since Redis 6.2.0, replaced by: ZRANGE with the REV argument
      Returns members in a sorted set within a range of indexes in reverse order.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.2.0
      See Also:
    • zrevrangebylex

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> zrevrangebylex(List<String> args)
      Deprecated.
      since Redis 6.2.0, replaced by: ZRANGE with the REV and BYLEX arguments
      Returns members in a sorted set within a lexicographical range in reverse order.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.8.9
      See Also:
    • zrevrangebylexAndAwait

      public io.vertx.redis.client.Response zrevrangebylexAndAwait(List<String> args)
      Deprecated.
      since Redis 6.2.0, replaced by: ZRANGE with the REV and BYLEX arguments
      Returns members in a sorted set within a lexicographical range in reverse order.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.8.9
      See Also:
    • zrevrangebylexAndForget

      public RedisAPI zrevrangebylexAndForget(List<String> args)
      Deprecated.
      since Redis 6.2.0, replaced by: ZRANGE with the REV and BYLEX arguments
      Returns members in a sorted set within a lexicographical range in reverse order.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.8.9
      See Also:
    • zrevrangebyscore

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> zrevrangebyscore(List<String> args)
      Deprecated.
      since Redis 6.2.0, replaced by: ZRANGE with the REV and BYSCORE arguments
      Returns members in a sorted set within a range of scores in reverse order.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.2.0
      See Also:
    • zrevrangebyscoreAndAwait

      public io.vertx.redis.client.Response zrevrangebyscoreAndAwait(List<String> args)
      Deprecated.
      since Redis 6.2.0, replaced by: ZRANGE with the REV and BYSCORE arguments
      Returns members in a sorted set within a range of scores in reverse order.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.2.0
      See Also:
    • zrevrangebyscoreAndForget

      public RedisAPI zrevrangebyscoreAndForget(List<String> args)
      Deprecated.
      since Redis 6.2.0, replaced by: ZRANGE with the REV and BYSCORE arguments
      Returns members in a sorted set within a range of scores in reverse order.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.2.0
      See Also:
    • zrevrank

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> zrevrank(List<String> args)
      Returns the index of a member in a sorted set ordered by descending scores.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.0.0
      See Also:
    • zrevrankAndAwait

      public io.vertx.redis.client.Response zrevrankAndAwait(List<String> args)
      Returns the index of a member in a sorted set ordered by descending scores.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.0.0
      See Also:
    • zrevrankAndForget

      public RedisAPI zrevrankAndForget(List<String> args)
      Returns the index of a member in a sorted set ordered by descending scores.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.0.0
      See Also:
    • zrevrank

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> zrevrank(String arg0, String arg1)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • RedisAPI.zrevrank(String, String)
    • zrevrankAndAwait

      public io.vertx.redis.client.Response zrevrankAndAwait(String arg0, String arg1)

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      See Also:
      • RedisAPI.zrevrank(String, String)
    • zrevrankAndForget

      public RedisAPI zrevrankAndForget(String arg0, String arg1)

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • RedisAPI.zrevrank(String, String)
    • zscan

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> zscan(List<String> args)
      Iterates over members and scores of a sorted set.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.8.0
      See Also:
      • ZSCAN
      • RedisAPI.zscan(List)
    • zscanAndAwait

      public io.vertx.redis.client.Response zscanAndAwait(List<String> args)
      Iterates over members and scores of a sorted set.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.8.0
      See Also:
      • ZSCAN
      • RedisAPI.zscan(List)
    • zscanAndForget

      public RedisAPI zscanAndForget(List<String> args)
      Iterates over members and scores of a sorted set.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.8.0
      See Also:
      • ZSCAN
      • RedisAPI.zscan(List)
    • zscore

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> zscore(String arg0, String arg1)
      Returns the score of a member in a sorted set.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 1.2.0
      See Also:
      • ZSCORE
      • RedisAPI.zscore(String, String)
    • zscoreAndAwait

      public io.vertx.redis.client.Response zscoreAndAwait(String arg0, String arg1)
      Returns the score of a member in a sorted set.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 1.2.0
      See Also:
      • ZSCORE
      • RedisAPI.zscore(String, String)
    • zscoreAndForget

      public RedisAPI zscoreAndForget(String arg0, String arg1)
      Returns the score of a member in a sorted set.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 1.2.0
      See Also:
      • ZSCORE
      • RedisAPI.zscore(String, String)
    • zunion

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> zunion(List<String> args)
      Returns the union of multiple sorted sets.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 6.2.0
      See Also:
      • ZUNION
      • RedisAPI.zunion(List)
    • zunionAndAwait

      public io.vertx.redis.client.Response zunionAndAwait(List<String> args)
      Returns the union of multiple sorted sets.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 6.2.0
      See Also:
      • ZUNION
      • RedisAPI.zunion(List)
    • zunionAndForget

      public RedisAPI zunionAndForget(List<String> args)
      Returns the union of multiple sorted sets.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 6.2.0
      See Also:
      • ZUNION
      • RedisAPI.zunion(List)
    • zunionstore

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.redis.client.Response> zunionstore(List<String> args)
      Stores the union of multiple sorted sets in a key.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Since:
      Redis 2.0.0
      See Also:
    • zunionstoreAndAwait

      public io.vertx.redis.client.Response zunionstoreAndAwait(List<String> args)
      Stores the union of multiple sorted sets in a key.

      Unlike the bare Vert.x variant, this method returns a Response. This method awaits indefinitely 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 operation result
      Since:
      Redis 2.0.0
      See Also:
    • zunionstoreAndForget

      public RedisAPI zunionstoreAndForget(List<String> args)
      Stores the union of multiple sorted sets in a key.

      Unlike the bare Vert.x variant, this method ignores the Response result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Since:
      Redis 2.0.0
      See Also:
    • api

      public static RedisAPI api(Redis client)
    • api

      public static RedisAPI api(RedisConnection connection)
    • close

      public void close()
    • newInstance

      public static RedisAPI newInstance(io.vertx.redis.client.RedisAPI delegate)
      Creates a new instance of the RedisAPI.
    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object
    • equals

      public boolean equals(Object o)
      Overrides:
      equals in class Object
    • toString

      public String toString()
      Overrides:
      toString in class Object