public interface ReactiveZSetOperations<K,V>
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.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. 
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)

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)

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)

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 . 
reactor.core.publisher.Mono<Boolean> add(K key, V value, double score)
value
to a sorted set at key
, or update its score
if it already exists.key
 must not be null.score
 the score.value
 the value.reactor.core.publisher.Mono<Long> addAll(K key, Collection<? extends ZSetOperations.TypedTuple<V>> tuples)
tuples
to a sorted set at key
, or update their score if it already exists.key
 must not be null.tuples
 the score.reactor.core.publisher.Mono<Long> remove(K key, Object... values)
values
from sorted set. Return number of removed elements.key
 must not be null.values
 must not be null.reactor.core.publisher.Mono<Double> incrementScore(K key, V value, double delta)
value
in sorted set by increment
.key
 must not be null.delta
 value
 the value.reactor.core.publisher.Mono<Long> rank(K key, Object o)
value
in a sorted set.key
 must not be null.o
 the value.reactor.core.publisher.Mono<Long> reverseRank(K key, Object o)
value
in a sorted set when scored high to low.key
 must not be null.o
 the value.reactor.core.publisher.Flux<V> range(K key, Range<Long> range)
start
and end
from sorted set.key
 must not be null.range
 must not be null.reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> rangeWithScores(K key, Range<Long> range)
key
 must not be null.range
 must not be null.reactor.core.publisher.Flux<V> rangeByScore(K key, Range<Double> range)
min
and max
from sorted set.key
 must not be null.range
 must not be null.reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> rangeByScoreWithScores(K key, Range<Double> range)
key
 must not be null.range
 must not be null.reactor.core.publisher.Flux<V> rangeByScore(K key, Range<Double> range, RedisZSetCommands.Limit limit)
start
to end
where score is between min
and max
from
sorted set.key
 must not be null.range
 limit
 reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> rangeByScoreWithScores(K key, Range<Double> range, RedisZSetCommands.Limit limit)
RedisZSetCommands.Tuple
s in range from start
to end
where score is between min
and
max
from sorted set.key
 range
 limit
 reactor.core.publisher.Flux<V> reverseRange(K key, Range<Long> range)
start
to end
from sorted set ordered from high to low.key
 must not be null.range
 reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> reverseRangeWithScores(K key, Range<Long> range)
RedisZSetCommands.Tuple
s in range from start
to end
from sorted set ordered from high to low.key
 must not be null.range
 reactor.core.publisher.Flux<V> reverseRangeByScore(K key, Range<Double> range)
min
and max
from sorted set ordered from high to low.key
 must not be null.range
 reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> reverseRangeByScoreWithScores(K key, Range<Double> range)
RedisZSetCommands.Tuple
where score is between min
and max
from sorted set ordered from high to
low.key
 must not be null.range
 reactor.core.publisher.Flux<V> reverseRangeByScore(K key, Range<Double> range, RedisZSetCommands.Limit limit)
start
to end
where score is between min
and max
from
sorted set ordered high > low.key
 must not be null.range
 limit
 reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> reverseRangeByScoreWithScores(K key, Range<Double> range, RedisZSetCommands.Limit limit)
RedisZSetCommands.Tuple
in range from start
to end
where score is between min
and
max
from sorted set ordered high > low.key
 must not be null.range
 limit
 default reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> scan(K key)
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.key
 must not be null.Flux
emitting the values one by one or an empty Flux
if none
exist.IllegalArgumentException
 when given key
is null.reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> scan(K key, ScanOptions options)
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.key
 must not be null.options
 must not be null. Use ScanOptions.NONE
instead.Flux
emitting the values one by one or an empty Flux
if none
exist.IllegalArgumentException
 when one of the required arguments is null.reactor.core.publisher.Mono<Long> count(K key, Range<Double> range)
min
and max
.key
 must not be null.range
 reactor.core.publisher.Mono<Long> lexCount(K key, Range<String> range)
Range.getLowerBound()
and
Range.getUpperBound()
applying lexicographical ordering.key
 must not be null.range
 must not be nullreactor.core.publisher.Mono<Long> size(K key)
key
.key
 reactor.core.publisher.Mono<Double> score(K key, Object o)
value
from sorted set with key key
.key
 must not be null.o
 the value.reactor.core.publisher.Mono<Long> removeRange(K key, Range<Long> range)
start
and end
from sorted set with key
.key
 must not be null.range
 reactor.core.publisher.Mono<Long> removeRangeByScore(K key, Range<Double> range)
min
and max
from sorted set with key
.key
 must not be null.range
 reactor.core.publisher.Mono<Long> unionAndStore(K key, K otherKey, K destKey)
key
and otherKeys
and store result in destination destKey
.key
 must not be null.otherKey
 must not be null.destKey
 must not be null.reactor.core.publisher.Mono<Long> unionAndStore(K key, Collection<K> otherKeys, K destKey)
key
and otherKeys
and store result in destination destKey
.key
 must not be null.otherKeys
 must not be null.destKey
 must not be null.default reactor.core.publisher.Mono<Long> unionAndStore(K key, Collection<K> otherKeys, K destKey, RedisZSetCommands.Aggregate aggregate)
key
and otherKeys
and store result in destination destKey
.key
 must not be null.otherKeys
 must not be null.destKey
 must not be null.aggregate
 must not be null.reactor.core.publisher.Mono<Long> unionAndStore(K key, Collection<K> otherKeys, K destKey, RedisZSetCommands.Aggregate aggregate, RedisZSetCommands.Weights weights)
key
and otherKeys
and store result in destination destKey
.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.reactor.core.publisher.Mono<Long> intersectAndStore(K key, K otherKey, K destKey)
key
and otherKey
and store result in destination destKey
.key
 must not be null.otherKey
 must not be null.destKey
 must not be null.reactor.core.publisher.Mono<Long> intersectAndStore(K key, Collection<K> otherKeys, K destKey)
key
and otherKeys
and store result in destination destKey
.key
 must not be null.otherKeys
 must not be null.destKey
 must not be null.default reactor.core.publisher.Mono<Long> intersectAndStore(K key, Collection<K> otherKeys, K destKey, RedisZSetCommands.Aggregate aggregate)
key
and otherKeys
and store result in destination destKey
.key
 must not be null.otherKeys
 must not be null.destKey
 must not be null.aggregate
 must not be null.reactor.core.publisher.Mono<Long> intersectAndStore(K key, Collection<K> otherKeys, K destKey, RedisZSetCommands.Aggregate aggregate, RedisZSetCommands.Weights weights)
key
and otherKeys
and store result in destination destKey
.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.reactor.core.publisher.Flux<V> rangeByLex(K key, Range<String> range)
key
with a value between
Range.getLowerBound()
and Range.getUpperBound()
.key
 must not be null.range
 must not be null.reactor.core.publisher.Flux<V> rangeByLex(K key, Range<String> range, RedisZSetCommands.Limit limit)
RedisZSetCommands.Limit.getCount()
, starting at
RedisZSetCommands.Limit.getOffset()
with lexicographical ordering from ZSET at key
with a value between
Range.getLowerBound()
and Range.getUpperBound()
.key
 must not be nullrange
 must not be null.limit
 can be null.reactor.core.publisher.Flux<V> reverseRangeByLex(K key, Range<String> range)
key
with a value between
Range.getLowerBound()
and Range.getUpperBound()
.key
 must not be null.range
 must not be null.reactor.core.publisher.Flux<V> reverseRangeByLex(K key, Range<String> range, RedisZSetCommands.Limit limit)
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()
.key
 must not be nullrange
 must not be null.limit
 can be null.Copyright © 2011–2021 Pivotal Software, Inc.. All rights reserved.