Package org.springframework.data.redis.core

Interface ReactiveZSetOperations<K,V>

public interface ReactiveZSetOperations<K,V>

Redis ZSet/sorted set specific operations.

Since:

2.0

Author:

Mark Paluch, Christoph Strobl, Andrey Shlykov

See Also:

• Redis Documentation: Sorted Set Commands

Method Summary

Modifier and Type	Method	Description
reactor.core.publisher.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.
reactor.core.publisher.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.
reactor.core.publisher.Mono<Long>	count(K key, org.springframework.data.domain.Range<Double> range)	Count number of elements within sorted set with scores between min and max.
reactor.core.publisher.Mono<Boolean>	delete(K key)	Removes the given key.
reactor.core.publisher.Flux<V>	difference(K key, Collection<K> otherKeys)	Diff sorted sets.
default reactor.core.publisher.Flux<V>	difference(K key, K otherKey)	Diff sorted sets.
reactor.core.publisher.Mono<Long>	differenceAndStore(K key, Collection<K> otherKeys, K destKey)	Diff sorted sets and store result in destination destKey.
default reactor.core.publisher.Mono<Long>	differenceAndStore(K key, K otherKey, K destKey)	Diff sorted sets and store result in destination destKey.
reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>>	differenceWithScores(K key, Collection<K> otherKeys)	Diff sorted sets.
default reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>>	differenceWithScores(K key, K otherKey)	Diff sorted sets.
reactor.core.publisher.Flux<V>	distinctRandomMembers(K key, long count)	Get count distinct random elements from set at key.
reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>>	distinctRandomMembersWithScore(K key, long count)	Get count distinct random elements with their score from set at key.
reactor.core.publisher.Mono<Double>	incrementScore(K key, V value, double delta)	Increment the score of element with value in sorted set by increment.
reactor.core.publisher.Flux<V>	intersect(K key, Collection<K> otherKeys)	Intersect sorted sets.
default reactor.core.publisher.Flux<V>	intersect(K key, K otherKey)	Intersect sorted sets.
reactor.core.publisher.Mono<Long>	intersectAndStore(K key, Collection<K> otherKeys, K destKey)	Intersect sorted sets at key and otherKeys and store result in destination destKey.
default reactor.core.publisher.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.
reactor.core.publisher.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 reactor.core.publisher.Mono<Long>	intersectAndStore(K key, K otherKey, K destKey)	Intersect sorted sets at key and otherKey and store result in destination destKey.
reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>>	intersectWithScores(K key, Collection<K> otherKeys)	Intersect sorted sets.
default reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>>	intersectWithScores(K key, Collection<K> otherKeys, Aggregate aggregate)	Intersect sorted sets at key and otherKeys .
reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>>	intersectWithScores(K key, Collection<K> otherKeys, Aggregate aggregate, Weights weights)	Intersect sorted sets.
default reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>>	intersectWithScores(K key, K otherKey)	Intersect sorted sets.
reactor.core.publisher.Mono<Long>	lexCount(K key, org.springframework.data.domain.Range<String> range)	Count number of elements within sorted set with a value between Range.getLowerBound() and Range.getUpperBound() applying lexicographical ordering.
reactor.core.publisher.Mono<ZSetOperations.TypedTuple<V>>	popMax(K key)	Remove and return the value with its score having the highest score from sorted set at key.
reactor.core.publisher.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.
reactor.core.publisher.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.
reactor.core.publisher.Mono<ZSetOperations.TypedTuple<V>>	popMin(K key)	Remove and return the value with its score having the lowest score from sorted set at key.
reactor.core.publisher.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.
reactor.core.publisher.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.
reactor.core.publisher.Mono<V>	randomMember(K key)	Get random element from set at key.
reactor.core.publisher.Flux<V>	randomMembers(K key, long count)	Get count random elements from set at key.
reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>>	randomMembersWithScore(K key, long count)	Get count random elements with their score from set at key.
reactor.core.publisher.Mono<ZSetOperations.TypedTuple<V>>	randomMemberWithScore(K key)	Get random element with its score from set at key.
reactor.core.publisher.Flux<V>	range(K key, org.springframework.data.domain.Range<Long> range)	Get elements between start and end from sorted set.
default reactor.core.publisher.Mono<Long>	rangeAndStoreByLex(K srcKey, K dstKey, org.springframework.data.domain.Range<String> range)	Store all elements at dstKey with lexicographical ordering from ZSET at srcKey with a value between Range.getLowerBound() and Range.getUpperBound().
reactor.core.publisher.Mono<Long>	rangeAndStoreByLex(K srcKey, K dstKey, org.springframework.data.domain.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 reactor.core.publisher.Mono<Long>	rangeAndStoreByScore(K srcKey, K dstKey, org.springframework.data.domain.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().
reactor.core.publisher.Mono<Long>	rangeAndStoreByScore(K srcKey, K dstKey, org.springframework.data.domain.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().
reactor.core.publisher.Flux<V>	rangeByLex(K key, org.springframework.data.domain.Range<String> range)	Get all elements with lexicographical ordering from ZSET at key with a value between Range.getLowerBound() and Range.getUpperBound().
reactor.core.publisher.Flux<V>	rangeByLex(K key, org.springframework.data.domain.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().
reactor.core.publisher.Flux<V>	rangeByScore(K key, org.springframework.data.domain.Range<Double> range)	Get elements where score is between min and max from sorted set.
reactor.core.publisher.Flux<V>	rangeByScore(K key, org.springframework.data.domain.Range<Double> range, Limit limit)	Get elements in range from start to end where score is between min and max from sorted set.
reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>>	rangeByScoreWithScores(K key, org.springframework.data.domain.Range<Double> range)	Get set of Tuples where score is between min and max from sorted set.
reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>>	rangeByScoreWithScores(K key, org.springframework.data.domain.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.
reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>>	rangeWithScores(K key, org.springframework.data.domain.Range<Long> range)	Get set of Tuples between start and end from sorted set.
reactor.core.publisher.Mono<Long>	rank(K key, Object o)	Determine the index of element with value in a sorted set.
reactor.core.publisher.Mono<Long>	remove(K key, Object... values)	Remove values from sorted set.
reactor.core.publisher.Mono<Long>	removeRange(K key, org.springframework.data.domain.Range<Long> range)	Remove elements in range between start and end from sorted set with key.
reactor.core.publisher.Mono<Long>	removeRangeByLex(K key, org.springframework.data.domain.Range<String> range)	Remove elements in range from sorted set with key.
reactor.core.publisher.Mono<Long>	removeRangeByScore(K key, org.springframework.data.domain.Range<Double> range)	Remove elements with scores between min and max from sorted set with key.
reactor.core.publisher.Flux<V>	reverseRange(K key, org.springframework.data.domain.Range<Long> range)	Get elements in range from start to end from sorted set ordered from high to low.
default reactor.core.publisher.Mono<Long>	reverseRangeAndStoreByLex(K srcKey, K dstKey, org.springframework.data.domain.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().
reactor.core.publisher.Mono<Long>	reverseRangeAndStoreByLex(K srcKey, K dstKey, org.springframework.data.domain.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 reactor.core.publisher.Mono<Long>	reverseRangeAndStoreByScore(K srcKey, K dstKey, org.springframework.data.domain.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().
reactor.core.publisher.Mono<Long>	reverseRangeAndStoreByScore(K srcKey, K dstKey, org.springframework.data.domain.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().
reactor.core.publisher.Flux<V>	reverseRangeByLex(K key, org.springframework.data.domain.Range<String> range)	Get all elements with reverse lexicographical ordering from ZSET at key with a value between Range.getLowerBound() and Range.getUpperBound().
reactor.core.publisher.Flux<V>	reverseRangeByLex(K key, org.springframework.data.domain.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().
reactor.core.publisher.Flux<V>	reverseRangeByScore(K key, org.springframework.data.domain.Range<Double> range)	Get elements where score is between min and max from sorted set ordered from high to low.
reactor.core.publisher.Flux<V>	reverseRangeByScore(K key, org.springframework.data.domain.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.
reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>>	reverseRangeByScoreWithScores(K key, org.springframework.data.domain.Range<Double> range)	Get set of Tuple where score is between min and max from sorted set ordered from high to low.
reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>>	reverseRangeByScoreWithScores(K key, org.springframework.data.domain.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.
reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>>	reverseRangeWithScores(K key, org.springframework.data.domain.Range<Long> range)	Get set of Tuples in range from start to end from sorted set ordered from high to low.
reactor.core.publisher.Mono<Long>	reverseRank(K key, Object o)	Determine the index of element with value in a sorted set when scored high to low.
default reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>>	scan(K key)	Use a Flux to iterate over entries in the sorted set at key.
reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>>	scan(K key, ScanOptions options)	Use a Flux to iterate over entries in the sorted set at key given ScanOptions.
reactor.core.publisher.Mono<Double>	score(K key, Object o)	Get the score of element with value from sorted set with key key.
reactor.core.publisher.Mono<List<Double>>	score(K key, Object... o)	Get the scores of elements with values from sorted set with key key.
reactor.core.publisher.Mono<Long>	size(K key)	Returns the number of elements of the sorted set stored with given key.
reactor.core.publisher.Flux<V>	union(K key, Collection<K> otherKeys)	Union sorted sets.
default reactor.core.publisher.Flux<V>	union(K key, K otherKey)	Union sorted sets.
reactor.core.publisher.Mono<Long>	unionAndStore(K key, Collection<K> otherKeys, K destKey)	Union sorted sets at key and otherKeys and store result in destination destKey.
default reactor.core.publisher.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.
reactor.core.publisher.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.
reactor.core.publisher.Mono<Long>	unionAndStore(K key, K otherKey, K destKey)	Union sorted sets at key and otherKeys and store result in destination destKey.
reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>>	unionWithScores(K key, Collection<K> otherKeys)	Union sorted sets.
default reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>>	unionWithScores(K key, Collection<K> otherKeys, Aggregate aggregate)	Union sorted sets at key and otherKeys .
reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>>	unionWithScores(K key, Collection<K> otherKeys, Aggregate aggregate, Weights weights)	Union sorted sets.
default reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>>	unionWithScores(K key, K otherKey)	Union sorted sets.

Method Details

add

reactor.core.publisher.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

reactor.core.publisher.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

reactor.core.publisher.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

reactor.core.publisher.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

reactor.core.publisher.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

reactor.core.publisher.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

reactor.core.publisher.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

reactor.core.publisher.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

reactor.core.publisher.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

reactor.core.publisher.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

reactor.core.publisher.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

reactor.core.publisher.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

reactor.core.publisher.Flux<V> range(K key,
 org.springframework.data.domain.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

reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> rangeWithScores(K key,
 org.springframework.data.domain.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

reactor.core.publisher.Flux<V> rangeByScore(K key,
 org.springframework.data.domain.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

reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> rangeByScoreWithScores(K key,
 org.springframework.data.domain.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

reactor.core.publisher.Flux<V> rangeByScore(K key,
 org.springframework.data.domain.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

reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> rangeByScoreWithScores(K key,
 org.springframework.data.domain.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

reactor.core.publisher.Flux<V> reverseRange(K key,
 org.springframework.data.domain.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

reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> reverseRangeWithScores(K key,
 org.springframework.data.domain.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

reactor.core.publisher.Flux<V> reverseRangeByScore(K key,
 org.springframework.data.domain.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

reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> reverseRangeByScoreWithScores(K key,
 org.springframework.data.domain.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

reactor.core.publisher.Flux<V> reverseRangeByScore(K key,
 org.springframework.data.domain.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

reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> reverseRangeByScoreWithScores(K key,
 org.springframework.data.domain.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 reactor.core.publisher.Mono<Long> rangeAndStoreByLex(K srcKey,
 K dstKey,
 org.springframework.data.domain.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

reactor.core.publisher.Mono<Long> rangeAndStoreByLex(K srcKey,
 K dstKey,
 org.springframework.data.domain.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 reactor.core.publisher.Mono<Long> reverseRangeAndStoreByLex(K srcKey,
 K dstKey,
 org.springframework.data.domain.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

reactor.core.publisher.Mono<Long> reverseRangeAndStoreByLex(K srcKey,
 K dstKey,
 org.springframework.data.domain.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 reactor.core.publisher.Mono<Long> rangeAndStoreByScore(K srcKey,
 K dstKey,
 org.springframework.data.domain.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

reactor.core.publisher.Mono<Long> rangeAndStoreByScore(K srcKey,
 K dstKey,
 org.springframework.data.domain.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 reactor.core.publisher.Mono<Long> reverseRangeAndStoreByScore(K srcKey,
 K dstKey,
 org.springframework.data.domain.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

reactor.core.publisher.Mono<Long> reverseRangeAndStoreByScore(K srcKey,
 K dstKey,
 org.springframework.data.domain.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 reactor.core.publisher.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

reactor.core.publisher.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

reactor.core.publisher.Mono<Long> count(K key,
 org.springframework.data.domain.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

reactor.core.publisher.Mono<Long> lexCount(K key,
 org.springframework.data.domain.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

reactor.core.publisher.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

reactor.core.publisher.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

reactor.core.publisher.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 {@link 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

reactor.core.publisher.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

reactor.core.publisher.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

reactor.core.publisher.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 {@link 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

reactor.core.publisher.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

reactor.core.publisher.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

reactor.core.publisher.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

reactor.core.publisher.Mono<Long> removeRange(K key,
 org.springframework.data.domain.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

reactor.core.publisher.Mono<Long> removeRangeByLex(K key,
 org.springframework.data.domain.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

reactor.core.publisher.Mono<Long> removeRangeByScore(K key,
 org.springframework.data.domain.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 reactor.core.publisher.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

reactor.core.publisher.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 reactor.core.publisher.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

reactor.core.publisher.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 reactor.core.publisher.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

reactor.core.publisher.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 reactor.core.publisher.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

reactor.core.publisher.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 reactor.core.publisher.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

reactor.core.publisher.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 reactor.core.publisher.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

reactor.core.publisher.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 reactor.core.publisher.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

reactor.core.publisher.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 reactor.core.publisher.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

reactor.core.publisher.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 reactor.core.publisher.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

reactor.core.publisher.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 reactor.core.publisher.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

reactor.core.publisher.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 reactor.core.publisher.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

reactor.core.publisher.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

reactor.core.publisher.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

reactor.core.publisher.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 reactor.core.publisher.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

reactor.core.publisher.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

reactor.core.publisher.Flux<V> rangeByLex(K key,
 org.springframework.data.domain.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

reactor.core.publisher.Flux<V> rangeByLex(K key,
 org.springframework.data.domain.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

reactor.core.publisher.Flux<V> reverseRangeByLex(K key,
 org.springframework.data.domain.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

reactor.core.publisher.Flux<V> reverseRangeByLex(K key,
 org.springframework.data.domain.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

reactor.core.publisher.Mono<Boolean> delete(K key)

Removes the given key.

Parameters:

key - must not be null.