java.lang.Object
- io.quarkus.redis.runtime.datasource.AbstractTransactionalCommands
- - io.quarkus.redis.runtime.datasource.ReactiveTransactionalListCommandsImpl<K,V>

All Implemented Interfaces:: ReactiveTransactionalListCommands<K,V>, ReactiveTransactionalRedisCommands

public class ReactiveTransactionalListCommandsImpl<K,V>
extends AbstractTransactionalCommands
implements ReactiveTransactionalListCommands<K,V>

Field Summary
- Fields inherited from class io.quarkus.redis.runtime.datasource.AbstractTransactionalCommands
  tx

Constructor Summary

Constructors
Constructor	Description
`ReactiveTransactionalListCommandsImpl(ReactiveTransactionalRedisDataSource ds, ReactiveListCommandsImpl<K,V> reactive, TransactionHolder tx)`

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`io.smallrye.mutiny.Uni<Void>`	`blmove(K source, K destination, Position positionInSource, Position positionInDest, Duration timeout)`	Execute the command BLMOVE.
`io.smallrye.mutiny.Uni<Void>`	`blmpop(Duration timeout, Position position, int count, K... keys)`	Execute the command BLMPOP.
`io.smallrye.mutiny.Uni<Void>`	`blmpop(Duration timeout, Position position, K... keys)`	Execute the command BLMPOP.
`io.smallrye.mutiny.Uni<Void>`	`blpop(Duration timeout, K... keys)`	Execute the command BLPOP.
`io.smallrye.mutiny.Uni<Void>`	`brpop(Duration timeout, K... keys)`	Execute the command BRPOP.
`io.smallrye.mutiny.Uni<Void>`	`brpoplpush(Duration timeout, K source, K destination)`	Deprecated.
`io.smallrye.mutiny.Uni<Void>`	`lindex(K key, long index)`	Execute the command LINDEX.
`io.smallrye.mutiny.Uni<Void>`	`linsertAfterPivot(K key, V pivot, V element)`	Execute the command LINSERT.
`io.smallrye.mutiny.Uni<Void>`	`linsertBeforePivot(K key, V pivot, V element)`	Execute the command LINSERT.
`io.smallrye.mutiny.Uni<Void>`	`llen(K key)`	Execute the command LLEN.
`io.smallrye.mutiny.Uni<Void>`	`lmove(K source, K destination, Position positionInSource, Position positionInDestination)`	Execute the command LMOVE.
`io.smallrye.mutiny.Uni<Void>`	`lmpop(Position position, int count, K... keys)`	Execute the command LMPOP.
`io.smallrye.mutiny.Uni<Void>`	`lmpop(Position position, K... keys)`	Execute the command LMPOP.
`io.smallrye.mutiny.Uni<Void>`	`lpop(K key)`	Execute the command LPOP.
`io.smallrye.mutiny.Uni<Void>`	`lpop(K key, int count)`	Execute the command LPOP.
`io.smallrye.mutiny.Uni<Void>`	`lpos(K key, V element)`	Execute the command LPOS.
`io.smallrye.mutiny.Uni<Void>`	`lpos(K key, V element, int count)`	Execute the command LPOS.
`io.smallrye.mutiny.Uni<Void>`	`lpos(K key, V element, int count, LPosArgs args)`	Execute the command LPOS.
`io.smallrye.mutiny.Uni<Void>`	`lpos(K key, V element, LPosArgs args)`	Execute the command LPOS.
`io.smallrye.mutiny.Uni<Void>`	`lpush(K key, V... elements)`	Execute the command LPUSH.
`io.smallrye.mutiny.Uni<Void>`	`lpushx(K key, V... elements)`	Execute the command LPUSHX.
`io.smallrye.mutiny.Uni<Void>`	`lrange(K key, long start, long stop)`	Execute the command LRANGE.
`io.smallrye.mutiny.Uni<Void>`	`lrem(K key, long count, V element)`	Execute the command LREM.
`io.smallrye.mutiny.Uni<Void>`	`lset(K key, long index, V element)`	Execute the command LSET.
`io.smallrye.mutiny.Uni<Void>`	`ltrim(K key, long start, long stop)`	Execute the command LTRIM.
`io.smallrye.mutiny.Uni<Void>`	`rpop(K key)`	Execute the command RPOP.
`io.smallrye.mutiny.Uni<Void>`	`rpop(K key, int count)`	Execute the command RPOP.
`io.smallrye.mutiny.Uni<Void>`	`rpoplpush(K source, K destination)`	Deprecated.
`io.smallrye.mutiny.Uni<Void>`	`rpush(K key, V... values)`	Execute the command RPUSH.
`io.smallrye.mutiny.Uni<Void>`	`rpushx(K key, V... values)`	Execute the command RPUSHX.

Methods inherited from class io.quarkus.redis.runtime.datasource.AbstractTransactionalCommands
getDataSource, queuedOrDiscard

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

Methods inherited from interface io.quarkus.redis.datasource.ReactiveTransactionalRedisCommands
getDataSource

- Constructor Detail
  - ReactiveTransactionalListCommandsImpl
```
public ReactiveTransactionalListCommandsImpl(ReactiveTransactionalRedisDataSource ds,
                                             ReactiveListCommandsImpl<K,V> reactive,
                                             TransactionHolder tx)
```
- Method Detail
  - blmove
```
public io.smallrye.mutiny.Uni<Void> blmove(K source,
                                           K destination,
                                           Position positionInSource,
                                           Position positionInDest,
                                           Duration timeout)
```
    Description copied from interface: ReactiveTransactionalListCommands
    
    Execute the command BLMOVE. Summary: Pop an element from a list, push it to another list and return it; or block until one is available Group: list Requires Redis 6.2.0
    
    Specified by:
    
    blmove in interface ReactiveTransactionalListCommands<K,V>
    
    Parameters:
    
    source - the key
    
    destination - the key
    
    positionInSource - the position of the element in the source, LEFT means the first element, RIGHT means the last element.
    
    positionInDest - the position of the element in the destination, LEFT means the first element, RIGHT means the last element.
    
    timeout - the operation timeout (in seconds)
    
    Returns:
    
    A Uni emitting null when the command has been enqueued successfully in the transaction, a failure otherwise. In the case of failure, the transaction is discarded.
  - blmpop
```
public io.smallrye.mutiny.Uni<Void> blmpop(Duration timeout,
                                           Position position,
                                           K... keys)
```
    Description copied from interface: ReactiveTransactionalListCommands
    
    Execute the command BLMPOP. Summary: Pop elements from a list, or block until one is available Group: list Requires Redis 7.0.0
    
    Specified by:
    
    blmpop in interface ReactiveTransactionalListCommands<K,V>
    
    Parameters:
    
    timeout - the operation timeout (in seconds)
    
    position - whether if the element must be popped from the beginning of the list (LEFT) or from the end (RIGHT)
    
    keys - the keys from which the element must be popped
    
    Returns:
    
    A Uni emitting null when the command has been enqueued successfully in the transaction, a failure otherwise. In the case of failure, the transaction is discarded.
  - blmpop
```
public io.smallrye.mutiny.Uni<Void> blmpop(Duration timeout,
                                           Position position,
                                           int count,
                                           K... keys)
```
    Description copied from interface: ReactiveTransactionalListCommands
    
    Execute the command BLMPOP. Summary: Pop elements from a list, or block until one is available Group: list Requires Redis 7.0.0
    
    Specified by:
    
    blmpop in interface ReactiveTransactionalListCommands<K,V>
    
    Parameters:
    
    timeout - the operation timeout (in seconds)
    
    position - whether if the element must be popped from the beginning of the list (LEFT) or from the end (RIGHT)
    
    count - the number of element to pop
    
    keys - the keys from which the element must be popped
    
    Returns:
    
    A Uni emitting null when the command has been enqueued successfully in the transaction, a failure otherwise. In the case of failure, the transaction is discarded.
  - blpop
```
public io.smallrye.mutiny.Uni<Void> blpop(Duration timeout,
                                          K... keys)
```
    Description copied from interface: ReactiveTransactionalListCommands
    
    Execute the command BLPOP. Summary: Remove and get the first element in a list, or block until one is available Group: list Requires Redis 2.0.0
    
    Specified by:
    
    blpop in interface ReactiveTransactionalListCommands<K,V>
    
    Parameters:
    
    timeout - the operation timeout (in seconds)
    
    keys - the keys from which the element must be popped
    
    Returns:
    
    A Uni emitting null when the command has been enqueued successfully in the transaction, a failure otherwise. In the case of failure, the transaction is discarded.
  - brpop
```
public io.smallrye.mutiny.Uni<Void> brpop(Duration timeout,
                                          K... keys)
```
    Description copied from interface: ReactiveTransactionalListCommands
    
    Execute the command BRPOP. Summary: Remove and get the last element in a list, or block until one is available Group: list Requires Redis 2.0.0
    
    Specified by:
    
    brpop in interface ReactiveTransactionalListCommands<K,V>
    
    Parameters:
    
    timeout - the operation timeout (in seconds)
    
    keys - the keys from which the element must be popped
    
    Returns:
    
    A Uni emitting null when the command has been enqueued successfully in the transaction, a failure otherwise. In the case of failure, the transaction is discarded.
  - brpoplpush
```
@Deprecated
public io.smallrye.mutiny.Uni<Void> brpoplpush(Duration timeout,
                                               K source,
                                               K destination)
```
    Deprecated.
    
    Description copied from interface: ReactiveTransactionalListCommands
    
    Execute the command BRPOPLPUSH. Summary: Pop an element from a list, push it to another list and return it; or block until one is available Group: list Requires Redis 2.2.0
    
    Specified by:
    
    brpoplpush in interface ReactiveTransactionalListCommands<K,V>
    
    Parameters:
    
    timeout - the timeout, in seconds
    
    source - the source key
    
    destination - the detination key
    
    Returns:
    
    A Uni emitting null when the command has been enqueued successfully in the transaction, a failure otherwise. In the case of failure, the transaction is discarded.
  - lindex
```
public io.smallrye.mutiny.Uni<Void> lindex(K key,
                                           long index)
```
    Description copied from interface: ReactiveTransactionalListCommands
    
    Execute the command LINDEX. Summary: Get an element from a list by its index Group: list Requires Redis 1.0.0
    
    Specified by:
    
    lindex in interface ReactiveTransactionalListCommands<K,V>
    
    Parameters:
    
    key - the key
    
    index - the index
    
    Returns:
    
    A Uni emitting null when the command has been enqueued successfully in the transaction, a failure otherwise. In the case of failure, the transaction is discarded.
  - linsertBeforePivot
```
public io.smallrye.mutiny.Uni<Void> linsertBeforePivot(K key,
                                                       V pivot,
                                                       V element)
```
    Description copied from interface: ReactiveTransactionalListCommands
    
    Execute the command LINSERT. Summary: Insert an element before another element in a list Group: list Requires Redis 2.2.0
    
    Specified by:
    
    linsertBeforePivot in interface ReactiveTransactionalListCommands<K,V>
    
    Parameters:
    
    key - the key
    
    pivot - the pivot, i.e. the position reference
    
    element - the element to insert
    
    Returns:
    
    A Uni emitting null when the command has been enqueued successfully in the transaction, a failure otherwise. In the case of failure, the transaction is discarded.
  - linsertAfterPivot
```
public io.smallrye.mutiny.Uni<Void> linsertAfterPivot(K key,
                                                      V pivot,
                                                      V element)
```
    Description copied from interface: ReactiveTransactionalListCommands
    
    Execute the command LINSERT. Summary: Insert an element after another element in a list Group: list Requires Redis 2.2.0
    
    Specified by:
    
    linsertAfterPivot in interface ReactiveTransactionalListCommands<K,V>
    
    Parameters:
    
    key - the key
    
    pivot - the pivot, i.e. the position reference
    
    element - the element to insert
    
    Returns:
    
    A Uni emitting null when the command has been enqueued successfully in the transaction, a failure otherwise. In the case of failure, the transaction is discarded.
  - llen
```
public io.smallrye.mutiny.Uni<Void> llen(K key)
```
    Description copied from interface: ReactiveTransactionalListCommands
    
    Execute the command LLEN. Summary: Get the length of a list Group: list Requires Redis 1.0.0
    
    Specified by:
    
    llen in interface ReactiveTransactionalListCommands<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    A Uni emitting null when the command has been enqueued successfully in the transaction, a failure otherwise. In the case of failure, the transaction is discarded.
  - lmove
```
public io.smallrye.mutiny.Uni<Void> lmove(K source,
                                          K destination,
                                          Position positionInSource,
                                          Position positionInDestination)
```
    Description copied from interface: ReactiveTransactionalListCommands
    
    Execute the command LMOVE. Summary: Pop an element from a list, push it to another list and return it Group: list Requires Redis 6.2.0
    
    Specified by:
    
    lmove in interface ReactiveTransactionalListCommands<K,V>
    
    Parameters:
    
    source - the key
    
    destination - the key
    
    positionInSource - the position of the element to pop in the source (LEFT: first element, RIGHT: last element)
    
    positionInDestination - the position of the element to insert in the destination (LEFT: first element, RIGHT: last element)
    
    Returns:
    
    A Uni emitting null when the command has been enqueued successfully in the transaction, a failure otherwise. In the case of failure, the transaction is discarded.
  - lmpop
```
public io.smallrye.mutiny.Uni<Void> lmpop(Position position,
                                          K... keys)
```
    Description copied from interface: ReactiveTransactionalListCommands
    
    Execute the command LMPOP. Summary: Pop one element from the first non-empty list Group: list Requires Redis 7.0.0
    
    Specified by:
    
    lmpop in interface ReactiveTransactionalListCommands<K,V>
    
    Parameters:
    
    position - the position of the item to pop (LEFT: beginning ot the list, RIGHT: end of the list)
    
    keys - the keys from which the item will be popped, must not be empty
    
    Returns:
    
    A Uni emitting null when the command has been enqueued successfully in the transaction, a failure otherwise. In the case of failure, the transaction is discarded.
  - lmpop
```
public io.smallrye.mutiny.Uni<Void> lmpop(Position position,
                                          int count,
                                          K... keys)
```
    Description copied from interface: ReactiveTransactionalListCommands
    
    Execute the command LMPOP. Summary: Pop count elements from the first non-empty list Group: list Requires Redis 7.0.0
    
    Specified by:
    
    lmpop in interface ReactiveTransactionalListCommands<K,V>
    
    Parameters:
    
    position - the position of the item to pop (LEFT: beginning ot the list, RIGHT: end of the list)
    
    count - the number of items to pop
    
    keys - the keys from which the item will be popped, must not be empty
    
    Returns:
    
    A Uni emitting null when the command has been enqueued successfully in the transaction, a failure otherwise. In the case of failure, the transaction is discarded.
  - lpop
```
public io.smallrye.mutiny.Uni<Void> lpop(K key)
```
    Description copied from interface: ReactiveTransactionalListCommands
    
    Execute the command LPOP. Summary: Remove and get the first elements in a list Group: list Requires Redis 1.0.0
    
    Specified by:
    
    lpop in interface ReactiveTransactionalListCommands<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    A Uni emitting null when the command has been enqueued successfully in the transaction, a failure otherwise. In the case of failure, the transaction is discarded.
  - lpop
```
public io.smallrye.mutiny.Uni<Void> lpop(K key,
                                         int count)
```
    Description copied from interface: ReactiveTransactionalListCommands
    
    Execute the command LPOP. Summary: Remove and get the first elements in a list Group: list Requires Redis 1.0.0
    
    Specified by:
    
    lpop in interface ReactiveTransactionalListCommands<K,V>
    
    Parameters:
    
    key - the key
    
    count - the number of element to pop
    
    Returns:
    
    A Uni emitting null when the command has been enqueued successfully in the transaction, a failure otherwise. In the case of failure, the transaction is discarded.
  - lpos
```
public io.smallrye.mutiny.Uni<Void> lpos(K key,
                                         V element)
```
    Description copied from interface: ReactiveTransactionalListCommands
    
    Execute the command LPOS. Summary: Return the index of matching elements on a list Group: list Requires Redis 6.0.6
    
    Specified by:
    
    lpos in interface ReactiveTransactionalListCommands<K,V>
    
    Parameters:
    
    key - the key
    
    element - the element to find
    
    Returns:
    
    A Uni emitting null when the command has been enqueued successfully in the transaction, a failure otherwise. In the case of failure, the transaction is discarded.
  - lpos
```
public io.smallrye.mutiny.Uni<Void> lpos(K key,
                                         V element,
                                         LPosArgs args)
```
    Description copied from interface: ReactiveTransactionalListCommands
    
    Execute the command LPOS. Summary: Return the index of matching elements on a list Group: list Requires Redis 6.0.6
    
    Specified by:
    
    lpos in interface ReactiveTransactionalListCommands<K,V>
    
    Parameters:
    
    key - the key
    
    element - the element to find
    
    args - the extra command parameter
    
    Returns:
    
    A Uni emitting null when the command has been enqueued successfully in the transaction, a failure otherwise. In the case of failure, the transaction is discarded.
  - lpos
```
public io.smallrye.mutiny.Uni<Void> lpos(K key,
                                         V element,
                                         int count)
```
    Description copied from interface: ReactiveTransactionalListCommands
    
    Execute the command LPOS. Summary: Return the index of matching elements on a list Group: list Requires Redis 6.0.6
    
    Specified by:
    
    lpos in interface ReactiveTransactionalListCommands<K,V>
    
    Parameters:
    
    key - the key
    
    element - the element to find
    
    count - the number of occurrence to find
    
    Returns:
    
    A Uni emitting null when the command has been enqueued successfully in the transaction, a failure otherwise. In the case of failure, the transaction is discarded.
  - lpos
```
public io.smallrye.mutiny.Uni<Void> lpos(K key,
                                         V element,
                                         int count,
                                         LPosArgs args)
```
    Description copied from interface: ReactiveTransactionalListCommands
    
    Execute the command LPOS. Summary: Return the index of matching elements on a list Group: list Requires Redis 6.0.6
    
    Specified by:
    
    lpos in interface ReactiveTransactionalListCommands<K,V>
    
    Parameters:
    
    key - the key
    
    element - the element to find
    
    count - the number of occurrence to find
    
    Returns:
    
    A Uni emitting null when the command has been enqueued successfully in the transaction, a failure otherwise. In the case of failure, the transaction is discarded.
  - lpush
```
public io.smallrye.mutiny.Uni<Void> lpush(K key,
                                          V... elements)
```
    Description copied from interface: ReactiveTransactionalListCommands
    
    Execute the command LPUSH. Summary: Prepend one or multiple elements to a list Group: list Requires Redis 1.0.0
    
    Specified by:
    
    lpush in interface ReactiveTransactionalListCommands<K,V>
    
    Parameters:
    
    key - the key
    
    elements - the elements to add
    
    Returns:
    
    A Uni emitting null when the command has been enqueued successfully in the transaction, a failure otherwise. In the case of failure, the transaction is discarded.
  - lpushx
```
public io.smallrye.mutiny.Uni<Void> lpushx(K key,
                                           V... elements)
```
    Description copied from interface: ReactiveTransactionalListCommands
    
    Execute the command LPUSHX. Summary: Prepend an element to a list, only if the list exists Group: list Requires Redis 2.2.0
    
    Specified by:
    
    lpushx in interface ReactiveTransactionalListCommands<K,V>
    
    Parameters:
    
    key - the key
    
    elements - the elements to add
    
    Returns:
    
    A Uni emitting null when the command has been enqueued successfully in the transaction, a failure otherwise. In the case of failure, the transaction is discarded.
  - lrange
```
public io.smallrye.mutiny.Uni<Void> lrange(K key,
                                           long start,
                                           long stop)
```
    Description copied from interface: ReactiveTransactionalListCommands
    
    Execute the command LRANGE. Summary: Get a range of elements from a list Group: list Requires Redis 1.0.0
    
    Specified by:
    
    lrange in interface ReactiveTransactionalListCommands<K,V>
    
    Parameters:
    
    key - the key
    
    start - the starting position
    
    stop - the last position
    
    Returns:
    
    A Uni emitting null when the command has been enqueued successfully in the transaction, a failure otherwise. In the case of failure, the transaction is discarded.
  - lrem
```
public io.smallrye.mutiny.Uni<Void> lrem(K key,
                                         long count,
                                         V element)
```
    Description copied from interface: ReactiveTransactionalListCommands
    
    Execute the command LREM. Summary: Remove elements from a list Group: list Requires Redis 1.0.0
    
    Specified by:
    
    lrem in interface ReactiveTransactionalListCommands<K,V>
    
    Parameters:
    
    key - the key
    
    count - the number of occurence to remove, following the given rules: if count > 0: Remove elements equal to element moving from head to tail. if count < 0: Remove elements equal to element moving from tail to head. if count = 0: Remove all elements equal to element.
    
    element - the element to remove
    
    Returns:
    
    A Uni emitting null when the command has been enqueued successfully in the transaction, a failure otherwise. In the case of failure, the transaction is discarded.
  - lset
```
public io.smallrye.mutiny.Uni<Void> lset(K key,
                                         long index,
                                         V element)
```
    Description copied from interface: ReactiveTransactionalListCommands
    
    Execute the command LSET. Summary: Set the value of an element in a list by its index Group: list Requires Redis 1.0.0
    
    Specified by:
    
    lset in interface ReactiveTransactionalListCommands<K,V>
    
    Parameters:
    
    key - the key
    
    index - the index
    
    element - the element to insert
  - ltrim
```
public io.smallrye.mutiny.Uni<Void> ltrim(K key,
                                          long start,
                                          long stop)
```
    Description copied from interface: ReactiveTransactionalListCommands
    
    Execute the command LTRIM. Summary: Trim a list to the specified range Group: list Requires Redis 1.0.0
    
    Specified by:
    
    ltrim in interface ReactiveTransactionalListCommands<K,V>
    
    Parameters:
    
    key - the key
    
    start - the starting index
    
    stop - the last index
  - rpop
```
public io.smallrye.mutiny.Uni<Void> rpop(K key)
```
    Description copied from interface: ReactiveTransactionalListCommands
    
    Execute the command RPOP. Summary: Remove and get the last elements in a list Group: list Requires Redis 1.0.0
    
    Specified by:
    
    rpop in interface ReactiveTransactionalListCommands<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    A Uni emitting null when the command has been enqueued successfully in the transaction, a failure otherwise. In the case of failure, the transaction is discarded.
  - rpop
```
public io.smallrye.mutiny.Uni<Void> rpop(K key,
                                         int count)
```
    Description copied from interface: ReactiveTransactionalListCommands
    
    Execute the command RPOP. Summary: Remove and get the last elements in a list Group: list Requires Redis 1.0.0
    
    Specified by:
    
    rpop in interface ReactiveTransactionalListCommands<K,V>
    
    Parameters:
    
    key - the key
    
    count - the number of element to pop
    
    Returns:
    
    A Uni emitting null when the command has been enqueued successfully in the transaction, a failure otherwise. In the case of failure, the transaction is discarded.
  - rpoplpush
```
@Deprecated
public io.smallrye.mutiny.Uni<Void> rpoplpush(K source,
                                              K destination)
```
    Deprecated.
    
    Description copied from interface: ReactiveTransactionalListCommands
    
    Execute the command RPOPLPUSH. Summary: Remove the last element in a list, prepend it to another list and return it Group: list Requires Redis 1.2.0
    
    Specified by:
    
    rpoplpush in interface ReactiveTransactionalListCommands<K,V>
    
    Parameters:
    
    source - the key
    
    destination - the key
    
    Returns:
    
    A Uni emitting null when the command has been enqueued successfully in the transaction, a failure otherwise. In the case of failure, the transaction is discarded.
  - rpush
```
public io.smallrye.mutiny.Uni<Void> rpush(K key,
                                          V... values)
```
    Description copied from interface: ReactiveTransactionalListCommands
    
    Execute the command RPUSH. Summary: Append one or multiple elements to a list Group: list Requires Redis 1.0.0
    
    Specified by:
    
    rpush in interface ReactiveTransactionalListCommands<K,V>
    
    Parameters:
    
    key - the key
    
    values - the values to add to the list
    
    Returns:
    
    A Uni emitting null when the command has been enqueued successfully in the transaction, a failure otherwise. In the case of failure, the transaction is discarded.
  - rpushx
```
public io.smallrye.mutiny.Uni<Void> rpushx(K key,
                                           V... values)
```
    Description copied from interface: ReactiveTransactionalListCommands
    
    Execute the command RPUSHX. Summary: Append an element to a list, only if the list exists Group: list Requires Redis 2.2.0
    
    Specified by:
    
    rpushx in interface ReactiveTransactionalListCommands<K,V>
    
    Parameters:
    
    key - the key
    
    values - the values to add to the list
    
    Returns:
    
    A Uni emitting null when the command has been enqueued successfully in the transaction, a failure otherwise. In the case of failure, the transaction is discarded.

Class ReactiveTransactionalListCommandsImpl<K,​V>

Field Summary

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

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

Methods inherited from interface io.quarkus.redis.datasource.ReactiveTransactionalRedisCommands

Constructor Detail

ReactiveTransactionalListCommandsImpl

Method Detail

blmove

blmpop

blmpop

blpop

brpop

brpoplpush

lindex

linsertBeforePivot

linsertAfterPivot

llen

lmove

lmpop

lmpop

lpop

lpop

lpos

lpos

lpos

lpos

lpush

lpushx

lrange

lrem

lset

ltrim

rpop

rpop

rpoplpush

rpush

rpushx

Class ReactiveTransactionalListCommandsImpl<K,V>