ReactiveZSetOperations (Spring Data Redis 2.2.0.RELEASE API)

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

All Methods Instance Methods Abstract Methods Default Methods
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.Tuple`s 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.Tuple`s 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.Tuple`s 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.Tuple`s 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: ZREVRANGE

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.

Interface ReactiveZSetOperations<K,V>

Method Summary

Method Detail

add

addAll

remove

incrementScore

rank

reverseRank

range

rangeWithScores

rangeByScore

rangeByScoreWithScores

rangeByScore

rangeByScoreWithScores

reverseRange

reverseRangeWithScores

reverseRangeByScore

reverseRangeByScoreWithScores

reverseRangeByScore

reverseRangeByScoreWithScores

scan

scan

count

size

score

removeRange

removeRangeByScore

unionAndStore

unionAndStore

unionAndStore

unionAndStore

intersectAndStore

intersectAndStore

intersectAndStore

intersectAndStore

rangeByLex

rangeByLex

reverseRangeByLex

reverseRangeByLex

delete