public interface ReactiveZSetOperations<K,V>

Reactive Redis operations for Sorted (ZSet) Commands.

Streams of methods returning Mono<K> or Flux<M> are terminated with InvalidDataAccessApiUsageException when RedisElementReader.read(ByteBuffer) returns null for a particular element as Reactive Streams prohibit the usage of null values.

Since:

2.0

Author:

Mark Paluch, Christoph Strobl, Andrey Shlykov

See Also:

Redis Documentation: Sorted Set Commands

Method Summary

Modifier and Type

Method

Description

Mono<Boolean>

add(K key, V value, double score)

Add value to a sorted set at key, or update its score if it already exists.

Mono<Long>

addAll(K key, Collection<? extends ZSetOperations.TypedTuple<V>> tuples)

Add tuples to a sorted set at key, or update their score if it already exists.

Mono<Long>

count(K key, Range<Double> range)

Count number of elements within sorted set with scores between min and max.

Mono<Boolean>

delete(K key)

Removes the given key.

Flux<V>

difference(K key, Collection<K> otherKeys)

Diff sorted sets.

default Flux<V>

difference(K key, K otherKey)

Diff sorted sets.

Mono<Long>

differenceAndStore(K key, Collection<K> otherKeys, K destKey)

Diff sorted sets and store result in destination destKey.

default Mono<Long>

differenceAndStore(K key, K otherKey, K destKey)

Diff sorted sets and store result in destination destKey.

Flux<ZSetOperations.TypedTuple<V>>

differenceWithScores(K key, Collection<K> otherKeys)

Diff sorted sets.

default Flux<ZSetOperations.TypedTuple<V>>

differenceWithScores(K key, K otherKey)

Diff sorted sets.

Flux<V>

distinctRandomMembers(K key, long count)

Get count distinct random elements from set at key.

Flux<ZSetOperations.TypedTuple<V>>

distinctRandomMembersWithScore(K key, long count)

Get count distinct random elements with their score from set at key.

Mono<Double>

incrementScore(K key, V value, double delta)

Increment the score of element with value in sorted set by increment.

Flux<V>

intersect(K key, Collection<K> otherKeys)

Intersect sorted sets.

default Flux<V>

intersect(K key, K otherKey)

Intersect sorted sets.

Mono<Long>

intersectAndStore(K key, Collection<K> otherKeys, K destKey)

Intersect sorted sets at key and otherKeys and store result in destination destKey.

default Mono<Long>

intersectAndStore(K key, Collection<K> otherKeys, K destKey, Aggregate aggregate)

Intersect sorted sets at key and otherKeys and store result in destination destKey.

Mono<Long>

intersectAndStore(K key, Collection<K> otherKeys, K destKey, Aggregate aggregate, Weights weights)

Intersect sorted sets at key and otherKeys and store result in destination destKey.

default Mono<Long>

intersectAndStore(K key, K otherKey, K destKey)

Intersect sorted sets at key and otherKey and store result in destination destKey.

Flux<ZSetOperations.TypedTuple<V>>

intersectWithScores(K key, Collection<K> otherKeys)

Intersect sorted sets.

default Flux<ZSetOperations.TypedTuple<V>>

intersectWithScores(K key, Collection<K> otherKeys, Aggregate aggregate)

Intersect sorted sets at key and otherKeys .

Flux<ZSetOperations.TypedTuple<V>>

intersectWithScores(K key, Collection<K> otherKeys, Aggregate aggregate, Weights weights)

Intersect sorted sets.

default Flux<ZSetOperations.TypedTuple<V>>

intersectWithScores(K key, K otherKey)

Intersect sorted sets.

Mono<Long>

lexCount(K key, Range<String> range)

Count number of elements within sorted set with a value between Range.getLowerBound() and Range.getUpperBound() applying lexicographical ordering.

Mono<ZSetOperations.TypedTuple<V>>

popMax(K key)

Remove and return the value with its score having the highest score from sorted set at key.

Flux<ZSetOperations.TypedTuple<V>>

popMax(K key, long count)

Remove and return count values with their score having the highest score from sorted set at key.

Mono<ZSetOperations.TypedTuple<V>>

popMax(K key, Duration timeout)

Remove and return the value with its score having the highest score from sorted set at key.

Mono<ZSetOperations.TypedTuple<V>>

popMin(K key)

Remove and return the value with its score having the lowest score from sorted set at key.

Flux<ZSetOperations.TypedTuple<V>>

popMin(K key, long count)

Remove and return count values with their score having the lowest score from sorted set at key.

Mono<ZSetOperations.TypedTuple<V>>

popMin(K key, Duration timeout)

Remove and return the value with its score having the lowest score from sorted set at key.

Mono<V>

randomMember(K key)

Get random element from set at key.

Flux<V>

randomMembers(K key, long count)

Get count random elements from set at key.

Flux<ZSetOperations.TypedTuple<V>>

randomMembersWithScore(K key, long count)

Get count random elements with their score from set at key.

Mono<ZSetOperations.TypedTuple<V>>

randomMemberWithScore(K key)

Get random element with its score from set at key.

Flux<V>

range(K key, Range<Long> range)

Get elements between start and end from sorted set.

default Mono<Long>

rangeAndStoreByLex(K srcKey, K dstKey, Range<String> range)

Store all elements at dstKey with lexicographical ordering from ZSET at srcKey with a value between Range.getLowerBound() and Range.getUpperBound().

Mono<Long>

rangeAndStoreByLex(K srcKey, K dstKey, Range<String> range, Limit limit)

Store n elements at dstKey, where n = Limit.getCount(), starting at Limit.getOffset() with lexicographical ordering from ZSET at srcKey with a value between Range.getLowerBound() and Range.getUpperBound().

default Mono<Long>

rangeAndStoreByScore(K srcKey, K dstKey, Range<Double> range)

Store all elements at dstKey with ordering by score from ZSET at srcKey with a score between Range.getLowerBound() and Range.getUpperBound().

Mono<Long>

rangeAndStoreByScore(K srcKey, K dstKey, Range<Double> range, Limit limit)

Store n elements at dstKey, where n = Limit.getCount(), starting at Limit.getOffset() with ordering by score from ZSET at srcKey with a score between Range.getLowerBound() and Range.getUpperBound().

Flux<V>

rangeByLex(K key, Range<String> range)

Get all elements with lexicographical ordering from ZSET at key with a value between Range.getLowerBound() and Range.getUpperBound().

Flux<V>

rangeByLex(K key, Range<String> range, Limit limit)

Get all elements n elements, where n = Limit.getCount(), starting at Limit.getOffset() with lexicographical ordering from ZSET at key with a value between Range.getLowerBound() and Range.getUpperBound().

Flux<V>

rangeByScore(K key, Range<Double> range)

Get elements where score is between min and max from sorted set.

Flux<V>

rangeByScore(K key, Range<Double> range, Limit limit)

Get elements in range from start to end where score is between min and max from sorted set.

Flux<ZSetOperations.TypedTuple<V>>

rangeByScoreWithScores(K key, Range<Double> range)

Get set of Tuples where score is between min and max from sorted set.

Flux<ZSetOperations.TypedTuple<V>>

rangeByScoreWithScores(K key, Range<Double> range, Limit limit)

Get set of Tuples in range from start to end where score is between min and max from sorted set.

Flux<ZSetOperations.TypedTuple<V>>

rangeWithScores(K key, Range<Long> range)

Get set of Tuples between start and end from sorted set.

Mono<Long>

rank(K key, Object o)

Determine the index of element with value in a sorted set.

Mono<Long>

remove(K key, Object... values)

Remove values from sorted set.

Mono<Long>

removeRange(K key, Range<Long> range)

Remove elements in range between start and end from sorted set with key.

Mono<Long>

removeRangeByLex(K key, Range<String> range)

Remove elements in range from sorted set with key.

Mono<Long>

removeRangeByScore(K key, Range<Double> range)

Remove elements with scores between min and max from sorted set with key.

Flux<V>

reverseRange(K key, Range<Long> range)

Get elements in range from start to end from sorted set ordered from high to low.

default Mono<Long>

reverseRangeAndStoreByLex(K srcKey, K dstKey, Range<String> range)

Store all elements at dstKey with reverse lexicographical ordering from ZSET at srcKey with a value between Range.getLowerBound() and Range.getUpperBound().

Mono<Long>

reverseRangeAndStoreByLex(K srcKey, K dstKey, Range<String> range, Limit limit)

Store n elements at dstKey, where n = Limit.getCount(), starting at Limit.getOffset() with reverse lexicographical ordering from ZSET at srcKey with a value between Range.getLowerBound() and Range.getUpperBound().

default Mono<Long>

reverseRangeAndStoreByScore(K srcKey, K dstKey, Range<Double> range)

Store all elements at dstKey with reverse ordering by score from ZSET at srcKey with a score between Range.getLowerBound() and Range.getUpperBound().

Mono<Long>

reverseRangeAndStoreByScore(K srcKey, K dstKey, Range<Double> range, Limit limit)

Store n elements at dstKey, where n = Limit.getCount(), starting at Limit.getOffset() with reverse ordering by score from ZSET at srcKey with a score between Range.getLowerBound() and Range.getUpperBound().

Flux<V>

reverseRangeByLex(K key, Range<String> range)

Get all elements with reverse lexicographical ordering from ZSET at key with a value between Range.getLowerBound() and Range.getUpperBound().

Flux<V>

reverseRangeByLex(K key, Range<String> range, Limit limit)

Get all elements n elements, where n = Limit.getCount(), starting at Limit.getOffset() with reverse lexicographical ordering from ZSET at key with a value between Range.getLowerBound() and Range.getUpperBound().

Flux<V>

reverseRangeByScore(K key, Range<Double> range)

Get elements where score is between min and max from sorted set ordered from high to low.

Flux<V>

reverseRangeByScore(K key, Range<Double> range, Limit limit)

Get elements in range from start to end where score is between min and max from sorted set ordered high -> low.

Flux<ZSetOperations.TypedTuple<V>>

reverseRangeByScoreWithScores(K key, Range<Double> range)

Get set of Tuple where score is between min and max from sorted set ordered from high to low.

Flux<ZSetOperations.TypedTuple<V>>

reverseRangeByScoreWithScores(K key, Range<Double> range, Limit limit)

Get set of Tuple in range from start to end where score is between min and max from sorted set ordered high -> low.

Flux<ZSetOperations.TypedTuple<V>>

reverseRangeWithScores(K key, Range<Long> range)

Get set of Tuples in range from start to end from sorted set ordered from high to low.

Mono<Long>

reverseRank(K key, Object o)

Determine the index of element with value in a sorted set when scored high to low.

default Flux<ZSetOperations.TypedTuple<V>>

scan(K key)

Use a Flux to iterate over entries in the sorted set at key.

Flux<ZSetOperations.TypedTuple<V>>

scan(K key, ScanOptions options)

Use a Flux to iterate over entries in the sorted set at key given ScanOptions.

Mono<Double>

score(K key, Object o)

Get the score of element with value from sorted set with key key.

Mono<List<Double>>

score(K key, Object... o)

Get the scores of elements with values from sorted set with key key.

Mono<Long>

size(K key)

Returns the number of elements of the sorted set stored with given key.

Flux<V>

union(K key, Collection<K> otherKeys)

Union sorted sets.

default Flux<V>

union(K key, K otherKey)

Union sorted sets.

Mono<Long>

unionAndStore(K key, Collection<K> otherKeys, K destKey)

Union sorted sets at key and otherKeys and store result in destination destKey.

default Mono<Long>

unionAndStore(K key, Collection<K> otherKeys, K destKey, Aggregate aggregate)

Union sorted sets at key and otherKeys and store result in destination destKey.

Mono<Long>

unionAndStore(K key, Collection<K> otherKeys, K destKey, Aggregate aggregate, Weights weights)

Union sorted sets at key and otherKeys and store result in destination destKey.

Mono<Long>

unionAndStore(K key, K otherKey, K destKey)

Union sorted sets at key and otherKeys and store result in destination destKey.

Flux<ZSetOperations.TypedTuple<V>>

unionWithScores(K key, Collection<K> otherKeys)

Union sorted sets.

default Flux<ZSetOperations.TypedTuple<V>>

unionWithScores(K key, Collection<K> otherKeys, Aggregate aggregate)

Union sorted sets at key and otherKeys .

Flux<ZSetOperations.TypedTuple<V>>

unionWithScores(K key, Collection<K> otherKeys, Aggregate aggregate, Weights weights)

Union sorted sets.

default Flux<ZSetOperations.TypedTuple<V>>

unionWithScores(K key, K otherKey)

Union sorted sets.

Method Details
- add
  
  Mono<Boolean> add(K key, V value, double score)
  
  Add value to a sorted set at key, or update its score if it already exists.
  Parameters:
  
  key - must not be null.
  
  value - the value.
  
  score - the score.
  
  Returns:
  
  See Also:
  
  Redis Documentation: ZADD
- addAll
  
  Mono<Long> addAll(K key, Collection<? extends ZSetOperations.TypedTuple<V>> tuples)
  
  Add tuples to a sorted set at key, or update their score if it already exists.
  Parameters:
  
  key - must not be null.
  
  tuples - the score.
  
  Returns:
  
  See Also:
  
  Redis Documentation: ZADD
- remove
  
  Mono<Long> remove(K key, Object... values)
  
  Remove values from sorted set. Return number of removed elements.
  Parameters:
  
  key - must not be null.
  
  values - must not be null.
  
  Returns:
  
  See Also:
  
  Redis Documentation: ZREM
- incrementScore
  
  Mono<Double> incrementScore(K key, V value, double delta)
  
  Increment the score of element with value in sorted set by increment.
  Parameters:
  
  key - must not be null.
  
  value - the value.
  
  delta - the delta to add. Can be negative.
  
  Returns:
  
  See Also:
  
  Redis Documentation: ZINCRBY
- randomMember
  
  Mono<V> randomMember(K key)
  
  Get random element from set at key.
  Parameters:
  
  key - must not be null.
  
  Returns:
  
  Since:
  
  2.6
  
  See Also:
  
  Redis Documentation: ZRANDMEMBER
- distinctRandomMembers
  
  Flux<V> distinctRandomMembers(K key, long count)
  
  Get count distinct random elements from set at key.
  Parameters:
  
  key - must not be null.
  
  count - number of members to return.
  
  Returns:
  
  Throws:
  
  IllegalArgumentException - if count is negative.
  
  Since:
  
  2.6
  
  See Also:
  
  Redis Documentation: ZRANDMEMBER
- randomMembers
  
  Flux<V> randomMembers(K key, long count)
  
  Get count random elements from set at key.
  Parameters:
  
  key - must not be null.
  
  count - number of members to return.
  
  Returns:
  
  Throws:
  
  IllegalArgumentException - if count is negative.
  
  Since:
  
  2.6
  
  See Also:
  
  Redis Documentation: ZRANDMEMBER
- randomMemberWithScore
  
  Mono<ZSetOperations.TypedTuple<V>> randomMemberWithScore(K key)
  
  Get random element with its score from set at key.
  Parameters:
  
  key - must not be null.
  
  Returns:
  
  Since:
  
  2.6
  
  See Also:
  
  Redis Documentation: ZRANDMEMBER
- distinctRandomMembersWithScore
  
  Flux<ZSetOperations.TypedTuple<V>> distinctRandomMembersWithScore(K key, long count)
  
  Get count distinct random elements with their score from set at key.
  Parameters:
  
  key - must not be null.
  
  count - number of members to return.
  
  Returns:
  
  Throws:
  
  IllegalArgumentException - if count is negative.
  
  Since:
  
  2.6
  
  See Also:
  
  Redis Documentation: ZRANDMEMBER
- randomMembersWithScore
  
  Flux<ZSetOperations.TypedTuple<V>> randomMembersWithScore(K key, long count)
  
  Get count random elements with their score from set at key.
  Parameters:
  
  key - must not be null.
  
  count - number of members to return.
  
  Returns:
  
  Throws:
  
  IllegalArgumentException - if count is negative.
  
  Since:
  
  2.6
  
  See Also:
  
  Redis Documentation: ZRANDMEMBER
- rank
  
  Mono<Long> rank(K key, Object o)
  
  Determine the index of element with value in a sorted set.
  Parameters:
  
  key - must not be null.
  
  o - the value.
  
  Returns:
  
  See Also:
  
  Redis Documentation: ZRANK
- reverseRank
  
  Mono<Long> reverseRank(K key, Object o)
  
  Determine the index of element with value in a sorted set when scored high to low.
  Parameters:
  
  key - must not be null.
  
  o - the value.
  
  Returns:
  
  See Also:
  
  Redis Documentation: ZREVRANK
- range
  
  Flux<V> range(K key, Range<Long> range)
  
  Get elements between start and end from sorted set.
  Parameters:
  
  key - must not be null.
  
  range - must not be null.
  
  Returns:
  
  See Also:
  
  Redis Documentation: ZRANGE
- rangeWithScores
  
  Flux<ZSetOperations.TypedTuple<V>> rangeWithScores(K key, Range<Long> range)
  
  Get set of Tuples between start and end from sorted set.
  Parameters:
  
  key - must not be null.
  
  range - must not be null.
  
  Returns:
  
  See Also:
  
  Redis Documentation: ZRANGE
- rangeByScore
  
  Flux<V> rangeByScore(K key, Range<Double> range)
  
  Get elements where score is between min and max from sorted set.
  Parameters:
  
  key - must not be null.
  
  range - must not be null.
  
  Returns:
  
  See Also:
  
  Redis Documentation: ZRANGEBYSCORE
- rangeByScoreWithScores
  
  Flux<ZSetOperations.TypedTuple<V>> rangeByScoreWithScores(K key, Range<Double> range)
  
  Get set of Tuples where score is between min and max from sorted set.
  Parameters:
  
  key - must not be null.
  
  range - must not be null.
  
  Returns:
  
  See Also:
  
  Redis Documentation: ZRANGEBYSCORE
- rangeByScore
  
  Flux<V> rangeByScore(K key, Range<Double> range, Limit limit)
  
  Get elements in range from start to end where score is between min and max from sorted set.
  Parameters:
  
  key - must not be null.
  
  range -
  
  limit -
  
  Returns:
  
  See Also:
  
  Redis Documentation: ZRANGEBYSCORE
- rangeByScoreWithScores
  
  Flux<ZSetOperations.TypedTuple<V>> rangeByScoreWithScores(K key, Range<Double> range, Limit limit)
  
  Get set of Tuples in range from start to end where score is between min and max from sorted set.
  Parameters:
  
  key -
  
  range -
  
  limit -
  
  Returns:
  
  See Also:
  
  Redis Documentation: ZRANGEBYSCORE
- reverseRange
  
  Flux<V> reverseRange(K key, Range<Long> range)
  
  Get elements in range from start to end from sorted set ordered from high to low.
  Parameters:
  
  key - must not be null.
  
  range -
  
  Returns:
  
  See Also:
  
  Redis Documentation: ZREVRANGE
- reverseRangeWithScores
  
  Flux<ZSetOperations.TypedTuple<V>> reverseRangeWithScores(K key, Range<Long> range)
  
  Get set of Tuples in range from start to end from sorted set ordered from high to low.
  Parameters:
  
  key - must not be null.
  
  range -
  
  Returns:
  
  See Also:
  
  Redis Documentation: ZREVRANGE
- reverseRangeByScore
  
  Flux<V> reverseRangeByScore(K key, Range<Double> range)
  
  Get elements where score is between min and max from sorted set ordered from high to low.
  Parameters:
  
  key - must not be null.
  
  range -
  
  Returns:
  
  See Also:
  
  Redis Documentation: ZREVRANGEBYSCORE
- reverseRangeByScoreWithScores
  
  Flux<ZSetOperations.TypedTuple<V>> reverseRangeByScoreWithScores(K key, Range<Double> range)
  
  Get set of Tuple where score is between min and max from sorted set ordered from high to low.
  Parameters:
  
  key - must not be null.
  
  range -
  
  Returns:
  
  See Also:
  
  Redis Documentation: ZREVRANGEBYSCORE
- reverseRangeByScore
  
  Flux<V> reverseRangeByScore(K key, Range<Double> range, Limit limit)
  
  Get elements in range from start to end where score is between min and max from sorted set ordered high -> low.
  Parameters:
  
  key - must not be null.
  
  range -
  
  limit -
  
  Returns:
  
  See Also:
  
  Redis Documentation: ZREVRANGEBYSCORE
- reverseRangeByScoreWithScores
  
  Flux<ZSetOperations.TypedTuple<V>> reverseRangeByScoreWithScores(K key, Range<Double> range, Limit limit)
  
  Get set of Tuple in range from start to end where score is between min and max from sorted set ordered high -> low.
  Parameters:
  
  key - must not be null.
  
  range -
  
  limit -
  
  Returns:
  
  See Also:
  
  Redis Documentation: ZREVRANGEBYSCORE
- rangeAndStoreByLex
  
  default Mono<Long> rangeAndStoreByLex(K srcKey, K dstKey, Range<String> range)
  
  Store all elements at dstKey with lexicographical ordering from ZSET at srcKey with a value between Range.getLowerBound() and Range.getUpperBound().
  Parameters:
  
  srcKey - must not be null.
  
  dstKey - must not be null.
  
  range - must not be null.
  
  Returns:
  
  the number of stored elements.
  
  Since:
  
  3.0
  
  See Also:
  
  Redis Documentation: ZRANGESTORE
- rangeAndStoreByLex
  
  Mono<Long> rangeAndStoreByLex(K srcKey, K dstKey, Range<String> range, Limit limit)
  
  Store n elements at dstKey, where n = Limit.getCount(), starting at Limit.getOffset() with lexicographical ordering from ZSET at srcKey with a value between Range.getLowerBound() and Range.getUpperBound().
  Parameters:
  
  srcKey - must not be null.
  
  dstKey - must not be null.
  
  range - must not be null.
  
  limit - must not be null.
  
  Returns:
  
  the number of stored elements.
  
  Since:
  
  3.0
  
  See Also:
  
  Redis Documentation: ZRANGESTORE
- reverseRangeAndStoreByLex
  
  default Mono<Long> reverseRangeAndStoreByLex(K srcKey, K dstKey, Range<String> range)
  
  Store all elements at dstKey with reverse lexicographical ordering from ZSET at srcKey with a value between Range.getLowerBound() and Range.getUpperBound().
  Parameters:
  
  srcKey - must not be null.
  
  dstKey - must not be null.
  
  range - must not be null.
  
  Returns:
  
  the number of stored elements.
  
  Since:
  
  3.0
  
  See Also:
  
  Redis Documentation: ZRANGESTORE
- reverseRangeAndStoreByLex
  
  Mono<Long> reverseRangeAndStoreByLex(K srcKey, K dstKey, Range<String> range, Limit limit)
  
  Store n elements at dstKey, where n = Limit.getCount(), starting at Limit.getOffset() with reverse lexicographical ordering from ZSET at srcKey with a value between Range.getLowerBound() and Range.getUpperBound().
  Parameters:
  
  srcKey - must not be null.
  
  dstKey - must not be null.
  
  range - must not be null.
  
  limit - must not be null.
  
  Returns:
  
  the number of stored elements.
  
  Since:
  
  3.0
  
  See Also:
  
  reverseRangeByLex(Object, Range, Limit)
  
  Redis Documentation: ZRANGESTORE
- rangeAndStoreByScore
  
  @Nullable default Mono<Long> rangeAndStoreByScore(K srcKey, K dstKey, Range<Double> range)
  
  Store all elements at dstKey with ordering by score from ZSET at srcKey with a score between Range.getLowerBound() and Range.getUpperBound().
  Parameters:
  
  srcKey - must not be null.
  
  dstKey - must not be null.
  
  range - must not be null.
  
  Returns:
  
  the number of stored elements.
  
  Since:
  
  3.0
  
  See Also:
  
  Redis Documentation: ZRANGESTORE
- rangeAndStoreByScore
  
  Mono<Long> rangeAndStoreByScore(K srcKey, K dstKey, Range<Double> range, Limit limit)
  
  Store n elements at dstKey, where n = Limit.getCount(), starting at Limit.getOffset() with ordering by score from ZSET at srcKey with a score between Range.getLowerBound() and Range.getUpperBound().
  Parameters:
  
  srcKey - must not be null.
  
  dstKey - must not be null.
  
  range - must not be null.
  
  limit - must not be null.
  
  Returns:
  
  the number of stored elements.
  
  Since:
  
  3.0
  
  See Also:
  
  Redis Documentation: ZRANGESTORE
- reverseRangeAndStoreByScore
  
  default Mono<Long> reverseRangeAndStoreByScore(K srcKey, K dstKey, Range<Double> range)
  
  Store all elements at dstKey with reverse ordering by score from ZSET at srcKey with a score between Range.getLowerBound() and Range.getUpperBound().
  Parameters:
  
  srcKey - must not be null.
  
  dstKey - must not be null.
  
  range - must not be null.
  
  Returns:
  
  the number of stored elements.
  
  Since:
  
  3.0
  
  See Also:
  
  Redis Documentation: ZRANGESTORE
- reverseRangeAndStoreByScore
  
  Mono<Long> reverseRangeAndStoreByScore(K srcKey, K dstKey, Range<Double> range, Limit limit)
  
  Store n elements at dstKey, where n = Limit.getCount(), starting at Limit.getOffset() with reverse ordering by score from ZSET at srcKey with a score between Range.getLowerBound() and Range.getUpperBound().
  Parameters:
  
  srcKey - must not be null.
  
  dstKey - must not be null.
  
  range - must not be null.
  
  limit - must not be null.
  
  Returns:
  
  the number of stored elements.
  
  Since:
  
  3.0
  
  See Also:
  
  Redis Documentation: ZRANGESTORE
- scan
  
  default Flux<ZSetOperations.TypedTuple<V>> scan(K key)
  
  Use a Flux to iterate over entries in the sorted set at key. The resulting Flux acts as a cursor and issues ZSCAN commands itself as long as the subscriber signals demand.
  Parameters:
  
  key - must not be null.
  
  Returns:
  
  the Flux emitting the values one by one or an empty Flux if none exist.
  
  Throws:
  
  IllegalArgumentException - when given key is null.
  
  Since:
  
  2.1
  
  See Also:
  
  Redis Documentation: ZSCAN
- scan
  
  Flux<ZSetOperations.TypedTuple<V>> scan(K key, ScanOptions options)
  
  Use a Flux to iterate over entries in the sorted set at key given ScanOptions. The resulting Flux acts as a cursor and issues ZSCAN commands itself as long as the subscriber signals demand.
  Parameters:
  
  key - must not be null.
  
  options - must not be null. Use ScanOptions.NONE instead.
  
  Returns:
  
  the Flux emitting the values one by one or an empty Flux if none exist.
  
  Throws:
  
  IllegalArgumentException - when one of the required arguments is null.
  
  Since:
  
  2.1
  
  See Also:
  
  Redis Documentation: ZSCAN
- count
  
  Mono<Long> count(K key, Range<Double> range)
  
  Count number of elements within sorted set with scores between min and max.
  Parameters:
  
  key - must not be null.
  
  range -
  
  Returns:
  
  See Also:
  
  Redis Documentation: ZCOUNT
- lexCount
  
  Mono<Long> lexCount(K key, Range<String> range)
  
  Count number of elements within sorted set with a value between Range.getLowerBound() and Range.getUpperBound() applying lexicographical ordering.
  Parameters:
  
  key - must not be null.
  
  range - must not be null
  
  Returns:
  
  Since:
  
  2.4
  
  See Also:
  
  Redis Documentation: ZLEXCOUNT
- popMin
  
  Mono<ZSetOperations.TypedTuple<V>> popMin(K key)
  
  Remove and return the value with its score having the lowest score from sorted set at key.
  Parameters:
  
  key - must not be null.
  
  Returns:
  
  Since:
  
  2.6
  
  See Also:
  
  Redis Documentation: ZPOPMIN
- popMin
  
  Flux<ZSetOperations.TypedTuple<V>> popMin(K key, long count)
  
  Remove and return count values with their score having the lowest score from sorted set at key.
  Parameters:
  
  key - must not be null.
  
  count - number of elements to pop.
  
  Returns:
  
  Since:
  
  2.6
  
  See Also:
  
  Redis Documentation: ZPOPMIN
- popMin
  
  Mono<ZSetOperations.TypedTuple<V>> popMin(K key, Duration timeout)
  
  Remove and return the value with its score having the lowest score from sorted set at key.
  Parameters:
  
  key - must not be null.
  
  timeout - maximal duration to wait until an entry in the list at key is available. Must be either Duration.ZERO or greater 1 second, must not be null. A timeout of zero can be used to wait indefinitely. Durations between zero and one second are not supported.
  
  Returns:
  
  Since:
  
  2.6
  
  See Also:
  
  Redis Documentation: ZPOPMIN
- popMax
  
  Mono<ZSetOperations.TypedTuple<V>> popMax(K key)
  
  Remove and return the value with its score having the highest score from sorted set at key.
  Parameters:
  
  key - must not be null.
  
  Returns:
  
  Since:
  
  2.6
  
  See Also:
  
  Redis Documentation: ZPOPMAX
- popMax
  
  Flux<ZSetOperations.TypedTuple<V>> popMax(K key, long count)
  
  Remove and return count values with their score having the highest score from sorted set at key.
  Parameters:
  
  key - must not be null.
  
  count - number of elements to pop.
  
  Returns:
  
  Since:
  
  2.6
  
  See Also:
  
  Redis Documentation: ZPOPMAX
- popMax
  
  Mono<ZSetOperations.TypedTuple<V>> popMax(K key, Duration timeout)
  
  Remove and return the value with its score having the highest score from sorted set at key.
  Parameters:
  
  key - must not be null.
  
  timeout - maximal duration to wait until an entry in the list at key is available. Must be either Duration.ZERO or greater 1 second, must not be null. A timeout of zero can be used to wait indefinitely. Durations between zero and one second are not supported.
  
  Returns:
  
  Since:
  
  2.6
  
  See Also:
  
  Redis Documentation: ZPOPMIN
- size
  
  Mono<Long> size(K key)
  
  Returns the number of elements of the sorted set stored with given key.
  Parameters:
  
  key -
  
  Returns:
  
  See Also:
  
  Redis Documentation: ZCARD
- score
  
  Mono<Double> score(K key, Object o)
  
  Get the score of element with value from sorted set with key key.
  Parameters:
  
  key - must not be null.
  
  o - the value.
  
  Returns:
  
  See Also:
  
  Redis Documentation: ZSCORE
- score
  
  Mono<List<Double>> score(K key, Object... o)
  
  Get the scores of elements with values from sorted set with key key.
  Parameters:
  
  key - must not be null.
  
  o - the values.
  
  Returns:
  
  Since:
  
  2.6
  
  See Also:
  
  Redis Documentation: ZMSCORE
- removeRange
  
  Mono<Long> removeRange(K key, Range<Long> range)
  
  Remove elements in range between start and end from sorted set with key.
  Parameters:
  
  key - must not be null.
  
  range -
  
  Returns:
  
  See Also:
  
  Redis Documentation: ZREMRANGEBYRANK
- removeRangeByLex
  
  Mono<Long> removeRangeByLex(K key, Range<String> range)
  
  Remove elements in range from sorted set with key.
  Parameters:
  
  key - must not be null.
  
  range - must not be null.
  
  Returns:
  
  a Mono emitting the number or removed elements.
  
  Since:
  
  2.5
  
  See Also:
  
  Redis Documentation: ZREMRANGEBYRANK
- removeRangeByScore
  
  Mono<Long> removeRangeByScore(K key, Range<Double> range)
  
  Remove elements with scores between min and max from sorted set with key.
  Parameters:
  
  key - must not be null.
  
  range -
  
  Returns:
  
  See Also:
  
  Redis Documentation: ZREMRANGEBYSCORE
- difference
  
  default Flux<V> difference(K key, K otherKey)
  
  Diff sorted sets.
  Parameters:
  
  key - must not be null.
  
  otherKey - must not be null.
  
  Returns:
  
  Since:
  
  2.6
  
  See Also:
  
  Redis Documentation: ZDIFF
- difference
  
  Flux<V> difference(K key, Collection<K> otherKeys)
  
  Diff sorted sets.
  Parameters:
  
  key - must not be null.
  
  otherKeys - must not be null.
  
  Returns:
  
  Since:
  
  2.6
  
  See Also:
  
  Redis Documentation: ZDIFF
- differenceWithScores
  
  default Flux<ZSetOperations.TypedTuple<V>> differenceWithScores(K key, K otherKey)
  
  Diff sorted sets.
  Parameters:
  
  key - must not be null.
  
  otherKey - must not be null.
  
  Returns:
  
  Since:
  
  2.6
  
  See Also:
  
  Redis Documentation: ZDIFF
- differenceWithScores
  
  Flux<ZSetOperations.TypedTuple<V>> differenceWithScores(K key, Collection<K> otherKeys)
  
  Diff sorted sets.
  Parameters:
  
  key - must not be null.
  
  otherKeys - must not be null.
  
  Returns:
  
  Since:
  
  2.6
  
  See Also:
  
  Redis Documentation: ZDIFF
- differenceAndStore
  
  default Mono<Long> differenceAndStore(K key, K otherKey, K destKey)
  
  Diff sorted sets and store result in destination destKey.
  Parameters:
  
  key - must not be null.
  
  otherKey - must not be null.
  
  destKey - must not be null.
  
  Returns:
  
  Since:
  
  2.6
  
  See Also:
  
  Redis Documentation: ZDIFFSTORE
- differenceAndStore
  
  Mono<Long> differenceAndStore(K key, Collection<K> otherKeys, K destKey)
  
  Diff sorted sets and store result in destination destKey.
  Parameters:
  
  key - must not be null.
  
  otherKeys - must not be null.
  
  destKey - must not be null.
  
  Returns:
  
  Since:
  
  2.6
  
  See Also:
  
  Redis Documentation: ZDIFFSTORE
- intersect
  
  default Flux<V> intersect(K key, K otherKey)
  
  Intersect sorted sets.
  Parameters:
  
  key - must not be null.
  
  otherKey - must not be null.
  
  Returns:
  
  Since:
  
  2.6
  
  See Also:
  
  Redis Documentation: ZINTER
- intersect
  
  Flux<V> intersect(K key, Collection<K> otherKeys)
  
  Intersect sorted sets.
  Parameters:
  
  key - must not be null.
  
  otherKeys - must not be null.
  
  Returns:
  
  Since:
  
  2.6
  
  See Also:
  
  Redis Documentation: ZINTER
- intersectWithScores
  
  default Flux<ZSetOperations.TypedTuple<V>> intersectWithScores(K key, K otherKey)
  
  Intersect sorted sets.
  Parameters:
  
  key - must not be null.
  
  otherKey - must not be null.
  
  Returns:
  
  Since:
  
  2.6
  
  See Also:
  
  Redis Documentation: ZINTER
- intersectWithScores
  
  Flux<ZSetOperations.TypedTuple<V>> intersectWithScores(K key, Collection<K> otherKeys)
  
  Intersect sorted sets.
  Parameters:
  
  key - must not be null.
  
  otherKeys - must not be null.
  
  Returns:
  
  Since:
  
  2.6
  
  See Also:
  
  Redis Documentation: ZINTER
- intersectWithScores
  
  default Flux<ZSetOperations.TypedTuple<V>> intersectWithScores(K key, Collection<K> otherKeys, Aggregate aggregate)
  
  Intersect sorted sets at key and otherKeys .
  Parameters:
  
  key - must not be null.
  
  otherKeys - must not be null.
  
  aggregate - must not be null.
  
  Returns:
  
  Since:
  
  2.6
  
  See Also:
  
  Redis Documentation: ZINTER
- intersectWithScores
  
  Flux<ZSetOperations.TypedTuple<V>> intersectWithScores(K key, Collection<K> otherKeys, Aggregate aggregate, Weights weights)
  
  Intersect sorted sets.
  Parameters:
  
  key - must not be null.
  
  otherKeys - must not be null.
  
  aggregate - must not be null.
  
  weights - must not be null.
  
  Returns:
  
  Since:
  
  2.6
  
  See Also:
  
  Redis Documentation: ZINTER
- intersectAndStore
  
  default Mono<Long> intersectAndStore(K key, K otherKey, K destKey)
  
  Intersect sorted sets at key and otherKey and store result in destination destKey.
  Parameters:
  
  key - must not be null.
  
  otherKey - must not be null.
  
  destKey - must not be null.
  
  Returns:
  
  See Also:
  
  Redis Documentation: ZINTERSTORE
- intersectAndStore
  
  Mono<Long> intersectAndStore(K key, Collection<K> otherKeys, K destKey)
  
  Intersect sorted sets at key and otherKeys and store result in destination destKey.
  Parameters:
  
  key - must not be null.
  
  otherKeys - must not be null.
  
  destKey - must not be null.
  
  Returns:
  
  See Also:
  
  Redis Documentation: ZINTERSTORE
- intersectAndStore
  
  default Mono<Long> intersectAndStore(K key, Collection<K> otherKeys, K destKey, Aggregate aggregate)
  
  Intersect sorted sets at key and otherKeys and store result in destination destKey.
  Parameters:
  
  key - must not be null.
  
  otherKeys - must not be null.
  
  destKey - must not be null.
  
  aggregate - must not be null.
  
  Returns:
  
  Since:
  
  2.1
  
  See Also:
  
  Redis Documentation: ZINTERSTORE
- intersectAndStore
  
  Mono<Long> intersectAndStore(K key, Collection<K> otherKeys, K destKey, Aggregate aggregate, Weights weights)
  
  Intersect sorted sets at key and otherKeys and store result in destination destKey.
  Parameters:
  
  key - must not be null.
  
  otherKeys - must not be null.
  
  destKey - must not be null.
  
  aggregate - must not be null.
  
  weights - must not be null.
  
  Returns:
  
  Since:
  
  2.1
  
  See Also:
  
  Redis Documentation: ZINTERSTORE
- union
  
  default Flux<V> union(K key, K otherKey)
  
  Union sorted sets.
  Parameters:
  
  key - must not be null.
  
  otherKey - must not be null.
  
  Returns:
  
  Since:
  
  2.6
  
  See Also:
  
  Redis Documentation: ZUNION
- union
  
  Flux<V> union(K key, Collection<K> otherKeys)
  
  Union sorted sets.
  Parameters:
  
  key - must not be null.
  
  otherKeys - must not be null.
  
  Returns:
  
  Since:
  
  2.6
  
  See Also:
  
  Redis Documentation: ZUNION
- unionWithScores
  
  default Flux<ZSetOperations.TypedTuple<V>> unionWithScores(K key, K otherKey)
  
  Union sorted sets.
  Parameters:
  
  key - must not be null.
  
  otherKey - must not be null.
  
  Returns:
  
  Since:
  
  2.6
  
  See Also:
  
  Redis Documentation: ZUNION
- unionWithScores
  
  Flux<ZSetOperations.TypedTuple<V>> unionWithScores(K key, Collection<K> otherKeys)
  
  Union sorted sets.
  Parameters:
  
  key - must not be null.
  
  otherKeys - must not be null.
  
  Returns:
  
  Since:
  
  2.6
  
  See Also:
  
  Redis Documentation: ZUNION
- unionWithScores
  
  default Flux<ZSetOperations.TypedTuple<V>> unionWithScores(K key, Collection<K> otherKeys, Aggregate aggregate)
  
  Union sorted sets at key and otherKeys .
  Parameters:
  
  key - must not be null.
  
  otherKeys - must not be null.
  
  aggregate - must not be null.
  
  Returns:
  
  Since:
  
  2.6
  
  See Also:
  
  Redis Documentation: ZUNION
- unionWithScores
  
  Flux<ZSetOperations.TypedTuple<V>> unionWithScores(K key, Collection<K> otherKeys, Aggregate aggregate, Weights weights)
  
  Union sorted sets.
  Parameters:
  
  key - must not be null.
  
  otherKeys - must not be null.
  
  aggregate - must not be null.
  
  weights - must not be null.
  
  Returns:
  
  Since:
  
  2.6
  
  See Also:
  
  Redis Documentation: ZUNION
- unionAndStore
  
  Mono<Long> unionAndStore(K key, K otherKey, K destKey)
  
  Union sorted sets at key and otherKeys and store result in destination destKey.
  Parameters:
  
  key - must not be null.
  
  otherKey - must not be null.
  
  destKey - must not be null.
  
  Returns:
  
  See Also:
  
  Redis Documentation: ZUNIONSTORE
- unionAndStore
  
  Mono<Long> unionAndStore(K key, Collection<K> otherKeys, K destKey)
  
  Union sorted sets at key and otherKeys and store result in destination destKey.
  Parameters:
  
  key - must not be null.
  
  otherKeys - must not be null.
  
  destKey - must not be null.
  
  Returns:
  
  See Also:
  
  Redis Documentation: ZUNIONSTORE
- unionAndStore
  
  default Mono<Long> unionAndStore(K key, Collection<K> otherKeys, K destKey, Aggregate aggregate)
  
  Union sorted sets at key and otherKeys and store result in destination destKey.
  Parameters:
  
  key - must not be null.
  
  otherKeys - must not be null.
  
  destKey - must not be null.
  
  aggregate - must not be null.
  
  Returns:
  
  Since:
  
  2.1
  
  See Also:
  
  Redis Documentation: ZUNIONSTORE
- unionAndStore
  
  Mono<Long> unionAndStore(K key, Collection<K> otherKeys, K destKey, Aggregate aggregate, Weights weights)
  
  Union sorted sets at key and otherKeys and store result in destination destKey.
  Parameters:
  
  key - must not be null.
  
  otherKeys - must not be null.
  
  destKey - must not be null.
  
  aggregate - must not be null.
  
  weights - must not be null.
  
  Returns:
  
  Since:
  
  2.1
  
  See Also:
  
  Redis Documentation: ZUNIONSTORE
- rangeByLex
  
  Flux<V> rangeByLex(K key, Range<String> range)
  
  Get all elements with lexicographical ordering from ZSET at key with a value between Range.getLowerBound() and Range.getUpperBound().
  Parameters:
  
  key - must not be null.
  
  range - must not be null.
  
  See Also:
  
  Redis Documentation: ZRANGEBYLEX
- rangeByLex
  
  Flux<V> rangeByLex(K key, Range<String> range, Limit limit)
  
  Get all elements n elements, where n = Limit.getCount(), starting at Limit.getOffset() with lexicographical ordering from ZSET at key with a value between Range.getLowerBound() and Range.getUpperBound().
  Parameters:
  
  key - must not be null
  
  range - must not be null.
  
  limit - can be null.
  
  Returns:
  
  See Also:
  
  Redis Documentation: ZRANGEBYLEX
- reverseRangeByLex
  
  Flux<V> reverseRangeByLex(K key, Range<String> range)
  
  Get all elements with reverse lexicographical ordering from ZSET at key with a value between Range.getLowerBound() and Range.getUpperBound().
  Parameters:
  
  key - must not be null.
  
  range - must not be null.
  
  See Also:
  
  Redis Documentation: ZREVRANGEBYLEX
- reverseRangeByLex
  
  Flux<V> reverseRangeByLex(K key, Range<String> range, Limit limit)
  
  Get all elements n elements, where n = Limit.getCount(), starting at Limit.getOffset() with reverse lexicographical ordering from ZSET at key with a value between Range.getLowerBound() and Range.getUpperBound().
  Parameters:
  
  key - must not be null
  
  range - must not be null.
  
  limit - can be null.
  
  Returns:
  
  See Also:
  
  Redis Documentation: ZREVRANGEBYLEX
- delete
  
  Mono<Boolean> delete(K key)
  
  Removes the given key.
  
  Parameters:
  
  key - must not be null.

Interface ReactiveZSetOperations<K,V>

Method Summary

Method Details

add

addAll

remove

incrementScore

randomMember

distinctRandomMembers

randomMembers

randomMemberWithScore

distinctRandomMembersWithScore

randomMembersWithScore

rank

reverseRank

range

rangeWithScores

rangeByScore

rangeByScoreWithScores

rangeByScore

rangeByScoreWithScores

reverseRange

reverseRangeWithScores

reverseRangeByScore

reverseRangeByScoreWithScores

reverseRangeByScore

reverseRangeByScoreWithScores

rangeAndStoreByLex

rangeAndStoreByLex

reverseRangeAndStoreByLex

reverseRangeAndStoreByLex

rangeAndStoreByScore

rangeAndStoreByScore

reverseRangeAndStoreByScore

reverseRangeAndStoreByScore

scan

scan

count

lexCount

popMin

popMin

popMin

popMax

popMax

popMax

size

score

score

removeRange

removeRangeByLex

removeRangeByScore

difference

difference

differenceWithScores

differenceWithScores

differenceAndStore

differenceAndStore

intersect

intersect

intersectWithScores

intersectWithScores

intersectWithScores

intersectWithScores

intersectAndStore

intersectAndStore

intersectAndStore

intersectAndStore

union

union

unionWithScores

unionWithScores

unionWithScores

unionWithScores

unionAndStore

unionAndStore

unionAndStore

unionAndStore

rangeByLex

rangeByLex

reverseRangeByLex