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

See Also:

Redis Documentation: Sorted Set Commands

Method Summary

Modifier and Type	Method and 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, 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.Mono<Double>	incrementScore(K key, V value, double delta) Increment the score of element with value in sorted set by increment.
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, RedisZSetCommands.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, RedisZSetCommands.Aggregate aggregate, RedisZSetCommands.Weights weights) Intersect sorted sets at key and otherKeys and store result in destination destKey.
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<V>	range(K key, Range<Long> range) Get elements between start and end from sorted set.
reactor.core.publisher.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().
reactor.core.publisher.Flux<V>	rangeByLex(K key, Range<String> range, RedisZSetCommands.Limit limit) Get all elements n elements, where n = RedisZSetCommands.Limit.getCount(), starting at RedisZSetCommands.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, Range<Double> range) Get elements where score is between min and max from sorted set.
reactor.core.publisher.Flux<V>	rangeByScore(K key, Range<Double> range, RedisZSetCommands.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, Range<Double> range) Get set of RedisZSetCommands.Tuples where score is between min and max from sorted set.
reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>>	rangeByScoreWithScores(K key, Range<Double> range, RedisZSetCommands.Limit limit) Get set of RedisZSetCommands.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, Range<Long> range) Get set of RedisZSetCommands.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, Range<Long> range) Remove elements in range between start and end from sorted set with key.
reactor.core.publisher.Mono<Long>	removeRangeByScore(K key, Range<Double> range) Remove elements with scores between min and max from sorted set with key.
reactor.core.publisher.Flux<V>	reverseRange(K key, Range<Long> range) Get elements in range from start to end from sorted set ordered from high to low.
reactor.core.publisher.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().
reactor.core.publisher.Flux<V>	reverseRangeByLex(K key, Range<String> range, RedisZSetCommands.Limit limit) Get all elements n elements, where n = RedisZSetCommands.Limit.getCount(), starting at RedisZSetCommands.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, 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, Range<Double> range, RedisZSetCommands.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, Range<Double> range) Get set of RedisZSetCommands.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, Range<Double> range, RedisZSetCommands.Limit limit) Get set of RedisZSetCommands.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, Range<Long> range) Get set of RedisZSetCommands.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<Long>	size(K key) Returns the number of elements of the sorted set stored with given key.
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, RedisZSetCommands.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, RedisZSetCommands.Aggregate aggregate, RedisZSetCommands.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.

Method Detail

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.

score - the score.

value - the value.

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.

delta -

value - the value.

Returns:

See Also:

Redis Documentation: ZINCRBY

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,
                                     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,
                                                                          Range<Long> range)

Get set of RedisZSetCommands.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,
                                            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,
                                                                                 Range<Double> range)

Get set of RedisZSetCommands.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,
                                            Range<Double> range,
                                            RedisZSetCommands.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,
                                                                                 Range<Double> range,
                                                                                 RedisZSetCommands.Limit limit)

Get set of RedisZSetCommands.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,
                                            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,
                                                                                 Range<Long> range)

Get set of RedisZSetCommands.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,
                                                   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,
                                                                                        Range<Double> range)

Get set of RedisZSetCommands.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,
                                                   Range<Double> range,
                                                   RedisZSetCommands.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,
                                                                                        Range<Double> range,
                                                                                        RedisZSetCommands.Limit limit)

Get set of RedisZSetCommands.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

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,
                                        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

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

removeRange

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

removeRangeByScore

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

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,
                                                        RedisZSetCommands.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,
                                                RedisZSetCommands.Aggregate aggregate,
                                                RedisZSetCommands.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

intersectAndStore

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,
                                                            RedisZSetCommands.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,
                                                    RedisZSetCommands.Aggregate aggregate,
                                                    RedisZSetCommands.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

rangeByLex

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

reactor.core.publisher.Flux<V> rangeByLex(K key,
                                          Range<String> range,
                                          RedisZSetCommands.Limit limit)

Get all elements n elements, where n = RedisZSetCommands.Limit.getCount(), starting at RedisZSetCommands.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,
                                                 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,
                                                 Range<String> range,
                                                 RedisZSetCommands.Limit limit)

Get all elements n elements, where n = RedisZSetCommands.Limit.getCount(), starting at RedisZSetCommands.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.