java.lang.Object
- io.quarkus.redis.runtime.datasource.AbstractRedisCommands
- - io.quarkus.redis.runtime.datasource.AbstractStreamCommands<K,F,V>
  - - io.quarkus.redis.runtime.datasource.ReactiveStreamCommandsImpl<K,F,V>

All Implemented Interfaces:: ReactiveRedisCommands, ReactiveStreamCommands<K,F,V>

public class ReactiveStreamCommandsImpl<K,F,V>
extends AbstractStreamCommands<K,F,V>
implements ReactiveStreamCommands<K,F,V>, ReactiveRedisCommands

Field Summary
- Fields inherited from class io.quarkus.redis.runtime.datasource.AbstractRedisCommands
  marshaller, redis

Constructor Summary

Constructors
Constructor	Description
`ReactiveStreamCommandsImpl(ReactiveRedisDataSourceImpl redis, Type k, Type f, Type v)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`protected ClaimedMessages<K,F,V>`	`decodeAsClaimedMessages(K key, io.vertx.mutiny.redis.client.Response r)`
`protected List<StreamMessage<K,F,V>>`	`decodeAsListOfMessagesFromXRead(io.vertx.mutiny.redis.client.Response r)`
`protected XPendingSummary`	`decodeAsXPendingSummary(io.vertx.mutiny.redis.client.Response r)`
`protected List<StreamMessage<K,F,V>>`	`decodeListOfMessages(K key, io.vertx.mutiny.redis.client.Response r)`
`protected List<PendingMessage>`	`decodeListOfPendingMessages(io.vertx.mutiny.redis.client.Response r)`
`protected List<StreamMessage<K,F,V>>`	`decodeMessageListPrefixedByKey(io.vertx.mutiny.redis.client.Response r)`
`(package private) Map<F,V>`	`decodeMessagePayload(io.vertx.mutiny.redis.client.Response response)`
`ReactiveRedisDataSource`	`getDataSource()`
`protected static String`	`getIdOrNull(io.vertx.mutiny.redis.client.Response r)`
`io.smallrye.mutiny.Uni<Integer>`	`xack(K key, String group, String... ids)`	Execute the command XACK.
`io.smallrye.mutiny.Uni<String>`	`xadd(K key, XAddArgs args, Map<F,V> payload)`	Execute the command XADD.
`io.smallrye.mutiny.Uni<String>`	`xadd(K key, Map<F,V> payload)`	Execute the command XADD.
`io.smallrye.mutiny.Uni<ClaimedMessages<K,F,V>>`	`xautoclaim(K key, String group, String consumer, Duration minIdleTime, String start)`	Execute the command XAUTOCLAIM.
`io.smallrye.mutiny.Uni<ClaimedMessages<K,F,V>>`	`xautoclaim(K key, String group, String consumer, Duration minIdleTime, String start, int count)`	Execute the command XAUTOCLAIM.
`io.smallrye.mutiny.Uni<ClaimedMessages<K,F,V>>`	`xautoclaim(K key, String group, String consumer, Duration minIdleTime, String start, int count, boolean justId)`	Execute the command XAUTOCLAIM.
`io.smallrye.mutiny.Uni<List<StreamMessage<K,F,V>>>`	`xclaim(K key, String group, String consumer, Duration minIdleTime, XClaimArgs args, String... id)`	Execute the command XCLAIM.
`io.smallrye.mutiny.Uni<List<StreamMessage<K,F,V>>>`	`xclaim(K key, String group, String consumer, Duration minIdleTime, String... id)`	Execute the command XCLAIM.
`io.smallrye.mutiny.Uni<Integer>`	`xdel(K key, String... id)`	Execute the command XDEL.
`io.smallrye.mutiny.Uni<Void>`	`xgroupCreate(K key, String groupname, String from)`	Execute the command XGROUP CREATE.
`io.smallrye.mutiny.Uni<Void>`	`xgroupCreate(K key, String groupname, String from, XGroupCreateArgs args)`	Execute the command XGROUP CREATE.
`io.smallrye.mutiny.Uni<Boolean>`	`xgroupCreateConsumer(K key, String groupname, String consumername)`	Execute the command XGROUP CREATECONSUMER.
`io.smallrye.mutiny.Uni<Long>`	`xgroupDelConsumer(K key, String groupname, String consumername)`	Execute the command XGROUP DELCONSUMER.
`io.smallrye.mutiny.Uni<Boolean>`	`xgroupDestroy(K key, String groupname)`	Execute the command XGROUP DESTROY.
`io.smallrye.mutiny.Uni<Void>`	`xgroupSetId(K key, String groupname, String from)`	Execute the command XGROUP SETID.
`io.smallrye.mutiny.Uni<Void>`	`xgroupSetId(K key, String groupname, String from, XGroupSetIdArgs args)`	Execute the command XGROUP SETID.
`io.smallrye.mutiny.Uni<Long>`	`xlen(K key)`	Execute the command XLEN.
`io.smallrye.mutiny.Uni<XPendingSummary>`	`xpending(K key, String group)`	Execute the command XPENDING.
`io.smallrye.mutiny.Uni<List<PendingMessage>>`	`xpending(K key, String group, StreamRange range, int count)`	Execute the command XPENDING.
`io.smallrye.mutiny.Uni<List<PendingMessage>>`	`xpending(K key, String group, StreamRange range, int count, XPendingArgs args)`	Execute the command XPENDING.
`io.smallrye.mutiny.Uni<List<StreamMessage<K,F,V>>>`	`xrange(K key, StreamRange range)`	Execute the command XRANGE.
`io.smallrye.mutiny.Uni<List<StreamMessage<K,F,V>>>`	`xrange(K key, StreamRange range, int count)`	Execute the command XRANGE.
`io.smallrye.mutiny.Uni<List<StreamMessage<K,F,V>>>`	`xread(Map<K,String> lastIdsPerStream)`	Execute the command XREAD.
`io.smallrye.mutiny.Uni<List<StreamMessage<K,F,V>>>`	`xread(Map<K,String> lastIdsPerStream, XReadArgs args)`	Execute the command XREAD.
`io.smallrye.mutiny.Uni<List<StreamMessage<K,F,V>>>`	`xread(K key, String id)`	Execute the command XREAD.
`io.smallrye.mutiny.Uni<List<StreamMessage<K,F,V>>>`	`xread(K key, String id, XReadArgs args)`	Execute the command XREAD.
`io.smallrye.mutiny.Uni<List<StreamMessage<K,F,V>>>`	`xreadgroup(String group, String consumer, Map<K,String> lastIdsPerStream)`	Execute the command XREADGROUP.
`io.smallrye.mutiny.Uni<List<StreamMessage<K,F,V>>>`	`xreadgroup(String group, String consumer, Map<K,String> lastIdsPerStream, XReadGroupArgs args)`	Execute the command XREADGROUP.
`io.smallrye.mutiny.Uni<List<StreamMessage<K,F,V>>>`	`xreadgroup(String group, String consumer, K key, String id)`	Execute the command XREADGROUP.
`io.smallrye.mutiny.Uni<List<StreamMessage<K,F,V>>>`	`xreadgroup(String group, String consumer, K key, String id, XReadGroupArgs args)`	Execute the command XREADGROUP.
`io.smallrye.mutiny.Uni<List<StreamMessage<K,F,V>>>`	`xrevrange(K key, StreamRange range)`	Execute the command XRANGE.
`io.smallrye.mutiny.Uni<List<StreamMessage<K,F,V>>>`	`xrevrange(K key, StreamRange range, int count)`	Execute the command XREVRANGE.
`io.smallrye.mutiny.Uni<Long>`	`xtrim(K key, XTrimArgs args)`	Execute the command XTRIM.
`io.smallrye.mutiny.Uni<Long>`	`xtrim(K key, String threshold)`	Execute the command XTRIM.

Methods inherited from class io.quarkus.redis.runtime.datasource.AbstractStreamCommands
_xack, _xadd, _xadd, _xautoclaim, _xautoclaim, _xautoclaim, _xclaim, _xclaim, _xdel, _xgroupCreate, _xgroupCreate, _xgroupCreateConsumer, _xgroupDelConsumer, _xgroupDestroy, _xgroupSetId, _xgroupSetId, _xlen, _xpending, _xpending, _xrange, _xrange, _xread, _xread, _xread, _xread, _xreadgroup, _xreadgroup, _xreadgroup, _xreadgroup, _xrevrange, _xrevrange, _xtrim

Methods inherited from class io.quarkus.redis.runtime.datasource.AbstractRedisCommands
execute, isMap

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - ReactiveStreamCommandsImpl
```
public ReactiveStreamCommandsImpl(ReactiveRedisDataSourceImpl redis,
                                  Type k,
                                  Type f,
                                  Type v)
```
- Method Detail
  - getDataSource
```
public ReactiveRedisDataSource getDataSource()
```
    Specified by:
    
    getDataSource in interface ReactiveRedisCommands
    
    Returns:
    
    the data source.
  - xack
```
public io.smallrye.mutiny.Uni<Integer> xack(K key,
                                            String group,
                                            String... ids)
```
    Description copied from interface: ReactiveStreamCommands
    
    Execute the command XACK. Summary: Marks a pending message as correctly processed, effectively removing it from the pending entries list of the consumer group. Return value of the command is the number of messages successfully acknowledged, that is, the IDs we were actually able to resolve in the PEL.
    The XACK command removes one or multiple messages from the Pending Entries List (PEL) of a stream consumer group. A message is pending, and as such stored inside the PEL, when it was delivered to some consumer, normally as a side effect of calling XREADGROUP, or when a consumer took ownership of a message calling XCLAIM. The pending message was delivered to some consumer but the server is yet not sure it was processed at least once. So new calls to XREADGROUP to grab the messages history for a consumer (for instance using an ID of 0), will return such message. Similarly, the pending message will be listed by the XPENDING command, that inspects the PEL.
    Once a consumer successfully processes a message, it should call XACK so that such message does not get processed again, and as a side effect, the PEL entry about this message is also purged, releasing memory from the Redis server.
    Group: stream Requires Redis 5.0.0+
    
    Specified by:
    
    xack in interface ReactiveStreamCommands<K,F,V>
    
    Parameters:
    
    key - the key
    
    group - the name of the consumer group
    
    ids - the message ids to acknowledge
    
    Returns:
    
    A Uni emitting the number of acknowledged messages. Certain message IDs may no longer be part of the PEL (for example because they have already been acknowledged), and XACK will not count them as successfully acknowledged.
  - xadd
```
public io.smallrye.mutiny.Uni<String> xadd(K key,
                                           Map<F,V> payload)
```
    Description copied from interface: ReactiveStreamCommands
    
    Execute the command XADD. Summary: Appends the specified stream entry to the stream at the specified key. If the key does not exist, as a side effect of running this command the key is created with a stream value. The creation of stream's key can be disabled with the NOMKSTREAM option.
    An entry is composed of a list of field-value pairs. The field-value pairs are stored in the same order they are given by the user. Commands that read the stream, such as XRANGE or XREAD, are guaranteed to return the fields and values exactly in the same order they were added by XADD.
    XADD is the only Redis command that can add data to a stream, but there are other commands, such as XDEL and XTRIM, that are able to remove data from a stream.
    Group: stream Requires Redis 5.0.0+
    
    Specified by:
    
    xadd in interface ReactiveStreamCommands<K,F,V>
    
    Parameters:
    
    key - the key
    
    payload - the payload to write to the stream, must not be null
    
    Returns:
    
    A Uni emitting the id of the added message
  - getIdOrNull
```
protected static String getIdOrNull(io.vertx.mutiny.redis.client.Response r)
```
  - xadd
```
public io.smallrye.mutiny.Uni<String> xadd(K key,
                                           XAddArgs args,
                                           Map<F,V> payload)
```
    Description copied from interface: ReactiveStreamCommands
    
    Execute the command XADD. Summary: Appends the specified stream entry to the stream at the specified key. If the key does not exist, as a side effect of running this command the key is created with a stream value. The creation of stream's key can be disabled with the NOMKSTREAM option.
    An entry is composed of a list of field-value pairs. The field-value pairs are stored in the same order they are given by the user. Commands that read the stream, such as XRANGE or XREAD, are guaranteed to return the fields and values exactly in the same order they were added by XADD.
    XADD is the only Redis command that can add data to a stream, but there are other commands, such as XDEL and XTRIM, that are able to remove data from a stream.
    Group: stream Requires Redis 5.0.0+
    
    Specified by:
    
    xadd in interface ReactiveStreamCommands<K,F,V>
    
    Parameters:
    
    key - the key
    
    args - the extra parameters
    
    payload - the payload to write to the stream, must not be null
    
    Returns:
    
    A Uni emitting the id of the added message
  - xautoclaim
```
public io.smallrye.mutiny.Uni<ClaimedMessages<K,F,V>> xautoclaim(K key,
                                                                             String group,
                                                                             String consumer,
                                                                             Duration minIdleTime,
                                                                             String start,
                                                                             int count)
```
    Description copied from interface: ReactiveStreamCommands
    
    Execute the command XAUTOCLAIM. Summary: Changes (or acquires) ownership of messages in a consumer group, as if the messages were delivered to the specified consumer.
    This command transfers ownership of pending stream entries that match the specified criteria. Conceptually, XAUTOCLAIM is equivalent to calling XPENDING and then XCLAIM, but provides a more straightforward way to deal with message delivery failures via SCAN-like semantics.
    Like XCLAIM, the command operates on the stream entries at key and in the context of the provided group. It transfers ownership to @{code consumer} of messages pending for more than min-idle-time milliseconds and having an equal or greater ID than start.
    Group: stream Requires Redis 6.2.0+
    
    Specified by:
    
    xautoclaim in interface ReactiveStreamCommands<K,F,V>
    
    Parameters:
    
    key - key the key
    
    group - string the consumer group
    
    consumer - string the consumer id
    
    minIdleTime - the min pending time of the message to claim
    
    start - the min id of the message to claim
    
    count - the upper limit of the number of entries to claim, default is 100.
    
    Returns:
    
    A Uni emitting the claimed messages
  - decodeAsClaimedMessages
```
protected ClaimedMessages<K,F,V> decodeAsClaimedMessages(K key,
                                                                     io.vertx.mutiny.redis.client.Response r)
```
  - decodeMessageListPrefixedByKey
```
protected List<StreamMessage<K,F,V>> decodeMessageListPrefixedByKey(io.vertx.mutiny.redis.client.Response r)
```
  - decodeMessagePayload
```
Map<F,V> decodeMessagePayload(io.vertx.mutiny.redis.client.Response response)
```
  - xautoclaim
```
public io.smallrye.mutiny.Uni<ClaimedMessages<K,F,V>> xautoclaim(K key,
                                                                             String group,
                                                                             String consumer,
                                                                             Duration minIdleTime,
                                                                             String start)
```
    Description copied from interface: ReactiveStreamCommands
    
    Execute the command XAUTOCLAIM. Summary: Changes (or acquires) ownership of messages in a consumer group, as if the messages were delivered to the specified consumer.
    This command transfers ownership of pending stream entries that match the specified criteria. Conceptually, XAUTOCLAIM is equivalent to calling XPENDING and then XCLAIM, but provides a more straightforward way to deal with message delivery failures via SCAN-like semantics.
    Like XCLAIM, the command operates on the stream entries at key and in the context of the provided group. It transfers ownership to @{code consumer} of messages pending for more than min-idle-time milliseconds and having an equal or greater ID than start.
    Group: stream Requires Redis 6.2.0+
    
    Specified by:
    
    xautoclaim in interface ReactiveStreamCommands<K,F,V>
    
    Parameters:
    
    key - key the key
    
    group - string the consumer group
    
    consumer - string the consumer id
    
    minIdleTime - the min pending time of the message to claim
    
    start - the min id of the message to claim
    
    Returns:
    
    A Uni emitting the claimed messages
  - xautoclaim
```
public io.smallrye.mutiny.Uni<ClaimedMessages<K,F,V>> xautoclaim(K key,
                                                                             String group,
                                                                             String consumer,
                                                                             Duration minIdleTime,
                                                                             String start,
                                                                             int count,
                                                                             boolean justId)
```
    Description copied from interface: ReactiveStreamCommands
    
    Execute the command XAUTOCLAIM. Summary: Changes (or acquires) ownership of messages in a consumer group, as if the messages were delivered to the specified consumer.
    This command transfers ownership of pending stream entries that match the specified criteria. Conceptually, XAUTOCLAIM is equivalent to calling XPENDING and then XCLAIM, but provides a more straightforward way to deal with message delivery failures via SCAN-like semantics.
    Like XCLAIM, the command operates on the stream entries at key and in the context of the provided group. It transfers ownership to @{code consumer} of messages pending for more than min-idle-time milliseconds and having an equal or greater ID than start.
    Group: stream Requires Redis 6.2.0+
    
    Specified by:
    
    xautoclaim in interface ReactiveStreamCommands<K,F,V>
    
    Parameters:
    
    key - key the key
    
    group - string the consumer group
    
    consumer - string the consumer id
    
    minIdleTime - the min pending time of the message to claim
    
    start - the min id of the message to claim
    
    count - the upper limit of the number of entries to claim, default is 100.
    
    justId - if true the returned structure would only contain the id of the messages and not the payloads
    
    Returns:
    
    A Uni emitting the claimed messages
  - xclaim
```
public io.smallrye.mutiny.Uni<List<StreamMessage<K,F,V>>> xclaim(K key,
                                                                             String group,
                                                                             String consumer,
                                                                             Duration minIdleTime,
                                                                             String... id)
```
    Description copied from interface: ReactiveStreamCommands
    
    Execute the command XCLAIM. Summary: In the context of a stream consumer group, this command changes the ownership of a pending message, so that the new owner is the consumer specified as the command argument.
    Group: stream Requires Redis 5.0.0+
    
    Specified by:
    
    xclaim in interface ReactiveStreamCommands<K,F,V>
    
    Parameters:
    
    key - key the key
    
    group - string the consumer group
    
    consumer - string the consumer id
    
    minIdleTime - the min pending time of the message to claim
    
    id - the message ids to claim, must not be empty, must not contain null
    
    Returns:
    
    A Uni emitting the claimed messages
  - xclaim
```
public io.smallrye.mutiny.Uni<List<StreamMessage<K,F,V>>> xclaim(K key,
                                                                             String group,
                                                                             String consumer,
                                                                             Duration minIdleTime,
                                                                             XClaimArgs args,
                                                                             String... id)
```
    Description copied from interface: ReactiveStreamCommands
    
    Execute the command XCLAIM. Summary: In the context of a stream consumer group, this command changes the ownership of a pending message, so that the new owner is the consumer specified as the command argument.
    Group: stream Requires Redis 5.0.0+
    
    Specified by:
    
    xclaim in interface ReactiveStreamCommands<K,F,V>
    
    Parameters:
    
    key - key the key
    
    group - string the consumer group
    
    consumer - string the consumer id
    
    minIdleTime - the min pending time of the message to claim
    
    args - the extra command parameters
    
    id - the message ids to claim, must not be empty, must not contain null
    
    Returns:
    
    A Uni emitting the claimed messages
  - xdel
```
public io.smallrye.mutiny.Uni<Integer> xdel(K key,
                                            String... id)
```
    Description copied from interface: ReactiveStreamCommands
    
    Execute the command XDEL. Summary: Removes the specified entries from a stream, and returns the number of entries deleted. This number may be less than the number of IDs passed to the command in the case where some of the specified IDs do not exist in the stream.
    Group: stream Requires Redis 5.0.0+
    
    Specified by:
    
    xdel in interface ReactiveStreamCommands<K,F,V>
    
    Parameters:
    
    key - key the key
    
    id - the message ids, must not be empty, must not contain null
    
    Returns:
    
    A Uni emitting the number of deleted messages
  - xgroupCreate
```
public io.smallrye.mutiny.Uni<Void> xgroupCreate(K key,
                                                 String groupname,
                                                 String from)
```
    Description copied from interface: ReactiveStreamCommands
    
    Execute the command XGROUP CREATE. Summary: Create a new consumer group uniquely identified by groupname for the stream stored at key
    Group: stream Requires Redis 5.0.0+
    
    Specified by:
    
    xgroupCreate in interface ReactiveStreamCommands<K,F,V>
    
    Parameters:
    
    key - key the key
    
    groupname - the name of the group, must be unique, and not null
    
    from - the last delivered entry in the stream from the new group's perspective. The special ID $ is the ID of the last entry in the stream, but you can substitute it with any valid ID.
    
    Returns:
    
    A Uni emitting null when the operation completes
  - xgroupCreate
```
public io.smallrye.mutiny.Uni<Void> xgroupCreate(K key,
                                                 String groupname,
                                                 String from,
                                                 XGroupCreateArgs args)
```
    Description copied from interface: ReactiveStreamCommands
    
    Execute the command XGROUP CREATE. Summary: Create a new consumer group uniquely identified by groupname for the stream stored at key
    Group: stream Requires Redis 5.0.0+
    
    Specified by:
    
    xgroupCreate in interface ReactiveStreamCommands<K,F,V>
    
    Parameters:
    
    key - key the key
    
    groupname - the name of the group, must be unique, and not null
    
    from - the last delivered entry in the stream from the new group's perspective. The special ID $ is the ID of the last entry in the stream, but you can substitute it with any valid ID.
    
    args - the extra command parameters
    
    Returns:
    
    A Uni emitting null when the operation completes
  - xgroupCreateConsumer
```
public io.smallrye.mutiny.Uni<Boolean> xgroupCreateConsumer(K key,
                                                            String groupname,
                                                            String consumername)
```
    Description copied from interface: ReactiveStreamCommands
    
    Execute the command XGROUP CREATECONSUMER. Summary: Create a consumer named consumername in the consumer group groupname of the stream that's stored at key.
    Consumers are also created automatically whenever an operation, such as XREADGROUP, references a consumer that doesn't exist.
    Group: stream Requires Redis 6.2.0+
    
    Specified by:
    
    xgroupCreateConsumer in interface ReactiveStreamCommands<K,F,V>
    
    Parameters:
    
    key - key the key
    
    groupname - the name of the group, must be unique, and not null
    
    consumername - the consumer name
    
    Returns:
    
    A Uni emitting true if the consumer was created, false otherwise.
  - xgroupDelConsumer
```
public io.smallrye.mutiny.Uni<Long> xgroupDelConsumer(K key,
                                                      String groupname,
                                                      String consumername)
```
    Description copied from interface: ReactiveStreamCommands
    
    Execute the command XGROUP DELCONSUMER. Summary: Deletes a consumer from the consumer group.
    Group: stream Requires Redis 5.0.0+
    
    Specified by:
    
    xgroupDelConsumer in interface ReactiveStreamCommands<K,F,V>
    
    Parameters:
    
    key - key the key
    
    groupname - the name of the group, must be unique, and not null
    
    consumername - the consumer name
    
    Returns:
    
    A Uni emitting the number of pending messages that the consumer had before it was deleted
  - xgroupDestroy
```
public io.smallrye.mutiny.Uni<Boolean> xgroupDestroy(K key,
                                                     String groupname)
```
    Description copied from interface: ReactiveStreamCommands
    
    Execute the command XGROUP DESTROY. Summary: Completely destroys a consumer group. The consumer group will be destroyed even if there are active consumers, and pending messages, so make sure to call this command only when really needed.
    Group: stream Requires Redis 5.0.0+
    
    Specified by:
    
    xgroupDestroy in interface ReactiveStreamCommands<K,F,V>
    
    Parameters:
    
    key - key the key
    
    groupname - the name of the group, must be unique, and not null
    
    Returns:
    
    A Uni emitting true if the consumer group was destroyed, false otherwise.
  - xgroupSetId
```
public io.smallrye.mutiny.Uni<Void> xgroupSetId(K key,
                                                String groupname,
                                                String from)
```
    Description copied from interface: ReactiveStreamCommands
    
    Execute the command XGROUP SETID. Summary: Set the last delivered ID for a consumer group.
    Group: stream Requires Redis 5.0.0+
    
    Specified by:
    
    xgroupSetId in interface ReactiveStreamCommands<K,F,V>
    
    Parameters:
    
    key - key the key
    
    groupname - the name of the group, must be unique, and not null
    
    from - the last delivered entry in the stream from the new group's perspective. The special ID $ is the ID of the last entry in the stream, but you can substitute it with any valid ID.
    
    Returns:
    
    A Uni emitting null when the operation completes
  - xgroupSetId
```
public io.smallrye.mutiny.Uni<Void> xgroupSetId(K key,
                                                String groupname,
                                                String from,
                                                XGroupSetIdArgs args)
```
    Description copied from interface: ReactiveStreamCommands
    
    Execute the command XGROUP SETID. Summary: Set the last delivered ID for a consumer group.
    Group: stream Requires Redis 5.0.0+
    
    Specified by:
    
    xgroupSetId in interface ReactiveStreamCommands<K,F,V>
    
    Parameters:
    
    key - key the key
    
    groupname - the name of the group, must be unique, and not null
    
    from - the last delivered entry in the stream from the new group's perspective. The special ID $ is the ID of the last entry in the stream, but you can substitute it with any valid ID.
    
    args - the extra command parameters
    
    Returns:
    
    A Uni emitting null when the operation completes
  - xlen
```
public io.smallrye.mutiny.Uni<Long> xlen(K key)
```
    Description copied from interface: ReactiveStreamCommands
    
    Execute the command XLEN. Summary: Returns the number of entries inside a stream.
    Group: stream Requires Redis 5.0.0+
    
    Specified by:
    
    xlen in interface ReactiveStreamCommands<K,F,V>
    
    Parameters:
    
    key - key the key
    
    Returns:
    
    A Uni emitting the number of messages in the stream
  - xrange
```
public io.smallrye.mutiny.Uni<List<StreamMessage<K,F,V>>> xrange(K key,
                                                                             StreamRange range,
                                                                             int count)
```
    Description copied from interface: ReactiveStreamCommands
    
    Execute the command XRANGE. Summary: The command returns the stream entries matching a given range of IDs.
    Group: stream Requires Redis 5.0.0+
    
    Specified by:
    
    xrange in interface ReactiveStreamCommands<K,F,V>
    
    Parameters:
    
    key - key the key
    
    range - the range, must not be null
    
    count - the max number of entries to return
    
    Returns:
    
    A Uni emitting a list containing the messages from the given range.
  - xrange
```
public io.smallrye.mutiny.Uni<List<StreamMessage<K,F,V>>> xrange(K key,
                                                                             StreamRange range)
```
    Description copied from interface: ReactiveStreamCommands
    
    Execute the command XRANGE. Summary: The command returns the stream entries matching a given range of IDs.
    Group: stream Requires Redis 5.0.0+
    
    Specified by:
    
    xrange in interface ReactiveStreamCommands<K,F,V>
    
    Parameters:
    
    key - key the key
    
    range - the range, must not be null
    
    Returns:
    
    A Uni emitting a list containing the messages from the given range.
  - decodeListOfMessages
```
protected List<StreamMessage<K,F,V>> decodeListOfMessages(K key,
                                                                      io.vertx.mutiny.redis.client.Response r)
```
  - xread
```
public io.smallrye.mutiny.Uni<List<StreamMessage<K,F,V>>> xread(K key,
                                                                            String id)
```
    Description copied from interface: ReactiveStreamCommands
    
    Execute the command XREAD. Summary: Read data from one or multiple streams, only returning entries with an ID greater than the last received ID reported by the caller. This command has an option to block if items are not available, in a similar fashion to BRPOP or BZPOPMIN and others.
    Group: stream Requires Redis 5.0.0+
    
    Specified by:
    
    xread in interface ReactiveStreamCommands<K,F,V>
    
    Parameters:
    
    key - key the key of the stream
    
    id - the last read id
    
    Returns:
    
    A Uni emitting a list containing the messages.
  - decodeAsListOfMessagesFromXRead
```
protected List<StreamMessage<K,F,V>> decodeAsListOfMessagesFromXRead(io.vertx.mutiny.redis.client.Response r)
```
  - xread
```
public io.smallrye.mutiny.Uni<List<StreamMessage<K,F,V>>> xread(Map<K,String> lastIdsPerStream)
```
    Description copied from interface: ReactiveStreamCommands
    
    Execute the command XREAD. Summary: Read data from one or multiple streams, only returning entries with an ID greater than the last received ID reported by the caller. This command has an option to block if items are not available, in a similar fashion to BRPOP or BZPOPMIN and others.
    Group: stream Requires Redis 5.0.0+
    
    Specified by:
    
    xread in interface ReactiveStreamCommands<K,F,V>
    
    Parameters:
    
    lastIdsPerStream - the map of key -> id indicating the last received id per stream to read
    
    Returns:
    
    A Uni emitting a list containing the messages.
  - xread
```
public io.smallrye.mutiny.Uni<List<StreamMessage<K,F,V>>> xread(K key,
                                                                            String id,
                                                                            XReadArgs args)
```
    Description copied from interface: ReactiveStreamCommands
    
    Execute the command XREAD. Summary: Read data from one or multiple streams, only returning entries with an ID greater than the last received ID reported by the caller. This command has an option to block if items are not available, in a similar fashion to BRPOP or BZPOPMIN and others.
    Group: stream Requires Redis 5.0.0+
    
    Specified by:
    
    xread in interface ReactiveStreamCommands<K,F,V>
    
    Parameters:
    
    key - key the key of the stream
    
    id - the last read id
    
    args - the extra parameter
    
    Returns:
    
    A Uni emitting a list containing the messages.
  - xread
```
public io.smallrye.mutiny.Uni<List<StreamMessage<K,F,V>>> xread(Map<K,String> lastIdsPerStream,
                                                                            XReadArgs args)
```
    Description copied from interface: ReactiveStreamCommands
    
    Execute the command XREAD. Summary: Read data from one or multiple streams, only returning entries with an ID greater than the last received ID reported by the caller. This command has an option to block if items are not available, in a similar fashion to BRPOP or BZPOPMIN and others.
    Group: stream Requires Redis 5.0.0+
    
    Specified by:
    
    xread in interface ReactiveStreamCommands<K,F,V>
    
    Parameters:
    
    lastIdsPerStream - the map of key -> id indicating the last received id per stream to read
    
    args - the extra parameter
    
    Returns:
    
    A Uni emitting a list containing the messages.
  - xreadgroup
```
public io.smallrye.mutiny.Uni<List<StreamMessage<K,F,V>>> xreadgroup(String group,
                                                                                 String consumer,
                                                                                 K key,
                                                                                 String id)
```
    Description copied from interface: ReactiveStreamCommands
    
    Execute the command XREADGROUP. Summary: The XREADGROUP command is a special version of the XREAD command with support for consumer groups.
    Group: stream Requires Redis 5.0.0+
    
    Specified by:
    
    xreadgroup in interface ReactiveStreamCommands<K,F,V>
    
    Parameters:
    
    group - the group name
    
    consumer - the consumer name
    
    key - the stream key
    
    id - the last read id
    
    Returns:
    
    A Uni emitting a list containing the messages.
  - xreadgroup
```
public io.smallrye.mutiny.Uni<List<StreamMessage<K,F,V>>> xreadgroup(String group,
                                                                                 String consumer,
                                                                                 Map<K,String> lastIdsPerStream)
```
    Description copied from interface: ReactiveStreamCommands
    
    Execute the command XREADGROUP. Summary: The XREADGROUP command is a special version of the XREAD command with support for consumer groups.
    Group: stream Requires Redis 5.0.0+
    
    Specified by:
    
    xreadgroup in interface ReactiveStreamCommands<K,F,V>
    
    Parameters:
    
    group - the group name
    
    consumer - the consumer name
    
    lastIdsPerStream - the map of key -> id indicating the last received id per stream to read
    
    Returns:
    
    A Uni emitting a list containing the messages.
  - xreadgroup
```
public io.smallrye.mutiny.Uni<List<StreamMessage<K,F,V>>> xreadgroup(String group,
                                                                                 String consumer,
                                                                                 K key,
                                                                                 String id,
                                                                                 XReadGroupArgs args)
```
    Description copied from interface: ReactiveStreamCommands
    
    Execute the command XREADGROUP. Summary: The XREADGROUP command is a special version of the XREAD command with support for consumer groups.
    Group: stream Requires Redis 5.0.0+
    
    Specified by:
    
    xreadgroup in interface ReactiveStreamCommands<K,F,V>
    
    Parameters:
    
    group - the group name
    
    consumer - the consumer name
    
    key - the stream key
    
    id - the last read id
    
    args - the extra parameter
    
    Returns:
    
    A Uni emitting a list containing the messages.
  - xreadgroup
```
public io.smallrye.mutiny.Uni<List<StreamMessage<K,F,V>>> xreadgroup(String group,
                                                                                 String consumer,
                                                                                 Map<K,String> lastIdsPerStream,
                                                                                 XReadGroupArgs args)
```
    Description copied from interface: ReactiveStreamCommands
    
    Execute the command XREADGROUP. Summary: The XREADGROUP command is a special version of the XREAD command with support for consumer groups.
    Group: stream Requires Redis 5.0.0+
    
    Specified by:
    
    xreadgroup in interface ReactiveStreamCommands<K,F,V>
    
    Parameters:
    
    group - the group name
    
    consumer - the consumer name
    
    lastIdsPerStream - the map of key -> id indicating the last received id per stream to read
    
    args - the extra parameter
    
    Returns:
    
    A Uni emitting a list containing the messages.
  - xrevrange
```
public io.smallrye.mutiny.Uni<List<StreamMessage<K,F,V>>> xrevrange(K key,
                                                                                StreamRange range,
                                                                                int count)
```
    Description copied from interface: ReactiveStreamCommands
    
    Execute the command XREVRANGE. Summary: This command is exactly like XRANGE, but with the notable difference of returning the entries in reverse order, and also taking the start-end range in reverse order: in XREVRANGE you need to state the end ID and later the start ID, and the command will produce all the element between (or exactly like) the two IDs, starting from the end side.
    Group: stream Requires Redis 5.0.0+
    
    Specified by:
    
    xrevrange in interface ReactiveStreamCommands<K,F,V>
    
    Parameters:
    
    key - key the key
    
    range - the range, must not be null
    
    count - the max number of entries to return
    
    Returns:
    
    A Uni emitting a list containing the messages from the given range.
  - xrevrange
```
public io.smallrye.mutiny.Uni<List<StreamMessage<K,F,V>>> xrevrange(K key,
                                                                                StreamRange range)
```
    Description copied from interface: ReactiveStreamCommands
    
    Execute the command XRANGE. Summary: This command is exactly like XRANGE, but with the notable difference of returning the entries in reverse order, and also taking the start-end range in reverse order: in XREVRANGE you need to state the end ID and later the start ID, and the command will produce all the element between (or exactly like) the two IDs, starting from the end side.
    Group: stream Requires Redis 5.0.0+
    
    Specified by:
    
    xrevrange in interface ReactiveStreamCommands<K,F,V>
    
    Parameters:
    
    key - key the key
    
    range - the range, must not be null
    
    Returns:
    
    A Uni emitting a list containing the messages from the given range.
  - xtrim
```
public io.smallrye.mutiny.Uni<Long> xtrim(K key,
                                          String threshold)
```
    Description copied from interface: ReactiveStreamCommands
    
    Execute the command XTRIM. Summary: Trims the stream by evicting older entries (entries with lower IDs) if needed.
    Group: stream Requires Redis 5.0.0+
    
    Specified by:
    
    xtrim in interface ReactiveStreamCommands<K,F,V>
    
    Parameters:
    
    key - the key
    
    threshold - the threshold
    
    Returns:
    
    A Uni emitting the number of entries deleted from the stream
  - xtrim
```
public io.smallrye.mutiny.Uni<Long> xtrim(K key,
                                          XTrimArgs args)
```
    Description copied from interface: ReactiveStreamCommands
    
    Execute the command XTRIM. Summary: Trims the stream by evicting older entries (entries with lower IDs) if needed.
    Group: stream Requires Redis 5.0.0+
    
    Specified by:
    
    xtrim in interface ReactiveStreamCommands<K,F,V>
    
    Parameters:
    
    key - the key
    
    args - the extra parameters
    
    Returns:
    
    A Uni emitting the number of entries deleted from the stream
  - xpending
```
public io.smallrye.mutiny.Uni<XPendingSummary> xpending(K key,
                                                        String group)
```
    Description copied from interface: ReactiveStreamCommands
    
    Execute the command XPENDING. Summary: The XPENDING command is the interface to inspect the list of pending messages, and is as thus a very important command in order to observe and understand what is happening with a streams consumer groups: what clients are active, what messages are pending to be consumed, or to see if there are idle messages.
    Group: stream Requires Redis 5.0.0+
    This variant of xpending uses the summary form.
    
    Specified by:
    
    xpending in interface ReactiveStreamCommands<K,F,V>
    
    Parameters:
    
    key - the key
    
    group - the group
    
    Returns:
    
    A Uni emitting the xpending summary
  - xpending
```
public io.smallrye.mutiny.Uni<List<PendingMessage>> xpending(K key,
                                                             String group,
                                                             StreamRange range,
                                                             int count)
```
    Description copied from interface: ReactiveStreamCommands
    
    Execute the command XPENDING. Summary: The XPENDING command is the interface to inspect the list of pending messages, and is as thus a very important command in order to observe and understand what is happening with a streams consumer groups: what clients are active, what messages are pending to be consumed, or to see if there are idle messages.
    Group: stream Requires Redis 5.0.0+
    This variant of xpending uses the extended form.
    
    Specified by:
    
    xpending in interface ReactiveStreamCommands<K,F,V>
    
    Parameters:
    
    key - the key
    
    group - the group
    
    range - the range
    
    count - the number of message to include
    
    Returns:
    
    A Uni emitting the list of pending messages
  - xpending
```
public io.smallrye.mutiny.Uni<List<PendingMessage>> xpending(K key,
                                                             String group,
                                                             StreamRange range,
                                                             int count,
                                                             XPendingArgs args)
```
    Description copied from interface: ReactiveStreamCommands
    
    Execute the command XPENDING. Summary: The XPENDING command is the interface to inspect the list of pending messages, and is as thus a very important command in order to observe and understand what is happening with a streams consumer groups: what clients are active, what messages are pending to be consumed, or to see if there are idle messages.
    Group: stream Requires Redis 5.0.0+
    This variant of xpending uses the extended form. If the extra parameter include the name of the consumer, the produced list will only contain 0 or 1 item.
    
    Specified by:
    
    xpending in interface ReactiveStreamCommands<K,F,V>
    
    Parameters:
    
    key - the key
    
    group - the group
    
    range - the range
    
    count - the number of message to include
    
    args - the extra argument (idle and consumer)
    
    Returns:
    
    A Uni emitting the list of pending messages
  - decodeListOfPendingMessages
```
protected List<PendingMessage> decodeListOfPendingMessages(io.vertx.mutiny.redis.client.Response r)
```
  - decodeAsXPendingSummary
```
protected XPendingSummary decodeAsXPendingSummary(io.vertx.mutiny.redis.client.Response r)
```

Class ReactiveStreamCommandsImpl<K,​F,​V>

Field Summary

Fields inherited from class io.quarkus.redis.runtime.datasource.AbstractRedisCommands

Constructor Summary

Method Summary

Methods inherited from class io.quarkus.redis.runtime.datasource.AbstractStreamCommands

Methods inherited from class io.quarkus.redis.runtime.datasource.AbstractRedisCommands

Methods inherited from class java.lang.Object

Constructor Detail

ReactiveStreamCommandsImpl

Method Detail

getDataSource

xack

xadd

getIdOrNull

xadd

xautoclaim

decodeAsClaimedMessages

decodeMessageListPrefixedByKey

decodeMessagePayload

xautoclaim

xautoclaim

xclaim

xclaim

xdel

xgroupCreate

xgroupCreate

xgroupCreateConsumer

xgroupDelConsumer

xgroupDestroy

xgroupSetId

xgroupSetId

xlen

xrange

xrange

decodeListOfMessages

xread

decodeAsListOfMessagesFromXRead

xread

xread

xread

xreadgroup

xreadgroup

xreadgroup

xreadgroup

xrevrange

xrevrange

xtrim

xtrim

xpending

xpending

xpending

decodeListOfPendingMessages

decodeAsXPendingSummary

Class ReactiveStreamCommandsImpl<K,F,V>