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.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,
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. |
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,
RedisZSetCommands.Aggregate aggregate)
Intersect sorted sets at
key and otherKeys . |
reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> |
intersectWithScores(K key,
Collection<K> otherKeys,
RedisZSetCommands.Aggregate aggregate,
RedisZSetCommands.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,
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.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.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>> |
popMin(K key)
Remove and return the value with its 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.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<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,
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.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)
|
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> |
removeRangeByLex(K key,
Range<String> range)
Remove elements in range 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)
|
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<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.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,
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.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,
RedisZSetCommands.Aggregate aggregate)
Union sorted sets at
key and otherKeys . |
reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> |
unionWithScores(K key,
Collection<K> otherKeys,
RedisZSetCommands.Aggregate aggregate,
RedisZSetCommands.Weights weights)
Union sorted
sets. |
default reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> |
unionWithScores(K key,
K otherKey)
Union sorted
sets. |
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.value - the value.score - the score.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.value - the value.delta - the delta to add. Can be negative.reactor.core.publisher.Mono<V> randomMember(K key)
key.key - must not be null.reactor.core.publisher.Flux<V> distinctRandomMembers(K key, long count)
count distinct random elements from set at key.key - must not be null.count - number of members to return.IllegalArgumentException - if count is negative.reactor.core.publisher.Flux<V> randomMembers(K key, long count)
count random elements from set at key.key - must not be null.count - number of members to return.IllegalArgumentException - if count is negative.reactor.core.publisher.Mono<ZSetOperations.TypedTuple<V>> randomMemberWithScore(K key)
key.key - must not be null.reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> distinctRandomMembersWithScore(K key, long count)
count distinct random elements with their score from set at key.key - must not be null.count - number of members to return.IllegalArgumentException - if count is negative.reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> randomMembersWithScore(K key, long count)
count random elements with their score from set at key.key - must not be null.count - number of members to return.IllegalArgumentException - if count is negative.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.Tuples 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.Tuples 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<ZSetOperations.TypedTuple<V>> popMin(K key)
key.key - must not be null.reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> popMin(K key, long count)
count values with their score having the lowest score from sorted set at key.key - must not be null.count - number of elements to pop.reactor.core.publisher.Mono<ZSetOperations.TypedTuple<V>> popMin(K key, Duration timeout)
key.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 second, must not be null. A timeout of zero can be
used to wait indefinitely. Durations between zero and one second are not supported.reactor.core.publisher.Mono<ZSetOperations.TypedTuple<V>> popMax(K key)
key.key - must not be null.reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> popMax(K key, long count)
count values with their score having the highest score from sorted set at key.key - must not be null.count - number of elements to pop.reactor.core.publisher.Mono<ZSetOperations.TypedTuple<V>> popMax(K key, Duration timeout)
key.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 second, must not be null. A timeout of zero can be
used to wait indefinitely. Durations between zero and one second are not supported.reactor.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<List<Double>> score(K key, Object... o)
values from sorted set with key key.key - must not be null.o - the values.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> removeRangeByLex(K key, Range<String> range)
key.key - must not be null.range - must not be null.Mono emitting the number or removed elements.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 - default reactor.core.publisher.Flux<V> difference(K key, K otherKey)
sets.key - must not be null.otherKey - must not be null.reactor.core.publisher.Flux<V> difference(K key, Collection<K> otherKeys)
sets.key - must not be null.otherKeys - must not be null.default reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> differenceWithScores(K key, K otherKey)
sets.key - must not be null.otherKey - must not be null.reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> differenceWithScores(K key, Collection<K> otherKeys)
sets.key - must not be null.otherKeys - must not be null.default reactor.core.publisher.Mono<Long> differenceAndStore(K key, K otherKey, K destKey)
sets 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> differenceAndStore(K key, Collection<K> otherKeys, K destKey)
sets 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.Flux<V> intersect(K key, K otherKey)
sets.key - must not be null.otherKey - must not be null.reactor.core.publisher.Flux<V> intersect(K key, Collection<K> otherKeys)
sets.key - must not be null.otherKeys - must not be null.default reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> intersectWithScores(K key, K otherKey)
sets.key - must not be null.otherKey - must not be null.reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> intersectWithScores(K key, Collection<K> otherKeys)
sets.key - must not be null.otherKeys - must not be null.default reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> intersectWithScores(K key, Collection<K> otherKeys, RedisZSetCommands.Aggregate aggregate)
key and otherKeys .key - must not be null.otherKeys - must not be null.aggregate - must not be null.reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> intersectWithScores(K key, Collection<K> otherKeys, RedisZSetCommands.Aggregate aggregate, RedisZSetCommands.Weights weights)
sets.key - must not be null.otherKeys - must not be null.aggregate - must not be null.weights - must not be null.default 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.default reactor.core.publisher.Flux<V> union(K key, K otherKey)
sets.key - must not be null.otherKey - must not be null.reactor.core.publisher.Flux<V> union(K key, Collection<K> otherKeys)
sets.key - must not be null.otherKeys - must not be null.default reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> unionWithScores(K key, K otherKey)
sets.key - must not be null.otherKey - must not be null.reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> unionWithScores(K key, Collection<K> otherKeys)
sets.key - must not be null.otherKeys - must not be null.default reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> unionWithScores(K key, Collection<K> otherKeys, RedisZSetCommands.Aggregate aggregate)
key and otherKeys .key - must not be null.otherKeys - must not be null.aggregate - must not be null.reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> unionWithScores(K key, Collection<K> otherKeys, RedisZSetCommands.Aggregate aggregate, RedisZSetCommands.Weights weights)
sets.key - must not be null.otherKeys - must not be null.aggregate - must not be null.weights - must not be null.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.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–2022 Pivotal Software, Inc.. All rights reserved.