java.lang.Object
- io.quarkus.redis.runtime.datasource.AbstractRedisCommands
- - io.quarkus.redis.runtime.datasource.ReactiveSortable<K,V>
  - - io.quarkus.redis.runtime.datasource.AbstractSortedSetCommands<K,V>
    - - io.quarkus.redis.runtime.datasource.ReactiveSortedSetCommandsImpl<K,V>

All Implemented Interfaces:: ReactiveRedisCommands, ReactiveSortedSetCommands<K,V>

public class ReactiveSortedSetCommandsImpl<K,V>
extends AbstractSortedSetCommands<K,V>
implements ReactiveSortedSetCommands<K,V>

Field Summary
- Fields inherited from class io.quarkus.redis.runtime.datasource.AbstractSortedSetCommands
  BZMPOP, DEFAULT_INSTANCE_AGG, DEFAULT_INSTANCE_RANGE, typeOfKey, typeOfValue, ZINTERCARD, ZMPOP
- Fields inherited from class io.quarkus.redis.runtime.datasource.AbstractRedisCommands
  marshaller, redis

Constructor Summary

Constructors
Constructor Description

ReactiveSortedSetCommandsImpl(ReactiveRedisDataSourceImpl redis, Type k, Type v)

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`io.smallrye.mutiny.Uni<List<ScoredValue<V>>>`	`bzmpopMax(Duration timeout, int count, K... keys)`	Execute the command BZMPOP.
`io.smallrye.mutiny.Uni<ScoredValue<V>>`	`bzmpopMax(Duration timeout, K... keys)`	Execute the command BZMPOP.
`io.smallrye.mutiny.Uni<List<ScoredValue<V>>>`	`bzmpopMin(Duration timeout, int count, K... keys)`	Execute the command BZMPOP.
`io.smallrye.mutiny.Uni<ScoredValue<V>>`	`bzmpopMin(Duration timeout, K... keys)`	Execute the command BZMPOP.
`io.smallrye.mutiny.Uni<KeyValue<K,ScoredValue<V>>>`	`bzpopmax(Duration timeout, K... keys)`	Execute the command BZPOPMAX.
`io.smallrye.mutiny.Uni<KeyValue<K,ScoredValue<V>>>`	`bzpopmin(Duration timeout, K... keys)`	Execute the command BZPOPMIN.
`ReactiveRedisDataSource`	`getDataSource()`
`io.smallrye.mutiny.Uni<Boolean>`	`zadd(K key, double score, V value)`	Execute the command ZADD.
`io.smallrye.mutiny.Uni<Integer>`	`zadd(K key, ScoredValue<V>... items)`	Execute the command ZADD.
`io.smallrye.mutiny.Uni<Boolean>`	`zadd(K key, ZAddArgs args, double score, V value)`	Execute the command ZADD.
`io.smallrye.mutiny.Uni<Integer>`	`zadd(K key, ZAddArgs args, ScoredValue<V>... items)`	Execute the command ZADD.
`io.smallrye.mutiny.Uni<Integer>`	`zadd(K key, ZAddArgs args, Map<V,Double> items)`	Execute the command ZADD.
`io.smallrye.mutiny.Uni<Integer>`	`zadd(K key, Map<V,Double> items)`	Execute the command ZADD.
`io.smallrye.mutiny.Uni<Double>`	`zaddincr(K key, double score, V value)`	Execute the command ZADD.
`io.smallrye.mutiny.Uni<Double>`	`zaddincr(K key, ZAddArgs args, double score, V value)`	Execute the command ZADD.
`io.smallrye.mutiny.Uni<Long>`	`zcard(K key)`	Execute the command ZCARD.
`io.smallrye.mutiny.Uni<Long>`	`zcount(K key, ScoreRange<Double> range)`	Execute the command ZCOUNT.
`io.smallrye.mutiny.Uni<List<V>>`	`zdiff(K... keys)`	Execute the command ZDIFF.
`io.smallrye.mutiny.Uni<Long>`	`zdiffstore(K destination, K... keys)`	Execute the command ZDIFFSTORE.
`io.smallrye.mutiny.Uni<List<ScoredValue<V>>>`	`zdiffWithScores(K... keys)`	Execute the command ZDIFF.
`io.smallrye.mutiny.Uni<Double>`	`zincrby(K key, double increment, V value)`	Execute the command ZINCRBY.
`io.smallrye.mutiny.Uni<List<V>>`	`zinter(ZAggregateArgs args, K... keys)`	Execute the command ZINTER.
`io.smallrye.mutiny.Uni<List<V>>`	`zinter(K... keys)`	Execute the command ZINTER.
`io.smallrye.mutiny.Uni<Long>`	`zintercard(long limit, K... keys)`	Execute the command ZINTERCARD.
`io.smallrye.mutiny.Uni<Long>`	`zintercard(K... keys)`	Execute the command ZINTERCARD.
`io.smallrye.mutiny.Uni<Long>`	`zinterstore(K destination, ZAggregateArgs arguments, K... keys)`	Execute the command ZINTERSTORE.
`io.smallrye.mutiny.Uni<Long>`	`zinterstore(K destination, K... keys)`	Execute the command ZINTERSTORE.
`io.smallrye.mutiny.Uni<List<ScoredValue<V>>>`	`zinterWithScores(ZAggregateArgs arguments, K... keys)`	Execute the command ZINTER.
`io.smallrye.mutiny.Uni<List<ScoredValue<V>>>`	`zinterWithScores(K... keys)`	Execute the command ZINTER.
`io.smallrye.mutiny.Uni<Long>`	`zlexcount(K key, Range<String> range)`	Execute the command ZLEXCOUNT.
`io.smallrye.mutiny.Uni<List<ScoredValue<V>>>`	`zmpopMax(int count, K... keys)`	Execute the command ZMPOP.
`io.smallrye.mutiny.Uni<ScoredValue<V>>`	`zmpopMax(K... keys)`	Execute the command ZMPOP.
`io.smallrye.mutiny.Uni<List<ScoredValue<V>>>`	`zmpopMin(int count, K... keys)`	Execute the command ZMPOP.
`io.smallrye.mutiny.Uni<ScoredValue<V>>`	`zmpopMin(K... keys)`	Execute the command ZMPOP.
`io.smallrye.mutiny.Uni<List<Double>>`	`zmscore(K key, V... values)`	Execute the command ZMSCORE.
`io.smallrye.mutiny.Uni<ScoredValue<V>>`	`zpopmax(K key)`	Execute the command ZPOPMAX.
`io.smallrye.mutiny.Uni<List<ScoredValue<V>>>`	`zpopmax(K key, int count)`	Execute the command ZPOPMAX.
`io.smallrye.mutiny.Uni<ScoredValue<V>>`	`zpopmin(K key)`	Execute the command ZPOPMIN.
`io.smallrye.mutiny.Uni<List<ScoredValue<V>>>`	`zpopmin(K key, int count)`	Execute the command ZPOPMIN.
`io.smallrye.mutiny.Uni<V>`	`zrandmember(K key)`	Execute the command ZRANDMEMBER.
`io.smallrye.mutiny.Uni<List<V>>`	`zrandmember(K key, int count)`	Execute the command ZRANDMEMBER.
`io.smallrye.mutiny.Uni<ScoredValue<V>>`	`zrandmemberWithScores(K key)`	Execute the command ZRANDMEMBER.
`io.smallrye.mutiny.Uni<List<ScoredValue<V>>>`	`zrandmemberWithScores(K key, int count)`	Execute the command ZRANDMEMBER.
`io.smallrye.mutiny.Uni<List<V>>`	`zrange(K key, long start, long stop)`	Execute the command ZRANGE.
`io.smallrye.mutiny.Uni<List<V>>`	`zrange(K key, long start, long stop, ZRangeArgs args)`	Execute the command ZRANGE.
`io.smallrye.mutiny.Uni<List<V>>`	`zrangebylex(K key, Range<String> range)`	Execute the command ZRANGE.
`io.smallrye.mutiny.Uni<List<V>>`	`zrangebylex(K key, Range<String> range, ZRangeArgs args)`	Execute the command ZRANGE.
`io.smallrye.mutiny.Uni<List<V>>`	`zrangebyscore(K key, ScoreRange<Double> range)`	Execute the command ZRANGE.
`io.smallrye.mutiny.Uni<List<V>>`	`zrangebyscore(K key, ScoreRange<Double> range, ZRangeArgs args)`	Execute the command ZRANGE.
`io.smallrye.mutiny.Uni<List<ScoredValue<V>>>`	`zrangebyscoreWithScores(K key, ScoreRange<Double> range)`	Execute the command ZRANGE.
`io.smallrye.mutiny.Uni<List<ScoredValue<V>>>`	`zrangebyscoreWithScores(K key, ScoreRange<Double> range, ZRangeArgs args)`	Execute the command ZRANGE.
`io.smallrye.mutiny.Uni<Long>`	`zrangestore(K dst, K src, long min, long max)`	Execute the command ZRANGESTORE.
`io.smallrye.mutiny.Uni<Long>`	`zrangestore(K dst, K src, long min, long max, ZRangeArgs args)`	Execute the command ZRANGESTORE.
`io.smallrye.mutiny.Uni<Long>`	`zrangestorebylex(K dst, K src, Range<String> range)`	Execute the command ZRANGESTORE.
`io.smallrye.mutiny.Uni<Long>`	`zrangestorebylex(K dst, K src, Range<String> range, ZRangeArgs args)`	Execute the command ZRANGESTORE.
`io.smallrye.mutiny.Uni<Long>`	`zrangestorebyscore(K dst, K src, ScoreRange<Double> range)`	Execute the command ZRANGESTORE.
`io.smallrye.mutiny.Uni<Long>`	`zrangestorebyscore(K dst, K src, ScoreRange<Double> range, ZRangeArgs args)`	Execute the command ZRANGESTORE.
`io.smallrye.mutiny.Uni<List<ScoredValue<V>>>`	`zrangeWithScores(K key, long start, long stop)`	Execute the command ZRANGE.
`io.smallrye.mutiny.Uni<List<ScoredValue<V>>>`	`zrangeWithScores(K key, long start, long stop, ZRangeArgs args)`	Execute the command ZRANGE.
`io.smallrye.mutiny.Uni<Long>`	`zrank(K key, V value)`	Execute the command ZRANK.
`io.smallrye.mutiny.Uni<Integer>`	`zrem(K key, V... values)`	Execute the command ZREM.
`io.smallrye.mutiny.Uni<Long>`	`zremrangebylex(K key, Range<String> range)`	Execute the command ZREMRANGEBYLEX.
`io.smallrye.mutiny.Uni<Long>`	`zremrangebyrank(K key, long start, long stop)`	Execute the command ZREMRANGEBYRANK.
`io.smallrye.mutiny.Uni<Long>`	`zremrangebyscore(K key, ScoreRange<Double> range)`	Execute the command ZREMRANGEBYSCORE.
`io.smallrye.mutiny.Uni<Long>`	`zrevrank(K key, V value)`	Execute the command ZREVRANK.
`ReactiveZScanCursor<V>`	`zscan(K key)`	Execute the command ZSCAN.
`ReactiveZScanCursor<V>`	`zscan(K key, ScanArgs args)`	Execute the command ZSCAN.
`io.smallrye.mutiny.Uni<Double>`	`zscore(K key, V value)`	Execute the command ZSCORE.
`io.smallrye.mutiny.Uni<List<V>>`	`zunion(ZAggregateArgs args, K... keys)`	Execute the command ZUNION.
`io.smallrye.mutiny.Uni<List<V>>`	`zunion(K... keys)`	Execute the command ZUNION.
`io.smallrye.mutiny.Uni<Long>`	`zunionstore(K destination, ZAggregateArgs args, K... keys)`	Execute the command ZUNIONSTORE.
`io.smallrye.mutiny.Uni<Long>`	`zunionstore(K destination, K... keys)`	Execute the command ZUNIONSTORE.
`io.smallrye.mutiny.Uni<List<ScoredValue<V>>>`	`zunionWithScores(ZAggregateArgs args, K... keys)`	Execute the command ZUNION.
`io.smallrye.mutiny.Uni<List<ScoredValue<V>>>`	`zunionWithScores(K... keys)`	Execute the command ZUNION.

Methods inherited from class io.quarkus.redis.runtime.datasource.AbstractSortedSetCommands
_bzmpopMax, _bzmpopMax, _bzmpopMin, _bzmpopMin, _bzpopmax, _bzpopmin, _zadd, _zadd, _zadd, _zadd, _zadd, _zadd, _zaddincr, _zaddincr, _zcard, _zcount, _zdiff, _zdiffstore, _zdiffWithScores, _zincrby, _zinter, _zinter, _zintercard, _zintercard, _zinterstore, _zinterstore, _zinterWithScores, _zinterWithScores, _zlexcount, _zmpopMax, _zmpopMax, _zmpopMin, _zmpopMin, _zmscore, _zpopmax, _zpopmax, _zpopmin, _zpopmin, _zrandmember, _zrandmember, _zrandmemberWithScores, _zrandmemberWithScores, _zrange, _zrange, _zrangebylex, _zrangebylex, _zrangebyscore, _zrangebyscore, _zrangebyscoreWithScores, _zrangebyscoreWithScores, _zrangestore, _zrangestore, _zrangestorebylex, _zrangestorebylex, _zrangestorebyscore, _zrangestorebyscore, _zrangeWithScores, _zrangeWithScores, _zrank, _zrem, _zremrangebylex, _zremrangebyrank, _zremrangebyscore, _zrevrank, _zscan, _zscan, _zscore, _zunion, _zunion, _zunionstore, _zunionstore, _zunionWithScores, _zunionWithScores, decodeAsDouble, decodeAsKeyValue, decodeAsListOfDouble, decodeAsListOfScoredValues, decodeAsListOfValues, decodeAsLong, decodeAsScoredValue, decodeAsScoredValueOrEmpty, decodeIntAsBoolean, decodeLongOrZero, decodePopResponse, decodePopResponseWithCount, decodeV, getScoreAsString

Methods inherited from class io.quarkus.redis.runtime.datasource.ReactiveSortable
sort, sort, sortAndStore, sortAndStore

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

Methods inherited from interface io.quarkus.redis.datasource.sortedset.ReactiveSortedSetCommands
sort, sort, sortAndStore, sortAndStore

- Constructor Detail
  - ReactiveSortedSetCommandsImpl
```
public ReactiveSortedSetCommandsImpl(ReactiveRedisDataSourceImpl redis,
                                     Type k,
                                     Type v)
```
- Method Detail
  - getDataSource
```
public ReactiveRedisDataSource getDataSource()
```
    Specified by:
    
    getDataSource in interface ReactiveRedisCommands
    
    Returns:
    
    the data source.
  - zadd
```
public io.smallrye.mutiny.Uni<Boolean> zadd(K key,
                                            double score,
                                            V value)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZADD. Summary: Add one or more members to a sorted set, or update its score if it already exists Group: sorted-set Requires Redis 1.2.0
    
    Specified by:
    
    zadd in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    score - the score
    
    value - the member
    
    Returns:
    
    true if the element was added, false otherwise
  - zadd
```
public io.smallrye.mutiny.Uni<Integer> zadd(K key,
                                            Map<V,Double> items)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZADD. Summary: Add one or more members to a sorted set, or update its score if it already exists Group: sorted-set Requires Redis 1.2.0
    
    Specified by:
    
    zadd in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    items - the map of value/score to be added
    
    Returns:
    
    the number of added elements
  - zadd
```
public io.smallrye.mutiny.Uni<Integer> zadd(K key,
                                            ScoredValue<V>... items)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZADD. Summary: Add one or more members to a sorted set, or update its score if it already exists Group: sorted-set Requires Redis 1.2.0
    
    Specified by:
    
    zadd in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    items - the pairs of score/value to be added
    
    Returns:
    
    the number of added elements
  - zadd
```
public io.smallrye.mutiny.Uni<Boolean> zadd(K key,
                                            ZAddArgs args,
                                            double score,
                                            V value)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZADD. Summary: Add one or more members to a sorted set, or update its score if it already exists Group: sorted-set Requires Redis 1.2.0
    
    Specified by:
    
    zadd in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    args - the extra parameter
    
    score - the score
    
    value - the member
    
    Returns:
    
    true if the element was added or changed, false otherwise
  - zadd
```
public io.smallrye.mutiny.Uni<Integer> zadd(K key,
                                            ZAddArgs args,
                                            Map<V,Double> items)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZADD. Summary: Add one or more members to a sorted set, or update its score if it already exists Group: sorted-set Requires Redis 1.2.0
    
    Specified by:
    
    zadd in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    args - the extra parameter
    
    items - the map of value/score to be added
    
    Returns:
    
    the number of items added to the set
  - zadd
```
public io.smallrye.mutiny.Uni<Integer> zadd(K key,
                                            ZAddArgs args,
                                            ScoredValue<V>... items)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZADD. Summary: Add one or more members to a sorted set, or update its score if it already exists Group: sorted-set Requires Redis 1.2.0
    
    Specified by:
    
    zadd in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    args - the extra parameter
    
    items - the pairs of score/value to be added
    
    Returns:
    
    the number of items added to the set
  - zaddincr
```
public io.smallrye.mutiny.Uni<Double> zaddincr(K key,
                                               double score,
                                               V value)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZADD. Summary: Add one or more members to a sorted set, or update its score if it already exists applying the INCR option Group: sorted-set Requires Redis 1.2.0
    This variant of ZADD acts like ZINCRBY. Only one score-element pair can be specified in this mode.
    
    Specified by:
    
    zaddincr in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key.
    
    score - the increment.
    
    value - the member.
    
    Returns:
    
    the new score of the updated member, or null if the operation was aborted.
  - zaddincr
```
public io.smallrye.mutiny.Uni<Double> zaddincr(K key,
                                               ZAddArgs args,
                                               double score,
                                               V value)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZADD. Summary: Add one or more members to a sorted set, or update its score if it already exists applying the INCR option Group: sorted-set Requires Redis 1.2.0
    This variant of ZADD acts like ZINCRBY. Only one score-element pair can be specified in this mode.
    
    Specified by:
    
    zaddincr in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key.
    
    score - the increment.
    
    value - the member.
    
    Returns:
    
    the new score of the updated member, or null if the operation was aborted (when called with either the XX or the NX option).
  - zcard
```
public io.smallrye.mutiny.Uni<Long> zcard(K key)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZCARD. Summary: Get the number of members in a sorted set Group: sorted-set Requires Redis 1.2.0
    
    Specified by:
    
    zcard in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    the cardinality (number of elements) of the sorted set. 0 if the key does not exist.
  - zcount
```
public io.smallrye.mutiny.Uni<Long> zcount(K key,
                                           ScoreRange<Double> range)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZCOUNT. Summary: Count the members in a sorted set with scores within the given values Group: sorted-set Requires Redis 2.0.0
    
    Specified by:
    
    zcount in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    range - the range
    
    Returns:
    
    the number of elements in the specified score range.
  - zdiff
```
public io.smallrye.mutiny.Uni<List<V>> zdiff(K... keys)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZDIFF. Summary: Subtract multiple sorted sets Group: sorted-set Requires Redis 6.2.0
    
    Specified by:
    
    zdiff in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    keys - the keys
    
    Returns:
    
    the result of the difference.
  - zdiffWithScores
```
public io.smallrye.mutiny.Uni<List<ScoredValue<V>>> zdiffWithScores(K... keys)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZDIFF. Summary: Subtract multiple sorted sets, and returns the list of keys with their scores Group: sorted-set Requires Redis 6.2.0
    
    Specified by:
    
    zdiffWithScores in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    keys - the keys
    
    Returns:
    
    the result of the difference.
  - zdiffstore
```
public io.smallrye.mutiny.Uni<Long> zdiffstore(K destination,
                                               K... keys)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZDIFFSTORE. Summary: Subtract multiple sorted sets and store the resulting sorted set in a new key Group: sorted-set Requires Redis 6.2.0
    
    Specified by:
    
    zdiffstore in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    destination - the destination key
    
    keys - the keys to compare
    
    Returns:
    
    the number of elements in the resulting sorted set at destination.
  - zincrby
```
public io.smallrye.mutiny.Uni<Double> zincrby(K key,
                                              double increment,
                                              V value)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZINCRBY. Summary: Increment the score of a member in a sorted set Group: sorted-set Requires Redis 1.2.0
    
    Specified by:
    
    zincrby in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    the new score of member.
  - zinter
```
public io.smallrye.mutiny.Uni<List<V>> zinter(ZAggregateArgs args,
                                              K... keys)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZINTER. Summary: Intersect multiple sorted sets Group: sorted-set Requires Redis 6.2.0
    
    Specified by:
    
    zinter in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    args - the ZINTER command extra-arguments
    
    keys - the keys
    
    Returns:
    
    the result of intersection.
  - zinter
```
public io.smallrye.mutiny.Uni<List<V>> zinter(K... keys)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZINTER. Summary: Intersect multiple sorted sets Group: sorted-set Requires Redis 6.2.0
    
    Specified by:
    
    zinter in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    keys - the keys
    
    Returns:
    
    the result of intersection.
  - zinterWithScores
```
public io.smallrye.mutiny.Uni<List<ScoredValue<V>>> zinterWithScores(ZAggregateArgs arguments,
                                                                     K... keys)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZINTER. Summary: Intersect multiple sorted sets Group: sorted-set Requires Redis 6.2.0
    
    Specified by:
    
    zinterWithScores in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    arguments - the ZINTER command extra-arguments
    
    keys - the keys
    
    Returns:
    
    the result of intersection with the scores
  - zinterWithScores
```
public io.smallrye.mutiny.Uni<List<ScoredValue<V>>> zinterWithScores(K... keys)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZINTER. Summary: Intersect multiple sorted sets Group: sorted-set Requires Redis 6.2.0
    
    Specified by:
    
    zinterWithScores in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    keys - the keys
    
    Returns:
    
    the result of intersection with the scores
  - zintercard
```
public io.smallrye.mutiny.Uni<Long> zintercard(K... keys)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZINTERCARD. Summary: Intersect multiple sorted sets and return the cardinality of the result Group: sorted-set Requires Redis 7.0.0
    
    Specified by:
    
    zintercard in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    keys - the keys
    
    Returns:
    
    the number of elements in the resulting intersection.
  - zintercard
```
public io.smallrye.mutiny.Uni<Long> zintercard(long limit,
                                               K... keys)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZINTERCARD. Summary: Intersect multiple sorted sets and return the cardinality of the result Group: sorted-set Requires Redis 7.0.0
    
    Specified by:
    
    zintercard in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    limit - if the intersection cardinality reaches limit partway through the computation, the algorithm will exit and yield limit as the cardinality.
    
    keys - the keys
    
    Returns:
    
    the number of elements in the resulting intersection.
  - zinterstore
```
public io.smallrye.mutiny.Uni<Long> zinterstore(K destination,
                                                ZAggregateArgs arguments,
                                                K... keys)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZINTERSTORE. Summary: Intersect multiple sorted sets and store the resulting sorted set in a new key Group: sorted-set Requires Redis 2.0.0
    
    Specified by:
    
    zinterstore in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    destination - the destination key
    
    arguments - the ZINTERSTORE command extra-arguments
    
    keys - the keys of the sorted set to analyze
    
    Returns:
    
    the number of elements in the resulting sorted set at destination.
  - zinterstore
```
@SafeVarargs
public final io.smallrye.mutiny.Uni<Long> zinterstore(K destination,
                                                      K... keys)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZINTERSTORE. Summary: Intersect multiple sorted sets and store the resulting sorted set in a new key Group: sorted-set Requires Redis 2.0.0
    
    Specified by:
    
    zinterstore in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    destination - the destination key
    
    keys - the keys of the sorted set to analyze
    
    Returns:
    
    the number of elements in the resulting sorted set at destination.
  - zlexcount
```
public io.smallrye.mutiny.Uni<Long> zlexcount(K key,
                                              Range<String> range)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZLEXCOUNT. Summary: Count the number of members in a sorted set between a given lexicographical range Group: sorted-set Requires Redis 2.8.9
    
    Specified by:
    
    zlexcount in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    range - the range
    
    Returns:
    
    the number of elements in the specified score range.
  - zmpopMin
```
public io.smallrye.mutiny.Uni<ScoredValue<V>> zmpopMin(K... keys)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZMPOP. Summary: Remove and return members with scores in a sorted set Group: sorted-set Requires Redis 7.0.0
    The elements popped are those with the lowest scores from the first non-empty sorted set.
    
    Specified by:
    
    zmpopMin in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    keys - the keys
    
    Returns:
    
    The popped element (value / score), or null if no element can be popped.
  - zmpopMin
```
public io.smallrye.mutiny.Uni<List<ScoredValue<V>>> zmpopMin(int count,
                                                             K... keys)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZMPOP. Summary: Remove and return members with scores in a sorted set Group: sorted-set Requires Redis 7.0.0
    The elements popped are those with the lowest scores from the first non-empty sorted set.
    
    Specified by:
    
    zmpopMin in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    count - the max number of element to pop
    
    keys - the keys
    
    Returns:
    
    The popped element (value / score), or empty if no element can be popped.
  - zmpopMax
```
public io.smallrye.mutiny.Uni<ScoredValue<V>> zmpopMax(K... keys)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZMPOP. Summary: Remove and return members with scores in a sorted set Group: sorted-set Requires Redis 7.0.0
    The elements with the highest scores to be popped.
    
    Specified by:
    
    zmpopMax in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    keys - the keys
    
    Returns:
    
    The popped element (value / score), or null if no element can be popped.
  - zmpopMax
```
public io.smallrye.mutiny.Uni<List<ScoredValue<V>>> zmpopMax(int count,
                                                             K... keys)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZMPOP. Summary: Remove and return members with scores in a sorted set Group: sorted-set Requires Redis 7.0.0
    The elements with the highest scores to be popped.
    
    Specified by:
    
    zmpopMax in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    count - the max number of element to pop
    
    keys - the keys
    
    Returns:
    
    The popped element (value / score), or empty if no element can be popped.
  - bzmpopMin
```
public io.smallrye.mutiny.Uni<ScoredValue<V>> bzmpopMin(Duration timeout,
                                                        K... keys)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command BZMPOP. Summary: Remove and return members with scores in a sorted set or block until one is available. Group: sorted-set Requires Redis 7.0.0
    The elements popped are those with the lowest scores from the first non-empty sorted set.
    
    Specified by:
    
    bzmpopMin in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    timeout - the timeout
    
    keys - the keys
    
    Returns:
    
    The popped element (value / score), or null if no element can be popped.
  - bzmpopMin
```
public io.smallrye.mutiny.Uni<List<ScoredValue<V>>> bzmpopMin(Duration timeout,
                                                              int count,
                                                              K... keys)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command BZMPOP. Summary: Remove and return members with scores in a sorted set or block until one is available. Group: sorted-set Requires Redis 7.0.0
    The elements popped are those with the lowest scores from the first non-empty sorted set.
    
    Specified by:
    
    bzmpopMin in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    timeout - the timeout
    
    count - the max number of element to pop
    
    keys - the keys
    
    Returns:
    
    The popped element (value / score), or empty if no element can be popped.
  - bzmpopMax
```
public io.smallrye.mutiny.Uni<ScoredValue<V>> bzmpopMax(Duration timeout,
                                                        K... keys)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command BZMPOP. Summary: Remove and return members with scores in a sorted set or block until one is available. Group: sorted-set Requires Redis 7.0.0
    The elements with the highest scores to be popped.
    
    Specified by:
    
    bzmpopMax in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    timeout - the timeout
    
    keys - the keys
    
    Returns:
    
    The popped element (value / score), or null if no element can be popped.
  - bzmpopMax
```
public io.smallrye.mutiny.Uni<List<ScoredValue<V>>> bzmpopMax(Duration timeout,
                                                              int count,
                                                              K... keys)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command BZMPOP. Summary: Remove and return members with scores in a sorted set or block until one is available. Group: sorted-set Requires Redis 7.0.0
    The elements with the highest scores to be popped.
    
    Specified by:
    
    bzmpopMax in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    timeout - the timeout
    
    count - the max number of element to pop
    
    keys - the keys
    
    Returns:
    
    The popped element (value / score), or empty if no element can be popped.
  - zmscore
```
public io.smallrye.mutiny.Uni<List<Double>> zmscore(K key,
                                                    V... values)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZMSCORE. Summary: Get the score associated with the given members in a sorted set Group: sorted-set Requires Redis 6.2.0
    
    Specified by:
    
    zmscore in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    values - the members
    
    Returns:
    
    list of scores or null associated with the specified member values.
  - zpopmax
```
public io.smallrye.mutiny.Uni<ScoredValue<V>> zpopmax(K key)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZPOPMAX. Summary: Remove and return members with the highest scores in a sorted set Group: sorted-set Requires Redis 5.0.0
    
    Specified by:
    
    zpopmax in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    the popped element and score, ScoredValue.EMPTY is not found.
  - zpopmax
```
public io.smallrye.mutiny.Uni<List<ScoredValue<V>>> zpopmax(K key,
                                                            int count)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZPOPMAX. Summary: Remove and return members with the highest scores in a sorted set Group: sorted-set Requires Redis 5.0.0
    
    Specified by:
    
    zpopmax in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    the popped elements and scores.
  - zpopmin
```
public io.smallrye.mutiny.Uni<ScoredValue<V>> zpopmin(K key)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZPOPMIN. Summary: Remove and return members with the lowest scores in a sorted set Group: sorted-set Requires Redis 5.0.0
    
    Specified by:
    
    zpopmin in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    the popped element and score.
  - zpopmin
```
public io.smallrye.mutiny.Uni<List<ScoredValue<V>>> zpopmin(K key,
                                                            int count)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZPOPMIN. Summary: Remove and return members with the lowest scores in a sorted set Group: sorted-set Requires Redis 5.0.0
    
    Specified by:
    
    zpopmin in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    the popped elements and scores.
  - zrandmember
```
public io.smallrye.mutiny.Uni<V> zrandmember(K key)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZRANDMEMBER. Summary: Get one or multiple random elements from a sorted set Group: sorted-set Requires Redis 6.2.0
    
    Specified by:
    
    zrandmember in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    the randomly selected element, or null when key does not exist.
  - zrandmember
```
public io.smallrye.mutiny.Uni<List<V>> zrandmember(K key,
                                                   int count)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZRANDMEMBER. Summary: Get one or multiple random elements from a sorted set Group: sorted-set Requires Redis 6.2.0
    
    Specified by:
    
    zrandmember in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    count - the number of member to select
    
    Returns:
    
    the list of elements, or an empty array when key does not exist.
  - zrandmemberWithScores
```
public io.smallrye.mutiny.Uni<ScoredValue<V>> zrandmemberWithScores(K key)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZRANDMEMBER. Summary: Get one or multiple random elements from a sorted set Group: sorted-set Requires Redis 6.2.0
    
    Specified by:
    
    zrandmemberWithScores in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    the randomly selected element and its score, or null when key does not exist.
  - zrandmemberWithScores
```
public io.smallrye.mutiny.Uni<List<ScoredValue<V>>> zrandmemberWithScores(K key,
                                                                          int count)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZRANDMEMBER. Summary: Get one or multiple random elements from a sorted set Group: sorted-set Requires Redis 6.2.0
    
    Specified by:
    
    zrandmemberWithScores in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    count - the number of member to select
    
    Returns:
    
    the list of elements (with their score), or an empty array when key does not exist.
  - bzpopmin
```
@SafeVarargs
public final io.smallrye.mutiny.Uni<KeyValue<K,ScoredValue<V>>> bzpopmin(Duration timeout,
                                                                               K... keys)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command BZPOPMIN. Summary: Remove and return the member with the lowest score from one or more sorted sets, or block until one is available Group: sorted-set Requires Redis 5.0.0
    
    Specified by:
    
    bzpopmin in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    timeout - the max timeout
    
    keys - the keys
    
    Returns:
    
    null when no element could be popped and the timeout expired. A structure containing the key and the ScoredValue with the popped value and the score.
  - bzpopmax
```
@SafeVarargs
public final io.smallrye.mutiny.Uni<KeyValue<K,ScoredValue<V>>> bzpopmax(Duration timeout,
                                                                               K... keys)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command BZPOPMAX. Summary: Remove and return the member with the highest score from one or more sorted sets, or block until one is available Group: sorted-set Requires Redis 5.0.0
    
    Specified by:
    
    bzpopmax in interface ReactiveSortedSetCommands<K,V>
    
    Returns:
    
    null when no element could be popped and the timeout expired. A structure containing the key and the ScoredValue with the popped value and the score.
  - zrange
```
public io.smallrye.mutiny.Uni<List<V>> zrange(K key,
                                              long start,
                                              long stop,
                                              ZRangeArgs args)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZRANGE. Summary: Return a range of members in a sorted set Group: sorted-set Requires Redis 1.2.0
    This method extracts a range my rank/index in the stream.
    
    Specified by:
    
    zrange in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    start - the start position
    
    stop - the stop position
    
    args - the extra ZRANGE parameters
    
    Returns:
    
    list of elements in the specified range.
  - zrangeWithScores
```
public io.smallrye.mutiny.Uni<List<ScoredValue<V>>> zrangeWithScores(K key,
                                                                     long start,
                                                                     long stop,
                                                                     ZRangeArgs args)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZRANGE. Summary: Return a range of members in a sorted set Group: sorted-set Requires Redis 1.2.0
    
    Specified by:
    
    zrangeWithScores in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    start - the start position
    
    stop - the stop position
    
    args - the extra ZRANGE parameters
    
    Returns:
    
    list of elements with their scores in the specified range.
  - zrange
```
public io.smallrye.mutiny.Uni<List<V>> zrange(K key,
                                              long start,
                                              long stop)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZRANGE. Summary: Return a range of members in a sorted set Group: sorted-set Requires Redis 1.2.0
    This method extracts a range my rank/index in the stream.
    
    Specified by:
    
    zrange in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    start - the start position
    
    stop - the stop position
    
    Returns:
    
    list of elements in the specified range.
  - zrangeWithScores
```
public io.smallrye.mutiny.Uni<List<ScoredValue<V>>> zrangeWithScores(K key,
                                                                     long start,
                                                                     long stop)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZRANGE. Summary: Return a range of members in a sorted set Group: sorted-set Requires Redis 1.2.0
    
    Specified by:
    
    zrangeWithScores in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    start - the start position
    
    stop - the stop position
    
    Returns:
    
    list of elements with their scores in the specified range.
  - zrangebylex
```
public io.smallrye.mutiny.Uni<List<V>> zrangebylex(K key,
                                                   Range<String> range,
                                                   ZRangeArgs args)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZRANGE. Summary: Return a range of members in a sorted set using lexicographical ranges Group: sorted-set Requires Redis 1.2.0
    
    Specified by:
    
    zrangebylex in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    range - the range
    
    args - the extra ZRANGE parameters
    
    Returns:
    
    list of elements in the specified range.
  - zrangebylex
```
public io.smallrye.mutiny.Uni<List<V>> zrangebylex(K key,
                                                   Range<String> range)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZRANGE. Summary: Return a range of members in a sorted set using lexicographical ranges Group: sorted-set Requires Redis 1.2.0
    
    Specified by:
    
    zrangebylex in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    range - the range
    
    Returns:
    
    list of elements in the specified range.
  - zrangebyscore
```
public io.smallrye.mutiny.Uni<List<V>> zrangebyscore(K key,
                                                     ScoreRange<Double> range,
                                                     ZRangeArgs args)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZRANGE. Summary: Return a range of members in a sorted set using score ranges Group: sorted-set Requires Redis 1.2.0
    
    Specified by:
    
    zrangebyscore in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    range - the range
    
    args - the extra ZRANGE parameters
    
    Returns:
    
    list of elements in the specified range.
  - zrangebyscoreWithScores
```
public io.smallrye.mutiny.Uni<List<ScoredValue<V>>> zrangebyscoreWithScores(K key,
                                                                            ScoreRange<Double> range,
                                                                            ZRangeArgs args)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZRANGE. Summary: Return a range of members in a sorted set using lexicographical ranges Group: sorted-set Requires Redis 1.2.0
    
    Specified by:
    
    zrangebyscoreWithScores in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    range - the range
    
    args - the extra ZRANGE parameters
    
    Returns:
    
    list of elements with their scores in the specified range.
  - zrangebyscore
```
public io.smallrye.mutiny.Uni<List<V>> zrangebyscore(K key,
                                                     ScoreRange<Double> range)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZRANGE. Summary: Return a range of members in a sorted set using score ranges Group: sorted-set Requires Redis 1.2.0
    
    Specified by:
    
    zrangebyscore in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    range - the range
    
    Returns:
    
    list of elements in the specified range.
  - zrangebyscoreWithScores
```
public io.smallrye.mutiny.Uni<List<ScoredValue<V>>> zrangebyscoreWithScores(K key,
                                                                            ScoreRange<Double> range)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZRANGE. Summary: Return a range of members in a sorted set using score ranges Group: sorted-set Requires Redis 1.2.0
    
    Specified by:
    
    zrangebyscoreWithScores in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    range - the range
    
    Returns:
    
    list of elements with their scores in the specified range.
  - zrangestore
```
public io.smallrye.mutiny.Uni<Long> zrangestore(K dst,
                                                K src,
                                                long min,
                                                long max,
                                                ZRangeArgs args)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZRANGESTORE. Summary: Store a range (by rank) of members from sorted set into another key Group: sorted-set Requires Redis 6.2.0
    
    Specified by:
    
    zrangestore in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    dst - the key
    
    src - the key
    
    min - the lower bound of the range
    
    max - the upper bound of the range
    
    args - the ZRANGESTORE command extra-arguments
    
    Returns:
    
    the number of elements in the resulting sorted set.
  - zrangestore
```
public io.smallrye.mutiny.Uni<Long> zrangestore(K dst,
                                                K src,
                                                long min,
                                                long max)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZRANGESTORE. Summary: Store a range (by rank) of members from sorted set into another key Group: sorted-set Requires Redis 6.2.0
    
    Specified by:
    
    zrangestore in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    dst - the key
    
    src - the key
    
    min - the lower bound of the range
    
    max - the upper bound of the range
    
    Returns:
    
    the number of elements in the resulting sorted set.
  - zrangestorebylex
```
public io.smallrye.mutiny.Uni<Long> zrangestorebylex(K dst,
                                                     K src,
                                                     Range<String> range,
                                                     ZRangeArgs args)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZRANGESTORE. Summary: Store a range (by lexicographical order) of members from sorted set into another key Group: sorted-set Requires Redis 6.2.0
    
    Specified by:
    
    zrangestorebylex in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    dst - the key
    
    src - the key
    
    range - the range
    
    args - the ZRANGESTORE command extra-arguments
    
    Returns:
    
    the number of elements in the resulting sorted set.
  - zrangestorebylex
```
public io.smallrye.mutiny.Uni<Long> zrangestorebylex(K dst,
                                                     K src,
                                                     Range<String> range)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZRANGESTORE. Summary: Store a range (by lexicographical order) of members from sorted set into another key Group: sorted-set Requires Redis 6.2.0
    
    Specified by:
    
    zrangestorebylex in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    dst - the key
    
    src - the key
    
    range - the range
    
    Returns:
    
    the number of elements in the resulting sorted set.
  - zrangestorebyscore
```
public io.smallrye.mutiny.Uni<Long> zrangestorebyscore(K dst,
                                                       K src,
                                                       ScoreRange<Double> range,
                                                       ZRangeArgs args)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZRANGESTORE. Summary: Store a range (by score order) of members from sorted set into another key Group: sorted-set Requires Redis 6.2.0
    
    Specified by:
    
    zrangestorebyscore in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    dst - the key
    
    src - the key
    
    range - the range
    
    args - the ZRANGESTORE command extra-arguments
    
    Returns:
    
    the number of elements in the resulting sorted set.
  - zrangestorebyscore
```
public io.smallrye.mutiny.Uni<Long> zrangestorebyscore(K dst,
                                                       K src,
                                                       ScoreRange<Double> range)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZRANGESTORE. Summary: Store a range (by score order) of members from sorted set into another key Group: sorted-set Requires Redis 6.2.0
    
    Specified by:
    
    zrangestorebyscore in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    dst - the key
    
    src - the key
    
    range - the range
    
    Returns:
    
    the number of elements in the resulting sorted set.
  - zrank
```
public io.smallrye.mutiny.Uni<Long> zrank(K key,
                                          V value)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZRANK. Summary: Determine the index of a member in a sorted set Group: sorted-set Requires Redis 2.0.0
    
    Specified by:
    
    zrank in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    the rank of member. If member does not exist in the sorted set or key does not exist, null.
  - zrem
```
public io.smallrye.mutiny.Uni<Integer> zrem(K key,
                                            V... values)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZREM. Summary: Remove one or more members from a sorted set Group: sorted-set Requires Redis 1.2.0
    
    Specified by:
    
    zrem in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    values - the members to remove
    
    Returns:
    
    The number of members removed from the sorted set, not including non-existing members.
  - zremrangebylex
```
public io.smallrye.mutiny.Uni<Long> zremrangebylex(K key,
                                                   Range<String> range)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZREMRANGEBYLEX. Summary: Remove all members in a sorted set between the given lexicographical range Group: sorted-set Requires Redis 2.8.9
    
    Specified by:
    
    zremrangebylex in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    range - the range
    
    Returns:
    
    the number of elements removed.
  - zremrangebyrank
```
public io.smallrye.mutiny.Uni<Long> zremrangebyrank(K key,
                                                    long start,
                                                    long stop)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZREMRANGEBYRANK. Summary: Remove all members in a sorted set within the given indexes Group: sorted-set Requires Redis 2.0.0
    
    Specified by:
    
    zremrangebyrank in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    start - the lower bound of the range
    
    stop - the upper bound of the range
    
    Returns:
    
    the number of elements removed.
  - zremrangebyscore
```
public io.smallrye.mutiny.Uni<Long> zremrangebyscore(K key,
                                                     ScoreRange<Double> range)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZREMRANGEBYSCORE. Summary: Remove all members in a sorted set within the given scores Group: sorted-set Requires Redis 1.2.0
    
    Specified by:
    
    zremrangebyscore in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    range - the range
    
    Returns:
    
    the number of elements removed.
  - zrevrank
```
public io.smallrye.mutiny.Uni<Long> zrevrank(K key,
                                             V value)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZREVRANK. Summary: Determine the index of a member in a sorted set, with scores ordered from high to low Group: sorted-set Requires Redis 2.0.0
    
    Specified by:
    
    zrevrank in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    the rank of member. If member does not exist in the sorted set or key does not exist, null.
  - zscan
```
public ReactiveZScanCursor<V> zscan(K key)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZSCAN. Summary: Incrementally iterate sorted sets elements and associated scores Group: sorted-set Requires Redis 2.8.0
    
    Specified by:
    
    zscan in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    the cursor to iterate over the sorted set
  - zscan
```
public ReactiveZScanCursor<V> zscan(K key,
                                    ScanArgs args)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZSCAN. Summary: Incrementally iterate sorted sets elements and associated scores Group: sorted-set Requires Redis 2.8.0
    
    Specified by:
    
    zscan in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    args - the extra scan arguments
    
    Returns:
    
    the cursor to iterate over the sorted set
  - zscore
```
public io.smallrye.mutiny.Uni<Double> zscore(K key,
                                             V value)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZSCORE. Summary: Get the score associated with the given member in a sorted set Group: sorted-set Requires Redis 1.2.0
    
    Specified by:
    
    zscore in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    key - the key
    
    value - the member
    
    Returns:
    
    the score of member, null if the member cannot be found or the key does not exist
  - zunion
```
public io.smallrye.mutiny.Uni<List<V>> zunion(ZAggregateArgs args,
                                              K... keys)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZUNION. Summary: Add multiple sorted sets Group: sorted-set Requires Redis 6.2.0
    
    Specified by:
    
    zunion in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    args - the ZUNION command extra-arguments
    
    keys - the keys
    
    Returns:
    
    the result of union
  - zunion
```
public io.smallrye.mutiny.Uni<List<V>> zunion(K... keys)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZUNION. Summary: Add multiple sorted sets Group: sorted-set Requires Redis 6.2.0
    
    Specified by:
    
    zunion in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    keys - the keys
    
    Returns:
    
    the result of union
  - zunionWithScores
```
public io.smallrye.mutiny.Uni<List<ScoredValue<V>>> zunionWithScores(K... keys)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZUNION. Summary: Add multiple sorted sets Group: sorted-set Requires Redis 6.2.0
    
    Specified by:
    
    zunionWithScores in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    keys - the keys
    
    Returns:
    
    the result of union
  - zunionWithScores
```
public io.smallrye.mutiny.Uni<List<ScoredValue<V>>> zunionWithScores(ZAggregateArgs args,
                                                                     K... keys)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZUNION. Summary: Add multiple sorted sets Group: sorted-set Requires Redis 6.2.0
    
    Specified by:
    
    zunionWithScores in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    args - the ZUNION command extra-arguments
    
    keys - the keys
    
    Returns:
    
    the result of union
  - zunionstore
```
public io.smallrye.mutiny.Uni<Long> zunionstore(K destination,
                                                ZAggregateArgs args,
                                                K... keys)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZUNIONSTORE. Summary: Add multiple sorted sets and store the resulting sorted set in a new key Group: sorted-set Requires Redis 2.0.0
    
    Specified by:
    
    zunionstore in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    destination - the destination key
    
    args - the zunionstore command extra-arguments
    
    keys - the keys
    
    Returns:
    
    the number of elements in the resulting sorted set at destination.
  - zunionstore
```
public io.smallrye.mutiny.Uni<Long> zunionstore(K destination,
                                                K... keys)
```
    Description copied from interface: ReactiveSortedSetCommands
    
    Execute the command ZUNIONSTORE. Summary: Add multiple sorted sets and store the resulting sorted set in a new key Group: sorted-set Requires Redis 2.0.0
    
    Specified by:
    
    zunionstore in interface ReactiveSortedSetCommands<K,V>
    
    Parameters:
    
    destination - the destination key
    
    keys - the keys
    
    Returns:
    
    the number of elements in the resulting sorted set at destination.

Class ReactiveSortedSetCommandsImpl<K,​V>

Field Summary

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

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

Constructor Summary

Method Summary

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

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

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

Methods inherited from class java.lang.Object

Methods inherited from interface io.quarkus.redis.datasource.sortedset.ReactiveSortedSetCommands

Constructor Detail

ReactiveSortedSetCommandsImpl

Method Detail

getDataSource

zadd

zadd

zadd

zadd

zadd

zadd

zaddincr

zaddincr

zcard

zcount

zdiff

zdiffWithScores

zdiffstore

zincrby

zinter

zinter

zinterWithScores

zinterWithScores

zintercard

zintercard

zinterstore

zinterstore

zlexcount

zmpopMin

zmpopMin

zmpopMax

zmpopMax

bzmpopMin

bzmpopMin

bzmpopMax

bzmpopMax

zmscore

zpopmax

zpopmax

zpopmin

zpopmin

zrandmember

zrandmember

zrandmemberWithScores

zrandmemberWithScores

bzpopmin

bzpopmax

zrange

zrangeWithScores

zrange

zrangeWithScores

zrangebylex

zrangebylex

zrangebyscore

zrangebyscoreWithScores

zrangebyscore

zrangebyscoreWithScores

zrangestore

zrangestore

zrangestorebylex

zrangestorebylex

zrangestorebyscore

zrangestorebyscore

zrank

zrem

zremrangebylex

zremrangebyrank

zremrangebyscore

zrevrank

zscan

Class ReactiveSortedSetCommandsImpl<K,V>