org.springframework.data.redis.connection

Interface ReactiveZSetCommands

All Known Subinterfaces:

ReactiveClusterZSetCommands

public interface ReactiveZSetCommands

Redis Sorted Set commands executed using reactive infrastructure.

Since:

2.0

Author:

Christoph Strobl, Mark Paluch, Andrey Shlykov

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	ReactiveZSetCommands.BZPopCommand BZPOPMIN/BZPOPMAX command parameters.
static class	ReactiveZSetCommands.PopDirection
static class	ReactiveZSetCommands.ZAddCommand ZADD command parameters.
static class	ReactiveZSetCommands.ZAggregateCommand ZINTER/ZUNION command parameters.
static class	ReactiveZSetCommands.ZAggregateStoreCommand ZINTERSTORE/ZUNIONSTORE command parameters.
static class	ReactiveZSetCommands.ZCountCommand ZCOUNT command parameters.
static class	ReactiveZSetCommands.ZDiffCommand ZDIFF command parameters.
static class	ReactiveZSetCommands.ZDiffStoreCommand ZDIFFSTORE command parameters.
static class	ReactiveZSetCommands.ZIncrByCommand ZINCRBY command parameters.
static class	ReactiveZSetCommands.ZInterStoreCommand ZINTERSTORE command parameters.
static class	ReactiveZSetCommands.ZLexCountCommand ZLEXCOUNT command parameters.
static class	ReactiveZSetCommands.ZMScoreCommand ZMSCORE command parameters.
static class	ReactiveZSetCommands.ZPopCommand ZPOPMIN/ZPOPMAX command parameters.
static class	ReactiveZSetCommands.ZRandMemberCommand ZRANDMEMBER command parameters.
static class	ReactiveZSetCommands.ZRangeByLexCommand ZRANGEBYLEX/ZREVRANGEBYLEX command parameters.
static class	ReactiveZSetCommands.ZRangeByScoreCommand ZRANGEBYSCORE/ZREVRANGEBYSCORE.
static class	ReactiveZSetCommands.ZRangeCommand ZRANGE/ZREVRANGE command parameters.
static class	ReactiveZSetCommands.ZRankCommand ZRANK/ZREVRANK command parameters.
static class	ReactiveZSetCommands.ZRemCommand ZREM command parameters.
static class	ReactiveZSetCommands.ZRemRangeByLexCommand ZREMRANGEBYLEX command parameters.
static class	ReactiveZSetCommands.ZRemRangeByRankCommand ZREMRANGEBYRANK command parameters.
static class	ReactiveZSetCommands.ZRemRangeByScoreCommand ZREMRANGEBYSCORE command parameters.
static class	ReactiveZSetCommands.ZScoreCommand ZSCORE command parameters.
static class	ReactiveZSetCommands.ZUnionStoreCommand ZUNIONSTORE command parameters.

Method Summary

Modifier and Type	Method and Description
reactor.core.publisher.Flux<ReactiveRedisConnection.CommandResponse<ReactiveZSetCommands.BZPopCommand,reactor.core.publisher.Flux<RedisZSetCommands.Tuple>>>	bZPop(org.reactivestreams.Publisher<ReactiveZSetCommands.BZPopCommand> commands) Remove and return elements from sorted set at keyCommand#getKey().
default reactor.core.publisher.Mono<RedisZSetCommands.Tuple>	bZPopMax(ByteBuffer key, Duration timeout) Remove and return the value with its score having the highest score from sorted set at key.
default reactor.core.publisher.Mono<RedisZSetCommands.Tuple>	bZPopMin(ByteBuffer key, Duration timeout) Remove and return the value with its score having the lowest score from sorted set at key.
default reactor.core.publisher.Mono<Long>	zAdd(ByteBuffer key, Collection<? extends RedisZSetCommands.Tuple> tuples) Add a tuples to a sorted set at key, or update their score if it already exists.
default reactor.core.publisher.Mono<Long>	zAdd(ByteBuffer key, Double score, ByteBuffer value) Add value to a sorted set at key, or update its score if it already exists.
reactor.core.publisher.Flux<ReactiveRedisConnection.NumericResponse<ReactiveZSetCommands.ZAddCommand,Number>>	zAdd(org.reactivestreams.Publisher<ReactiveZSetCommands.ZAddCommand> commands) Add ReactiveZSetCommands.ZAddCommand.getTuples() to a sorted set at ReactiveRedisConnection.KeyCommand.getKey(), or update its score if it already exists.
default reactor.core.publisher.Mono<Long>	zCard(ByteBuffer key) Get the size of sorted set with key.
reactor.core.publisher.Flux<ReactiveRedisConnection.NumericResponse<ReactiveRedisConnection.KeyCommand,Long>>	zCard(org.reactivestreams.Publisher<ReactiveRedisConnection.KeyCommand> commands) Get the size of sorted set with .
default reactor.core.publisher.Mono<Long>	zCount(ByteBuffer key, org.springframework.data.domain.Range<Double> range) Count number of elements within sorted set with scores within Range.
reactor.core.publisher.Flux<ReactiveRedisConnection.NumericResponse<ReactiveZSetCommands.ZCountCommand,Long>>	zCount(org.reactivestreams.Publisher<ReactiveZSetCommands.ZCountCommand> commands) Count number of elements within sorted set with scores within Range.
default reactor.core.publisher.Flux<ByteBuffer>	zDiff(List<ByteBuffer> sets) Diff sorted sets.
reactor.core.publisher.Flux<ReactiveRedisConnection.CommandResponse<ReactiveZSetCommands.ZDiffCommand,reactor.core.publisher.Flux<ByteBuffer>>>	zDiff(org.reactivestreams.Publisher<? extends ReactiveZSetCommands.ZDiffCommand> commands) Diff sorted sets.
default reactor.core.publisher.Mono<Long>	zDiffStore(ByteBuffer destinationKey, List<ByteBuffer> sets) Diff sorted sets and store result in destination destinationKey.
reactor.core.publisher.Flux<ReactiveRedisConnection.NumericResponse<ReactiveZSetCommands.ZDiffStoreCommand,Long>>	zDiffStore(org.reactivestreams.Publisher<ReactiveZSetCommands.ZDiffStoreCommand> commands) Diff sorted sets and store result in destination destinationKey.
default reactor.core.publisher.Flux<RedisZSetCommands.Tuple>	zDiffWithScores(List<ByteBuffer> sets) Diff sorted sets.
reactor.core.publisher.Flux<ReactiveRedisConnection.CommandResponse<ReactiveZSetCommands.ZDiffCommand,reactor.core.publisher.Flux<RedisZSetCommands.Tuple>>>	zDiffWithScores(org.reactivestreams.Publisher<? extends ReactiveZSetCommands.ZDiffCommand> commands) Diff sorted sets.
default reactor.core.publisher.Mono<Double>	zIncrBy(ByteBuffer key, Number increment, ByteBuffer value) Increment the score of element with value in sorted set by increment.
reactor.core.publisher.Flux<ReactiveRedisConnection.NumericResponse<ReactiveZSetCommands.ZIncrByCommand,Double>>	zIncrBy(org.reactivestreams.Publisher<ReactiveZSetCommands.ZIncrByCommand> commands) Increment the score of element with ReactiveZSetCommands.ZIncrByCommand.getValue() in sorted set by ReactiveZSetCommands.ZIncrByCommand.getIncrement().
default reactor.core.publisher.Flux<ByteBuffer>	zInter(List<ByteBuffer> sets) Intersect sorted sets.
reactor.core.publisher.Flux<ReactiveRedisConnection.CommandResponse<ReactiveZSetCommands.ZAggregateCommand,reactor.core.publisher.Flux<ByteBuffer>>>	zInter(org.reactivestreams.Publisher<? extends ReactiveZSetCommands.ZAggregateCommand> commands) Intersect sorted sets by applying aggregateFunction and apply weights to individual sets.
default reactor.core.publisher.Mono<Long>	zInterStore(ByteBuffer destinationKey, List<ByteBuffer> sets) Intersect sorted sets and store result in destination destinationKey.
default reactor.core.publisher.Mono<Long>	zInterStore(ByteBuffer destinationKey, List<ByteBuffer> sets, List<Double> weights) Intersect sorted sets and store result in destination destinationKey and apply weights to individual sets.
default reactor.core.publisher.Mono<Long>	zInterStore(ByteBuffer destinationKey, List<ByteBuffer> sets, List<Double> weights, RedisZSetCommands.Aggregate aggregateFunction) Intersect sorted sets by applying aggregateFunction and store result in destination destinationKey and apply weights to individual sets.
default reactor.core.publisher.Mono<Long>	zInterStore(ByteBuffer destinationKey, List<ByteBuffer> sets, RedisZSetCommands.Weights weights) Intersect sorted sets and store result in destination destinationKey and apply weights to individual sets.
default reactor.core.publisher.Mono<Long>	zInterStore(ByteBuffer destinationKey, List<ByteBuffer> sets, RedisZSetCommands.Weights weights, RedisZSetCommands.Aggregate aggregateFunction) Intersect sorted sets by applying aggregateFunction and store result in destination destinationKey and apply weights to individual sets.
reactor.core.publisher.Flux<ReactiveRedisConnection.NumericResponse<ReactiveZSetCommands.ZAggregateStoreCommand,Long>>	zInterStore(org.reactivestreams.Publisher<? extends ReactiveZSetCommands.ZAggregateStoreCommand> commands) Intersect sorted sets by applying aggregateFunction and store result in destination destinationKey and apply weights to individual sets.
default reactor.core.publisher.Flux<RedisZSetCommands.Tuple>	zInterWithScores(List<ByteBuffer> sets) Intersect sorted sets.
default reactor.core.publisher.Flux<RedisZSetCommands.Tuple>	zInterWithScores(List<ByteBuffer> sets, List<Double> weights) Intersect sorted sets and apply weights to individual sets.
default reactor.core.publisher.Flux<RedisZSetCommands.Tuple>	zInterWithScores(List<ByteBuffer> sets, List<Double> weights, RedisZSetCommands.Aggregate aggregateFunction) Intersect sorted sets by applying aggregateFunction and apply weights to individual sets.
default reactor.core.publisher.Flux<RedisZSetCommands.Tuple>	zInterWithScores(List<ByteBuffer> sets, RedisZSetCommands.Weights weights) Intersect sorted sets and apply weights to individual sets.
default reactor.core.publisher.Flux<RedisZSetCommands.Tuple>	zInterWithScores(List<ByteBuffer> sets, RedisZSetCommands.Weights weights, RedisZSetCommands.Aggregate aggregateFunction) Intersect sorted sets by applying aggregateFunction and apply weights to individual sets.
reactor.core.publisher.Flux<ReactiveRedisConnection.CommandResponse<ReactiveZSetCommands.ZAggregateCommand,reactor.core.publisher.Flux<RedisZSetCommands.Tuple>>>	zInterWithScores(org.reactivestreams.Publisher<? extends ReactiveZSetCommands.ZAggregateCommand> commands) Intersect sorted sets by applying aggregateFunction and apply weights to individual sets.
default reactor.core.publisher.Mono<Long>	zLexCount(ByteBuffer key, org.springframework.data.domain.Range<String> range) Count number of elements within sorted set with value between Range#min and Range#max applying lexicographical ordering.
reactor.core.publisher.Flux<ReactiveRedisConnection.NumericResponse<ReactiveZSetCommands.ZLexCountCommand,Long>>	zLexCount(org.reactivestreams.Publisher<ReactiveZSetCommands.ZLexCountCommand> commands) Count number of elements within sorted set with value between Range#min and Range#max applying lexicographical ordering.
default reactor.core.publisher.Mono<List<Double>>	zMScore(ByteBuffer key, Collection<ByteBuffer> values) Get the scores of elements with values from sorted set with key key.
reactor.core.publisher.Flux<ReactiveRedisConnection.MultiValueResponse<ReactiveZSetCommands.ZMScoreCommand,Double>>	zMScore(org.reactivestreams.Publisher<ReactiveZSetCommands.ZMScoreCommand> commands) Get the scores of elements with ReactiveZSetCommands.ZMScoreCommand.getValues() from sorted set with key ReactiveRedisConnection.KeyCommand.getKey()
reactor.core.publisher.Flux<ReactiveRedisConnection.CommandResponse<ReactiveZSetCommands.ZPopCommand,reactor.core.publisher.Flux<RedisZSetCommands.Tuple>>>	zPop(org.reactivestreams.Publisher<ReactiveZSetCommands.ZPopCommand> commands) Remove and return elements from sorted set at keyCommand#getKey().
default reactor.core.publisher.Mono<RedisZSetCommands.Tuple>	zPopMax(ByteBuffer key) Remove and return the value with its score having the highest score from sorted set at key.
default reactor.core.publisher.Flux<RedisZSetCommands.Tuple>	zPopMax(ByteBuffer key, long count) Remove and return count values with their score having the highest score from sorted set at key.
default reactor.core.publisher.Mono<RedisZSetCommands.Tuple>	zPopMin(ByteBuffer key) Remove and return the value with its score having the lowest score from sorted set at key.
default reactor.core.publisher.Flux<RedisZSetCommands.Tuple>	zPopMin(ByteBuffer key, long count) Remove and return count values with their score having the lowest score from sorted set at key.
default reactor.core.publisher.Mono<ByteBuffer>	zRandMember(ByteBuffer key) Get random element from sorted set at key.
default reactor.core.publisher.Flux<ByteBuffer>	zRandMember(ByteBuffer key, long count) Get count random elements from sorted set at key.
reactor.core.publisher.Flux<ReactiveRedisConnection.CommandResponse<ReactiveZSetCommands.ZRandMemberCommand,reactor.core.publisher.Flux<ByteBuffer>>>	zRandMember(org.reactivestreams.Publisher<ReactiveZSetCommands.ZRandMemberCommand> commands) Get random elements from sorted set at key.
default reactor.core.publisher.Mono<RedisZSetCommands.Tuple>	zRandMemberWithScore(ByteBuffer key) Get random element from sorted set at key.
default reactor.core.publisher.Flux<RedisZSetCommands.Tuple>	zRandMemberWithScore(ByteBuffer key, long count) Get count random elements from sorted set at key.
reactor.core.publisher.Flux<ReactiveRedisConnection.CommandResponse<ReactiveZSetCommands.ZRandMemberCommand,reactor.core.publisher.Flux<RedisZSetCommands.Tuple>>>	zRandMemberWithScore(org.reactivestreams.Publisher<ReactiveZSetCommands.ZRandMemberCommand> commands) Get random elements from sorted set at key.
default reactor.core.publisher.Flux<ByteBuffer>	zRange(ByteBuffer key, org.springframework.data.domain.Range<Long> range) Get elements in range from sorted set.
reactor.core.publisher.Flux<ReactiveRedisConnection.CommandResponse<ReactiveZSetCommands.ZRangeCommand,reactor.core.publisher.Flux<RedisZSetCommands.Tuple>>>	zRange(org.reactivestreams.Publisher<ReactiveZSetCommands.ZRangeCommand> commands) Get set of RedisZSetCommands.Tuples in range from sorted set.
default reactor.core.publisher.Flux<ByteBuffer>	zRangeByLex(ByteBuffer key, org.springframework.data.domain.Range<String> range) Get all elements in Range from the sorted set at key in lexicographical ordering.
default reactor.core.publisher.Flux<ByteBuffer>	zRangeByLex(ByteBuffer key, org.springframework.data.domain.Range<String> range, RedisZSetCommands.Limit limit) Get all elements in Range from the sorted set at key in lexicographical ordering.
reactor.core.publisher.Flux<ReactiveRedisConnection.CommandResponse<ReactiveZSetCommands.ZRangeByLexCommand,reactor.core.publisher.Flux<ByteBuffer>>>	zRangeByLex(org.reactivestreams.Publisher<ReactiveZSetCommands.ZRangeByLexCommand> commands) Get all elements in Range from the sorted set at key in lexicographical ordering.
default reactor.core.publisher.Flux<ByteBuffer>	zRangeByScore(ByteBuffer key, org.springframework.data.domain.Range<Double> range) Get elements in range from sorted set.
default reactor.core.publisher.Flux<ByteBuffer>	zRangeByScore(ByteBuffer key, org.springframework.data.domain.Range<Double> range, RedisZSetCommands.Limit limit) Get elements in range from sorted set.
reactor.core.publisher.Flux<ReactiveRedisConnection.CommandResponse<ReactiveZSetCommands.ZRangeByScoreCommand,reactor.core.publisher.Flux<RedisZSetCommands.Tuple>>>	zRangeByScore(org.reactivestreams.Publisher<ReactiveZSetCommands.ZRangeByScoreCommand> commands) Get RedisZSetCommands.Tuples in range from sorted set.
default reactor.core.publisher.Flux<RedisZSetCommands.Tuple>	zRangeByScoreWithScores(ByteBuffer key, org.springframework.data.domain.Range<Double> range) Get RedisZSetCommands.Tuples in range from sorted set.
default reactor.core.publisher.Flux<RedisZSetCommands.Tuple>	zRangeByScoreWithScores(ByteBuffer key, org.springframework.data.domain.Range<Double> range, RedisZSetCommands.Limit limit) Get RedisZSetCommands.Tuples in range from sorted set.
default reactor.core.publisher.Flux<RedisZSetCommands.Tuple>	zRangeWithScores(ByteBuffer key, org.springframework.data.domain.Range<Long> range) Get set of RedisZSetCommands.Tuples in range from sorted set.
default reactor.core.publisher.Mono<Long>	zRank(ByteBuffer key, ByteBuffer value) Determine the index of element with value in a sorted set.
reactor.core.publisher.Flux<ReactiveRedisConnection.NumericResponse<ReactiveZSetCommands.ZRankCommand,Long>>	zRank(org.reactivestreams.Publisher<ReactiveZSetCommands.ZRankCommand> commands) Determine the index of element with value in a sorted set when scored by ReactiveZSetCommands.ZRankCommand.getDirection().
default reactor.core.publisher.Mono<Long>	zRem(ByteBuffer key, ByteBuffer value) Remove value from sorted set.
default reactor.core.publisher.Mono<Long>	zRem(ByteBuffer key, Collection<ByteBuffer> values) Remove values from sorted set.
reactor.core.publisher.Flux<ReactiveRedisConnection.NumericResponse<ReactiveZSetCommands.ZRemCommand,Long>>	zRem(org.reactivestreams.Publisher<ReactiveZSetCommands.ZRemCommand> commands) Remove ReactiveZSetCommands.ZRemCommand.getValues() from sorted set.
default reactor.core.publisher.Mono<Long>	zRemRangeByLex(ByteBuffer key, org.springframework.data.domain.Range<String> range) Remove elements in Range from sorted set with key.
reactor.core.publisher.Flux<ReactiveRedisConnection.NumericResponse<ReactiveZSetCommands.ZRemRangeByLexCommand,Long>>	zRemRangeByLex(org.reactivestreams.Publisher<ReactiveZSetCommands.ZRemRangeByLexCommand> commands) Remove elements in Range from sorted set with ReactiveRedisConnection.KeyCommand.getKey().
default reactor.core.publisher.Mono<Long>	zRemRangeByRank(ByteBuffer key, org.springframework.data.domain.Range<Long> range) Remove elements in Range from sorted set with key.
reactor.core.publisher.Flux<ReactiveRedisConnection.NumericResponse<ReactiveZSetCommands.ZRemRangeByRankCommand,Long>>	zRemRangeByRank(org.reactivestreams.Publisher<ReactiveZSetCommands.ZRemRangeByRankCommand> commands) Remove elements in Range from sorted set with ReactiveRedisConnection.KeyCommand.getKey().
default reactor.core.publisher.Mono<Long>	zRemRangeByScore(ByteBuffer key, org.springframework.data.domain.Range<Double> range) Remove elements in Range from sorted set with key.
reactor.core.publisher.Flux<ReactiveRedisConnection.NumericResponse<ReactiveZSetCommands.ZRemRangeByScoreCommand,Long>>	zRemRangeByScore(org.reactivestreams.Publisher<ReactiveZSetCommands.ZRemRangeByScoreCommand> commands) Remove elements in Range from sorted set with ReactiveRedisConnection.KeyCommand.getKey().
default reactor.core.publisher.Flux<ByteBuffer>	zRevRange(ByteBuffer key, org.springframework.data.domain.Range<Long> range) Get elements in range from sorted set in reverse score ordering.
default reactor.core.publisher.Flux<ByteBuffer>	zRevRangeByLex(ByteBuffer key, org.springframework.data.domain.Range<String> range) Get all elements in Range from the sorted set at key in lexicographical ordering.
default reactor.core.publisher.Flux<ByteBuffer>	zRevRangeByLex(ByteBuffer key, org.springframework.data.domain.Range<String> range, RedisZSetCommands.Limit limit) Get all elements in Range from the sorted set at key in lexicographical ordering.
default reactor.core.publisher.Flux<ByteBuffer>	zRevRangeByScore(ByteBuffer key, org.springframework.data.domain.Range<Double> range) Get elements in range from sorted set in reverse score ordering.
default reactor.core.publisher.Flux<ByteBuffer>	zRevRangeByScore(ByteBuffer key, org.springframework.data.domain.Range<Double> range, RedisZSetCommands.Limit limit) Get elements in range from sorted set in reverse score ordering.
default reactor.core.publisher.Flux<RedisZSetCommands.Tuple>	zRevRangeByScoreWithScores(ByteBuffer key, org.springframework.data.domain.Range<Double> range) Get set of RedisZSetCommands.Tuples in range from sorted set in reverse score ordering.
default reactor.core.publisher.Flux<RedisZSetCommands.Tuple>	zRevRangeByScoreWithScores(ByteBuffer key, org.springframework.data.domain.Range<Double> range, RedisZSetCommands.Limit limit) Get RedisZSetCommands.Tuples in range from sorted set in reverse score ordering.
default reactor.core.publisher.Flux<RedisZSetCommands.Tuple>	zRevRangeWithScores(ByteBuffer key, org.springframework.data.domain.Range<Long> range) Get set of RedisZSetCommands.Tuples in range from sorted set in reverse score ordering.
default reactor.core.publisher.Mono<Long>	zRevRank(ByteBuffer key, ByteBuffer value) Determine the index of element with value in a sorted set when scored high to low.
default reactor.core.publisher.Flux<RedisZSetCommands.Tuple>	zScan(ByteBuffer key) Use a Flux to iterate over members in the sorted set at key.
default reactor.core.publisher.Flux<RedisZSetCommands.Tuple>	zScan(ByteBuffer key, ScanOptions options) Use a Flux to iterate over members in the sorted set at key given ScanOptions.
reactor.core.publisher.Flux<ReactiveRedisConnection.CommandResponse<ReactiveRedisConnection.KeyCommand,reactor.core.publisher.Flux<RedisZSetCommands.Tuple>>>	zScan(org.reactivestreams.Publisher<ReactiveRedisConnection.KeyScanCommand> commands) Use a Flux to iterate over members in the sorted set at key.
default reactor.core.publisher.Mono<Double>	zScore(ByteBuffer key, ByteBuffer value) Get the score of element with value from sorted set with key key.
reactor.core.publisher.Flux<ReactiveRedisConnection.NumericResponse<ReactiveZSetCommands.ZScoreCommand,Double>>	zScore(org.reactivestreams.Publisher<ReactiveZSetCommands.ZScoreCommand> commands) Get the score of element with ReactiveZSetCommands.ZScoreCommand.getValue() from sorted set with key ReactiveRedisConnection.KeyCommand.getKey()
default reactor.core.publisher.Flux<ByteBuffer>	zUnion(List<ByteBuffer> sets) Union sorted sets.
reactor.core.publisher.Flux<ReactiveRedisConnection.CommandResponse<ReactiveZSetCommands.ZAggregateCommand,reactor.core.publisher.Flux<ByteBuffer>>>	zUnion(org.reactivestreams.Publisher<? extends ReactiveZSetCommands.ZAggregateCommand> commands) Union sorted sets by applying aggregateFunction and apply weights to individual sets.
default reactor.core.publisher.Mono<Long>	zUnionStore(ByteBuffer destinationKey, List<ByteBuffer> sets) Union sorted sets and store result in destination destinationKey.
default reactor.core.publisher.Mono<Long>	zUnionStore(ByteBuffer destinationKey, List<ByteBuffer> sets, List<Double> weights) Union sorted sets and store result in destination destinationKey and apply weights to individual sets.
default reactor.core.publisher.Mono<Long>	zUnionStore(ByteBuffer destinationKey, List<ByteBuffer> sets, List<Double> weights, RedisZSetCommands.Aggregate aggregateFunction) Union sorted sets by applying aggregateFunction and store result in destination destinationKey and apply weights to individual sets.
default reactor.core.publisher.Mono<Long>	zUnionStore(ByteBuffer destinationKey, List<ByteBuffer> sets, RedisZSetCommands.Weights weights) Union sorted sets and store result in destination destinationKey and apply weights to individual sets.
default reactor.core.publisher.Mono<Long>	zUnionStore(ByteBuffer destinationKey, List<ByteBuffer> sets, RedisZSetCommands.Weights weights, RedisZSetCommands.Aggregate aggregateFunction) Union sorted sets by applying aggregateFunction and store result in destination destinationKey and apply weights to individual sets.
reactor.core.publisher.Flux<ReactiveRedisConnection.NumericResponse<ReactiveZSetCommands.ZAggregateStoreCommand,Long>>	zUnionStore(org.reactivestreams.Publisher<? extends ReactiveZSetCommands.ZAggregateStoreCommand> commands) Union sorted sets by applying aggregateFunction and store result in destination destinationKey and apply weights to individual sets.
default reactor.core.publisher.Flux<RedisZSetCommands.Tuple>	zUnionWithScores(List<ByteBuffer> sets) Union sorted sets.
default reactor.core.publisher.Flux<RedisZSetCommands.Tuple>	zUnionWithScores(List<ByteBuffer> sets, List<Double> weights) Union sorted sets and apply weights to individual sets.
default reactor.core.publisher.Flux<RedisZSetCommands.Tuple>	zUnionWithScores(List<ByteBuffer> sets, List<Double> weights, RedisZSetCommands.Aggregate aggregateFunction) Union sorted sets by applying aggregateFunction and apply weights to individual sets.
default reactor.core.publisher.Flux<RedisZSetCommands.Tuple>	zUnionWithScores(List<ByteBuffer> sets, RedisZSetCommands.Weights weights) Union sorted sets and apply weights to individual sets.
default reactor.core.publisher.Flux<RedisZSetCommands.Tuple>	zUnionWithScores(List<ByteBuffer> sets, RedisZSetCommands.Weights weights, RedisZSetCommands.Aggregate aggregateFunction) Union sorted sets by applying aggregateFunction and apply weights to individual sets.
reactor.core.publisher.Flux<ReactiveRedisConnection.CommandResponse<ReactiveZSetCommands.ZAggregateCommand,reactor.core.publisher.Flux<RedisZSetCommands.Tuple>>>	zUnionWithScores(org.reactivestreams.Publisher<? extends ReactiveZSetCommands.ZAggregateCommand> commands) Union sorted sets by applying aggregateFunction and apply weights to individual sets.

Method Detail

zAdd

default reactor.core.publisher.Mono<Long> zAdd(ByteBuffer key,
                                               Double score,
                                               ByteBuffer value)

Add value to a sorted set at key, or update its score if it already exists.

Parameters:

key - must not be null.

score - must not be null.

value - must not be null.

Returns:

See Also:

Redis Documentation: ZADD

zAdd

default reactor.core.publisher.Mono<Long> zAdd(ByteBuffer key,
                                               Collection<? extends RedisZSetCommands.Tuple> tuples)

Add a tuples to a sorted set at key, or update their score if it already exists.

Parameters:

key - must not be null.

tuples - must not be null.

Returns:

See Also:

Redis Documentation: ZADD

zAdd

reactor.core.publisher.Flux<ReactiveRedisConnection.NumericResponse<ReactiveZSetCommands.ZAddCommand,Number>> zAdd(org.reactivestreams.Publisher<ReactiveZSetCommands.ZAddCommand> commands)

Add ReactiveZSetCommands.ZAddCommand.getTuples() to a sorted set at ReactiveRedisConnection.KeyCommand.getKey(), or update its score if it already exists.

Parameters:

commands - must not be null.

Returns:

See Also:

Redis Documentation: ZADD

zRem

default reactor.core.publisher.Mono<Long> zRem(ByteBuffer key,
                                               ByteBuffer value)

Remove value from sorted set. Return number of removed elements.

Parameters:

key - must not be null.

value - must not be null.

Returns:

See Also:

Redis Documentation: ZREM

zRem

default reactor.core.publisher.Mono<Long> zRem(ByteBuffer key,
                                               Collection<ByteBuffer> 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

zRem

reactor.core.publisher.Flux<ReactiveRedisConnection.NumericResponse<ReactiveZSetCommands.ZRemCommand,Long>> zRem(org.reactivestreams.Publisher<ReactiveZSetCommands.ZRemCommand> commands)

Remove ReactiveZSetCommands.ZRemCommand.getValues() from sorted set. Return number of removed elements.

Parameters:

commands - must not be null.

Returns:

See Also:

Redis Documentation: ZREM

zIncrBy

default reactor.core.publisher.Mono<Double> zIncrBy(ByteBuffer key,
                                                    Number increment,
                                                    ByteBuffer value)

Increment the score of element with value in sorted set by increment.

Parameters:

key - must not be null.

increment - must not be null.

value - must not be null.

Returns:

See Also:

Redis Documentation: ZINCRBY

zIncrBy

reactor.core.publisher.Flux<ReactiveRedisConnection.NumericResponse<ReactiveZSetCommands.ZIncrByCommand,Double>> zIncrBy(org.reactivestreams.Publisher<ReactiveZSetCommands.ZIncrByCommand> commands)

Increment the score of element with ReactiveZSetCommands.ZIncrByCommand.getValue() in sorted set by ReactiveZSetCommands.ZIncrByCommand.getIncrement().

Parameters:

commands - must not be null.

Returns:

See Also:

Redis Documentation: ZINCRBY

zRandMember

default reactor.core.publisher.Mono<ByteBuffer> zRandMember(ByteBuffer key)

Get random element from sorted set at key.

Parameters:

key - must not be null.

Returns:

Since:

2.6

See Also:

Redis Documentation: ZRANDMEMBER

zRandMember

default reactor.core.publisher.Flux<ByteBuffer> zRandMember(ByteBuffer key,
                                                            long count)

Get count random elements from sorted set at key.

Parameters:

key - must not be null.

count - if the provided count argument is positive, return a list of distinct fields, capped either at count or the set size. If count is negative, the behavior changes and the command is allowed to return the same value multiple times. In this case, the number of returned values is the absolute value of the specified count.

Returns:

Since:

2.6

See Also:

Redis Documentation: ZRANDMEMBER

zRandMember

reactor.core.publisher.Flux<ReactiveRedisConnection.CommandResponse<ReactiveZSetCommands.ZRandMemberCommand,reactor.core.publisher.Flux<ByteBuffer>>> zRandMember(org.reactivestreams.Publisher<ReactiveZSetCommands.ZRandMemberCommand> commands)

Get random elements from sorted set at key.

Parameters:

commands - must not be null.

Returns:

Since:

2.6

See Also:

Redis Documentation: ZRANDMEMBER

zRandMemberWithScore

default reactor.core.publisher.Mono<RedisZSetCommands.Tuple> zRandMemberWithScore(ByteBuffer key)

Get random element from sorted set at key.

Parameters:

key - must not be null.

Returns:

Since:

2.6

See Also:

Redis Documentation: ZRANDMEMBER

zRandMemberWithScore

default reactor.core.publisher.Flux<RedisZSetCommands.Tuple> zRandMemberWithScore(ByteBuffer key,
                                                                                  long count)

Get count random elements from sorted set at key.

Parameters:

key - must not be null.

count - if the provided count argument is positive, return a list of distinct fields, capped either at count or the set size. If count is negative, the behavior changes and the command is allowed to return the same value multiple times. In this case, the number of returned values is the absolute value of the specified count.

Returns:

Since:

2.6

See Also:

Redis Documentation: ZRANDMEMBER

zRandMemberWithScore

reactor.core.publisher.Flux<ReactiveRedisConnection.CommandResponse<ReactiveZSetCommands.ZRandMemberCommand,reactor.core.publisher.Flux<RedisZSetCommands.Tuple>>> zRandMemberWithScore(org.reactivestreams.Publisher<ReactiveZSetCommands.ZRandMemberCommand> commands)

Get random elements from sorted set at key.

Parameters:

commands - must not be null.

Returns:

Since:

2.6

See Also:

Redis Documentation: ZRANDMEMBER

zRank

default reactor.core.publisher.Mono<Long> zRank(ByteBuffer key,
                                                ByteBuffer value)

Determine the index of element with value in a sorted set.

Parameters:

key - must not be null.

value - must not be null.

Returns:

See Also:

Redis Documentation: ZRANK

zRevRank

default reactor.core.publisher.Mono<Long> zRevRank(ByteBuffer key,
                                                   ByteBuffer value)

Determine the index of element with value in a sorted set when scored high to low.

Parameters:

key - must not be null.

value - must not be null.

Returns:

See Also:

Redis Documentation: ZREVRANK

zRank

reactor.core.publisher.Flux<ReactiveRedisConnection.NumericResponse<ReactiveZSetCommands.ZRankCommand,Long>> zRank(org.reactivestreams.Publisher<ReactiveZSetCommands.ZRankCommand> commands)

Determine the index of element with value in a sorted set when scored by ReactiveZSetCommands.ZRankCommand.getDirection().

Parameters:

commands - must not be null.

Returns:

See Also:

Redis Documentation: ZRANK, Redis Documentation: ZREVRANK

zRange

default reactor.core.publisher.Flux<ByteBuffer> zRange(ByteBuffer key,
                                                       org.springframework.data.domain.Range<Long> range)

Get elements in range from sorted set.

Parameters:

key - must not be null.

range - must not be null.

Returns:

See Also:

Redis Documentation: ZRANGE

zRangeWithScores

default reactor.core.publisher.Flux<RedisZSetCommands.Tuple> zRangeWithScores(ByteBuffer key,
                                                                              org.springframework.data.domain.Range<Long> range)

Get set of RedisZSetCommands.Tuples in range from sorted set.

Parameters:

key - must not be null.

range - must not be null.

Returns:

See Also:

Redis Documentation: ZRANGE

zRevRange

default reactor.core.publisher.Flux<ByteBuffer> zRevRange(ByteBuffer key,
                                                          org.springframework.data.domain.Range<Long> range)

Get elements in range from sorted set in reverse score ordering.

Parameters:

key - must not be null.

range - must not be null.

Returns:

See Also:

Redis Documentation: ZREVRANGE

zRevRangeWithScores

default reactor.core.publisher.Flux<RedisZSetCommands.Tuple> zRevRangeWithScores(ByteBuffer key,
                                                                                 org.springframework.data.domain.Range<Long> range)

Get set of RedisZSetCommands.Tuples in range from sorted set in reverse score ordering.

Parameters:

key - must not be null.

range - must not be null.

Returns:

See Also:

Redis Documentation: ZREVRANGE

zRange

reactor.core.publisher.Flux<ReactiveRedisConnection.CommandResponse<ReactiveZSetCommands.ZRangeCommand,reactor.core.publisher.Flux<RedisZSetCommands.Tuple>>> zRange(org.reactivestreams.Publisher<ReactiveZSetCommands.ZRangeCommand> commands)

Get set of RedisZSetCommands.Tuples in range from sorted set.

Parameters:

commands - must not be null.

Returns:

See Also:

Redis Documentation: ZRANGE, Redis Documentation: ZREVRANGE

zRangeByScore

default reactor.core.publisher.Flux<ByteBuffer> zRangeByScore(ByteBuffer key,
                                                              org.springframework.data.domain.Range<Double> range)

Get elements in range from sorted set.

Parameters:

key - must not be null.

range - must not be null.

Returns:

See Also:

Redis Documentation: ZRANGEBYSCORE

zRangeByScore

default reactor.core.publisher.Flux<ByteBuffer> zRangeByScore(ByteBuffer key,
                                                              org.springframework.data.domain.Range<Double> range,
                                                              RedisZSetCommands.Limit limit)

Get elements in range from sorted set.

Parameters:

key - must not be null.

range - must not be null.

limit - must not be null.

Returns:

See Also:

Redis Documentation: ZRANGEBYSCORE

zRangeByScoreWithScores

default reactor.core.publisher.Flux<RedisZSetCommands.Tuple> zRangeByScoreWithScores(ByteBuffer key,
                                                                                     org.springframework.data.domain.Range<Double> range)

Get RedisZSetCommands.Tuples in range from sorted set.

Parameters:

key - must not be null.

range - must not be null.

Returns:

See Also:

Redis Documentation: ZRANGEBYSCORE

zRangeByScoreWithScores

default reactor.core.publisher.Flux<RedisZSetCommands.Tuple> zRangeByScoreWithScores(ByteBuffer key,
                                                                                     org.springframework.data.domain.Range<Double> range,
                                                                                     RedisZSetCommands.Limit limit)

Get RedisZSetCommands.Tuples in range from sorted set.

Parameters:

key - must not be null.

range - must not be null.

limit - must not be null.

Returns:

See Also:

Redis Documentation: ZRANGEBYSCORE

zRevRangeByScore

default reactor.core.publisher.Flux<ByteBuffer> zRevRangeByScore(ByteBuffer key,
                                                                 org.springframework.data.domain.Range<Double> range)

Get elements in range from sorted set in reverse score ordering.

Parameters:

key - must not be null.

range - must not be null.

Returns:

See Also:

Redis Documentation: ZREVRANGEBYSCORE

zRevRangeByScore

default reactor.core.publisher.Flux<ByteBuffer> zRevRangeByScore(ByteBuffer key,
                                                                 org.springframework.data.domain.Range<Double> range,
                                                                 RedisZSetCommands.Limit limit)

Get elements in range from sorted set in reverse score ordering.

Parameters:

key - must not be null.

range - must not be null.

limit - must not be null.

Returns:

See Also:

Redis Documentation: ZREVRANGEBYSCORE

zRevRangeByScoreWithScores

default reactor.core.publisher.Flux<RedisZSetCommands.Tuple> zRevRangeByScoreWithScores(ByteBuffer key,
                                                                                        org.springframework.data.domain.Range<Double> range)

Get set of RedisZSetCommands.Tuples in range from sorted set in reverse score ordering.

Parameters:

key - must not be null.

range - must not be null.

Returns:

See Also:

Redis Documentation: ZREVRANGEBYSCORE

zRevRangeByScoreWithScores

default reactor.core.publisher.Flux<RedisZSetCommands.Tuple> zRevRangeByScoreWithScores(ByteBuffer key,
                                                                                        org.springframework.data.domain.Range<Double> range,
                                                                                        RedisZSetCommands.Limit limit)

Get RedisZSetCommands.Tuples in range from sorted set in reverse score ordering.

Parameters:

key - must not be null.

range - must not be null.

limit - must not be null.

Returns:

See Also:

Redis Documentation: ZREVRANGEBYSCORE

zRangeByScore

reactor.core.publisher.Flux<ReactiveRedisConnection.CommandResponse<ReactiveZSetCommands.ZRangeByScoreCommand,reactor.core.publisher.Flux<RedisZSetCommands.Tuple>>> zRangeByScore(org.reactivestreams.Publisher<ReactiveZSetCommands.ZRangeByScoreCommand> commands)

Get RedisZSetCommands.Tuples in range from sorted set.

Parameters:

commands - must not be null.

Returns:

See Also:

Redis Documentation: ZRANGEBYSCORE, Redis Documentation: ZREVRANGEBYSCORE

zScan

default reactor.core.publisher.Flux<RedisZSetCommands.Tuple> zScan(ByteBuffer key)

Use a Flux to iterate over members 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 raw tuples one by one.

Throws:

IllegalArgumentException - when key is null.

Since:

2.1

See Also:

Redis Documentation: ZSCAN

zScan

default reactor.core.publisher.Flux<RedisZSetCommands.Tuple> zScan(ByteBuffer key,
                                                                   ScanOptions options)

Use a Flux to iterate over members 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.

Parameters:

key - must not be null.

options - must not be null. Use ScanOptions.NONE instead.

Returns:

the Flux emitting the raw tuples one by one.

Throws:

IllegalArgumentException - when one of the required arguments is null.

Since:

2.1

See Also:

Redis Documentation: ZSCAN

zScan

reactor.core.publisher.Flux<ReactiveRedisConnection.CommandResponse<ReactiveRedisConnection.KeyCommand,reactor.core.publisher.Flux<RedisZSetCommands.Tuple>>> zScan(org.reactivestreams.Publisher<ReactiveRedisConnection.KeyScanCommand> commands)

Use a Flux to iterate over members 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:

commands - must not be null.

Returns:

Since:

2.1

See Also:

Redis Documentation: ZSCAN

zCount

default reactor.core.publisher.Mono<Long> zCount(ByteBuffer key,
                                                 org.springframework.data.domain.Range<Double> range)

Count number of elements within sorted set with scores within Range.
NOTE please use Double.NEGATIVE_INFINITY for -inf and Double.POSITIVE_INFINITY for +inf.

Parameters:

key - must not be null.

range - must not be null.

Returns:

See Also:

Redis Documentation: ZCOUNT

zCount

reactor.core.publisher.Flux<ReactiveRedisConnection.NumericResponse<ReactiveZSetCommands.ZCountCommand,Long>> zCount(org.reactivestreams.Publisher<ReactiveZSetCommands.ZCountCommand> commands)

Count number of elements within sorted set with scores within Range.
NOTE please use Double.NEGATIVE_INFINITY for -inf and Double.POSITIVE_INFINITY for +inf.

Parameters:

commands - must not be null.

Returns:

See Also:

Redis Documentation: ZCOUNT

zLexCount

default reactor.core.publisher.Mono<Long> zLexCount(ByteBuffer key,
                                                    org.springframework.data.domain.Range<String> range)

Count number of elements within sorted set with value between Range#min and Range#max applying lexicographical ordering.

Parameters:

key - must not be null.

range - must not be null.

Returns:

Since:

2.4

See Also:

Redis Documentation: ZLEXCOUNT

zLexCount

reactor.core.publisher.Flux<ReactiveRedisConnection.NumericResponse<ReactiveZSetCommands.ZLexCountCommand,Long>> zLexCount(org.reactivestreams.Publisher<ReactiveZSetCommands.ZLexCountCommand> commands)

Count number of elements within sorted set with value between Range#min and Range#max applying lexicographical ordering.

Parameters:

commands - must not be null.

Returns:

Since:

2.4

See Also:

Redis Documentation: ZLEXCOUNT

zPopMin

default reactor.core.publisher.Mono<RedisZSetCommands.Tuple> zPopMin(ByteBuffer 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

zPopMin

default reactor.core.publisher.Flux<RedisZSetCommands.Tuple> zPopMin(ByteBuffer 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

bZPopMin

default reactor.core.publisher.Mono<RedisZSetCommands.Tuple> bZPopMin(ByteBuffer key,
                                                                      Duration timeout)

Remove and return the value with its score having the lowest score from sorted set at key. Blocks connection until element available or timeout reached.

Parameters:

key - must not be null.

timeout - must not be null.

Returns:

Throws:

IllegalArgumentException - if the timeout is null or negative.

Since:

2.6

See Also:

Redis Documentation: BZPOPMIN

zPopMax

default reactor.core.publisher.Mono<RedisZSetCommands.Tuple> zPopMax(ByteBuffer 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

zPopMax

default reactor.core.publisher.Flux<RedisZSetCommands.Tuple> zPopMax(ByteBuffer 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

bZPopMax

default reactor.core.publisher.Mono<RedisZSetCommands.Tuple> bZPopMax(ByteBuffer key,
                                                                      Duration timeout)

Remove and return the value with its score having the highest score from sorted set at key. Blocks connection until element available or timeout reached.

Parameters:

key - must not be null.

timeout - must not be null.

Returns:

Throws:

IllegalArgumentException - if the timeout is null or negative.

Since:

2.6

See Also:

Redis Documentation: BZPOPMAX

zPop

reactor.core.publisher.Flux<ReactiveRedisConnection.CommandResponse<ReactiveZSetCommands.ZPopCommand,reactor.core.publisher.Flux<RedisZSetCommands.Tuple>>> zPop(org.reactivestreams.Publisher<ReactiveZSetCommands.ZPopCommand> commands)

Remove and return elements from sorted set at keyCommand#getKey().

Parameters:

commands - must not be null.

Returns:

See Also:

Redis Documentation: ZPOPMIN, Redis Documentation: ZPOPMAX

bZPop

reactor.core.publisher.Flux<ReactiveRedisConnection.CommandResponse<ReactiveZSetCommands.BZPopCommand,reactor.core.publisher.Flux<RedisZSetCommands.Tuple>>> bZPop(org.reactivestreams.Publisher<ReactiveZSetCommands.BZPopCommand> commands)

Remove and return elements from sorted set at keyCommand#getKey().

Parameters:

commands - must not be null.

Returns:

See Also:

Redis Documentation: ZPOPMIN, Redis Documentation: ZPOPMAX

zCard

default reactor.core.publisher.Mono<Long> zCard(ByteBuffer key)

Get the size of sorted set with key.

Parameters:

key - must not be null.

Returns:

See Also:

Redis Documentation: ZCARD

zCard

reactor.core.publisher.Flux<ReactiveRedisConnection.NumericResponse<ReactiveRedisConnection.KeyCommand,Long>> zCard(org.reactivestreams.Publisher<ReactiveRedisConnection.KeyCommand> commands)

Get the size of sorted set with .

Parameters:

commands - must not be null.

Returns:

See Also:

Redis Documentation: ZCARD

zScore

default reactor.core.publisher.Mono<Double> zScore(ByteBuffer key,
                                                   ByteBuffer value)

Get the score of element with value from sorted set with key key.

Parameters:

key - must not be null.

value - must not be null.

Returns:

See Also:

Redis Documentation: ZSCORE

zScore

reactor.core.publisher.Flux<ReactiveRedisConnection.NumericResponse<ReactiveZSetCommands.ZScoreCommand,Double>> zScore(org.reactivestreams.Publisher<ReactiveZSetCommands.ZScoreCommand> commands)

Get the score of element with ReactiveZSetCommands.ZScoreCommand.getValue() from sorted set with key ReactiveRedisConnection.KeyCommand.getKey()

Parameters:

commands - must not be null.

Returns:

See Also:

Redis Documentation: ZSCORE

zMScore

default reactor.core.publisher.Mono<List<Double>> zMScore(ByteBuffer key,
                                                          Collection<ByteBuffer> values)

Get the scores of elements with values from sorted set with key key.

Parameters:

key - must not be null.

values - must not be null.

Returns:

Since:

2.6

See Also:

Redis Documentation: ZMSCORE

zMScore

reactor.core.publisher.Flux<ReactiveRedisConnection.MultiValueResponse<ReactiveZSetCommands.ZMScoreCommand,Double>> zMScore(org.reactivestreams.Publisher<ReactiveZSetCommands.ZMScoreCommand> commands)

Get the scores of elements with ReactiveZSetCommands.ZMScoreCommand.getValues() from sorted set with key ReactiveRedisConnection.KeyCommand.getKey()

Parameters:

commands - must not be null.

Returns:

Since:

2.6

See Also:

Redis Documentation: ZMSCORE

zRemRangeByRank

default reactor.core.publisher.Mono<Long> zRemRangeByRank(ByteBuffer key,
                                                          org.springframework.data.domain.Range<Long> range)

Remove elements in Range from sorted set with key.

Parameters:

key - must not be null.

range - must not be null.

Returns:

See Also:

Redis Documentation: ZREMRANGEBYRANK

zRemRangeByRank

reactor.core.publisher.Flux<ReactiveRedisConnection.NumericResponse<ReactiveZSetCommands.ZRemRangeByRankCommand,Long>> zRemRangeByRank(org.reactivestreams.Publisher<ReactiveZSetCommands.ZRemRangeByRankCommand> commands)

Remove elements in Range from sorted set with ReactiveRedisConnection.KeyCommand.getKey().

Parameters:

commands - must not be null.

Returns:

See Also:

Redis Documentation: ZREMRANGEBYRANK

zRemRangeByScore

default reactor.core.publisher.Mono<Long> zRemRangeByScore(ByteBuffer key,
                                                           org.springframework.data.domain.Range<Double> range)

Remove elements in Range from sorted set with key.

Parameters:

key - must not be null.

range - must not be null.

Returns:

See Also:

Redis Documentation: ZREMRANGEBYSCORE

zRemRangeByScore

reactor.core.publisher.Flux<ReactiveRedisConnection.NumericResponse<ReactiveZSetCommands.ZRemRangeByScoreCommand,Long>> zRemRangeByScore(org.reactivestreams.Publisher<ReactiveZSetCommands.ZRemRangeByScoreCommand> commands)

Remove elements in Range from sorted set with ReactiveRedisConnection.KeyCommand.getKey().

Parameters:

commands - must not be null.

Returns:

See Also:

Redis Documentation: ZREMRANGEBYSCORE

zRemRangeByLex

default reactor.core.publisher.Mono<Long> zRemRangeByLex(ByteBuffer 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 of removed elements.

Since:

2.5

See Also:

Redis Documentation: ZREMRANGEBYLEX

zRemRangeByLex

reactor.core.publisher.Flux<ReactiveRedisConnection.NumericResponse<ReactiveZSetCommands.ZRemRangeByLexCommand,Long>> zRemRangeByLex(org.reactivestreams.Publisher<ReactiveZSetCommands.ZRemRangeByLexCommand> commands)

Remove elements in Range from sorted set with ReactiveRedisConnection.KeyCommand.getKey().

Parameters:

commands - must not be null.

Returns:

Since:

2.5

See Also:

Redis Documentation: ZREMRANGEBYLEX

zDiff

default reactor.core.publisher.Flux<ByteBuffer> zDiff(List<ByteBuffer> sets)

Diff sorted sets.

Parameters:

sets - must not be null.

Returns:

Since:

2.6

See Also:

Redis Documentation: ZDIFF

zDiff

reactor.core.publisher.Flux<ReactiveRedisConnection.CommandResponse<ReactiveZSetCommands.ZDiffCommand,reactor.core.publisher.Flux<ByteBuffer>>> zDiff(org.reactivestreams.Publisher<? extends ReactiveZSetCommands.ZDiffCommand> commands)

Diff sorted sets.

Parameters:

commands -

Returns:

Since:

2.6

See Also:

Redis Documentation: ZDIFF

zDiffWithScores

default reactor.core.publisher.Flux<RedisZSetCommands.Tuple> zDiffWithScores(List<ByteBuffer> sets)

Diff sorted sets.

Parameters:

sets - must not be null.

Returns:

Since:

2.6

See Also:

Redis Documentation: ZDIFF

zDiffWithScores

reactor.core.publisher.Flux<ReactiveRedisConnection.CommandResponse<ReactiveZSetCommands.ZDiffCommand,reactor.core.publisher.Flux<RedisZSetCommands.Tuple>>> zDiffWithScores(org.reactivestreams.Publisher<? extends ReactiveZSetCommands.ZDiffCommand> commands)

Diff sorted sets.

Parameters:

commands -

Returns:

Since:

2.6

See Also:

Redis Documentation: ZDIFF

zDiffStore

default reactor.core.publisher.Mono<Long> zDiffStore(ByteBuffer destinationKey,
                                                     List<ByteBuffer> sets)

Diff sorted sets and store result in destination destinationKey.

Parameters:

destinationKey - must not be null.

sets - must not be null.

Returns:

Since:

2.6

See Also:

Redis Documentation: ZDIFFSTORE

zDiffStore

reactor.core.publisher.Flux<ReactiveRedisConnection.NumericResponse<ReactiveZSetCommands.ZDiffStoreCommand,Long>> zDiffStore(org.reactivestreams.Publisher<ReactiveZSetCommands.ZDiffStoreCommand> commands)

Diff sorted sets and store result in destination destinationKey.

Parameters:

commands -

Returns:

Since:

2.6

See Also:

Redis Documentation: ZDIFFSTORE

zInter

default reactor.core.publisher.Flux<ByteBuffer> zInter(List<ByteBuffer> sets)

Intersect sorted sets.

Parameters:

sets - must not be null.

Returns:

Since:

2.6

See Also:

Redis Documentation: ZINTER

zInter

reactor.core.publisher.Flux<ReactiveRedisConnection.CommandResponse<ReactiveZSetCommands.ZAggregateCommand,reactor.core.publisher.Flux<ByteBuffer>>> zInter(org.reactivestreams.Publisher<? extends ReactiveZSetCommands.ZAggregateCommand> commands)

Intersect sorted sets by applying aggregateFunction and apply weights to individual sets.

Parameters:

commands -

Returns:

Since:

2.6

See Also:

Redis Documentation: ZINTER

zInterWithScores

default reactor.core.publisher.Flux<RedisZSetCommands.Tuple> zInterWithScores(List<ByteBuffer> sets)

Intersect sorted sets.

Parameters:

sets - must not be null.

Returns:

Since:

2.6

See Also:

Redis Documentation: ZINTER

zInterWithScores

default reactor.core.publisher.Flux<RedisZSetCommands.Tuple> zInterWithScores(List<ByteBuffer> sets,
                                                                              List<Double> weights)

Intersect sorted sets and apply weights to individual sets.

Parameters:

sets - must not be null.

weights - must not be null.

Returns:

Since:

2.6

See Also:

Redis Documentation: ZINTER

zInterWithScores

default reactor.core.publisher.Flux<RedisZSetCommands.Tuple> zInterWithScores(List<ByteBuffer> sets,
                                                                              RedisZSetCommands.Weights weights)

Intersect sorted sets and apply weights to individual sets.

Parameters:

sets - must not be null.

weights - must not be null.

Returns:

Since:

2.6

See Also:

Redis Documentation: ZINTER

zInterWithScores

default reactor.core.publisher.Flux<RedisZSetCommands.Tuple> zInterWithScores(List<ByteBuffer> sets,
                                                                              List<Double> weights,
                                                                              @Nullable
                                                                              RedisZSetCommands.Aggregate aggregateFunction)

Intersect sorted sets by applying aggregateFunction and apply weights to individual sets.

Parameters:

sets - must not be null.

weights - must not be null.

aggregateFunction - can be null.

Returns:

Since:

2.6

See Also:

Redis Documentation: ZINTER

zInterWithScores

default reactor.core.publisher.Flux<RedisZSetCommands.Tuple> zInterWithScores(List<ByteBuffer> sets,
                                                                              RedisZSetCommands.Weights weights,
                                                                              @Nullable
                                                                              RedisZSetCommands.Aggregate aggregateFunction)

Intersect sorted sets by applying aggregateFunction and apply weights to individual sets.

Parameters:

sets - must not be null.

weights - must not be null.

aggregateFunction - can be null.

Returns:

Since:

2.6

See Also:

Redis Documentation: ZINTER

zInterWithScores

reactor.core.publisher.Flux<ReactiveRedisConnection.CommandResponse<ReactiveZSetCommands.ZAggregateCommand,reactor.core.publisher.Flux<RedisZSetCommands.Tuple>>> zInterWithScores(org.reactivestreams.Publisher<? extends ReactiveZSetCommands.ZAggregateCommand> commands)

Intersect sorted sets by applying aggregateFunction and apply weights to individual sets.

Parameters:

commands -

Returns:

Since:

2.6

See Also:

Redis Documentation: ZINTER

zInterStore

default reactor.core.publisher.Mono<Long> zInterStore(ByteBuffer destinationKey,
                                                      List<ByteBuffer> sets)

Intersect sorted sets and store result in destination destinationKey.

Parameters:

destinationKey - must not be null.

sets - must not be null.

Returns:

See Also:

Redis Documentation: ZINTERSTORE

zInterStore

default reactor.core.publisher.Mono<Long> zInterStore(ByteBuffer destinationKey,
                                                      List<ByteBuffer> sets,
                                                      List<Double> weights)

Intersect sorted sets and store result in destination destinationKey and apply weights to individual sets.

Parameters:

destinationKey - must not be null.

sets - must not be null.

weights - must not be null.

Returns:

See Also:

Redis Documentation: ZINTERSTORE

zInterStore

default reactor.core.publisher.Mono<Long> zInterStore(ByteBuffer destinationKey,
                                                      List<ByteBuffer> sets,
                                                      RedisZSetCommands.Weights weights)

Intersect sorted sets and store result in destination destinationKey and apply weights to individual sets.

Parameters:

destinationKey - must not be null.

sets - must not be null.

weights - must not be null.

Returns:

Since:

2.1

See Also:

Redis Documentation: ZINTERSTORE

zInterStore

default reactor.core.publisher.Mono<Long> zInterStore(ByteBuffer destinationKey,
                                                      List<ByteBuffer> sets,
                                                      List<Double> weights,
                                                      @Nullable
                                                      RedisZSetCommands.Aggregate aggregateFunction)

Intersect sorted sets by applying aggregateFunction and store result in destination destinationKey and apply weights to individual sets.

Parameters:

destinationKey - must not be null.

sets - must not be null.

weights - must not be null.

aggregateFunction - can be null.

Returns:

See Also:

Redis Documentation: ZINTERSTORE

zInterStore

default reactor.core.publisher.Mono<Long> zInterStore(ByteBuffer destinationKey,
                                                      List<ByteBuffer> sets,
                                                      RedisZSetCommands.Weights weights,
                                                      @Nullable
                                                      RedisZSetCommands.Aggregate aggregateFunction)

Intersect sorted sets by applying aggregateFunction and store result in destination destinationKey and apply weights to individual sets.

Parameters:

destinationKey - must not be null.

sets - must not be null.

weights - must not be null.

aggregateFunction - can be null.

Returns:

Since:

2.1

See Also:

Redis Documentation: ZINTERSTORE

zInterStore

reactor.core.publisher.Flux<ReactiveRedisConnection.NumericResponse<ReactiveZSetCommands.ZAggregateStoreCommand,Long>> zInterStore(org.reactivestreams.Publisher<? extends ReactiveZSetCommands.ZAggregateStoreCommand> commands)

Intersect sorted sets by applying aggregateFunction and store result in destination destinationKey and apply weights to individual sets.

Parameters:

commands -

Returns:

See Also:

Redis Documentation: ZINTERSTORE

zUnion

default reactor.core.publisher.Flux<ByteBuffer> zUnion(List<ByteBuffer> sets)

Union sorted sets.

Parameters:

sets - must not be null.

Returns:

Since:

2.6

See Also:

Redis Documentation: ZUNION

zUnionWithScores

default reactor.core.publisher.Flux<RedisZSetCommands.Tuple> zUnionWithScores(List<ByteBuffer> sets)

Union sorted sets.

Parameters:

sets - must not be null.

Returns:

Since:

2.6

See Also:

Redis Documentation: ZUNION

zUnionWithScores

default reactor.core.publisher.Flux<RedisZSetCommands.Tuple> zUnionWithScores(List<ByteBuffer> sets,
                                                                              List<Double> weights)

Union sorted sets and apply weights to individual sets.

Parameters:

sets - must not be null.

weights - must not be null.

Returns:

Since:

2.6

See Also:

Redis Documentation: ZUNION

zUnionWithScores

default reactor.core.publisher.Flux<RedisZSetCommands.Tuple> zUnionWithScores(List<ByteBuffer> sets,
                                                                              RedisZSetCommands.Weights weights)

Union sorted sets and apply weights to individual sets.

Parameters:

sets - must not be null.

weights - must not be null.

Returns:

Since:

2.6

See Also:

Redis Documentation: ZUNION

zUnionWithScores

default reactor.core.publisher.Flux<RedisZSetCommands.Tuple> zUnionWithScores(List<ByteBuffer> sets,
                                                                              List<Double> weights,
                                                                              @Nullable
                                                                              RedisZSetCommands.Aggregate aggregateFunction)

Union sorted sets by applying aggregateFunction and apply weights to individual sets.

Parameters:

sets - must not be null.

weights - can be null.

aggregateFunction - can be null.

Returns:

Since:

2.6

See Also:

Redis Documentation: ZUNION

zUnionWithScores

default reactor.core.publisher.Flux<RedisZSetCommands.Tuple> zUnionWithScores(List<ByteBuffer> sets,
                                                                              RedisZSetCommands.Weights weights,
                                                                              @Nullable
                                                                              RedisZSetCommands.Aggregate aggregateFunction)

Union sorted sets by applying aggregateFunction and apply weights to individual sets.

Parameters:

sets - must not be null.

weights - can be null.

aggregateFunction - can be null.

Returns:

Since:

2.6

See Also:

Redis Documentation: ZUNION

zUnionWithScores

reactor.core.publisher.Flux<ReactiveRedisConnection.CommandResponse<ReactiveZSetCommands.ZAggregateCommand,reactor.core.publisher.Flux<RedisZSetCommands.Tuple>>> zUnionWithScores(org.reactivestreams.Publisher<? extends ReactiveZSetCommands.ZAggregateCommand> commands)

Union sorted sets by applying aggregateFunction and apply weights to individual sets.

Parameters:

commands -

Returns:

Since:

2.6

See Also:

Redis Documentation: ZUNION

zUnion

reactor.core.publisher.Flux<ReactiveRedisConnection.CommandResponse<ReactiveZSetCommands.ZAggregateCommand,reactor.core.publisher.Flux<ByteBuffer>>> zUnion(org.reactivestreams.Publisher<? extends ReactiveZSetCommands.ZAggregateCommand> commands)

Union sorted sets by applying aggregateFunction and apply weights to individual sets.

Parameters:

commands -

Returns:

Since:

2.6

See Also:

Redis Documentation: ZUNION

zUnionStore

default reactor.core.publisher.Mono<Long> zUnionStore(ByteBuffer destinationKey,
                                                      List<ByteBuffer> sets)

Union sorted sets and store result in destination destinationKey.

Parameters:

destinationKey - must not be null.

sets - must not be null.

Returns:

See Also:

Redis Documentation: ZUNIONSTORE

zUnionStore

default reactor.core.publisher.Mono<Long> zUnionStore(ByteBuffer destinationKey,
                                                      List<ByteBuffer> sets,
                                                      List<Double> weights)

Union sorted sets and store result in destination destinationKey and apply weights to individual sets.

Parameters:

destinationKey - must not be null.

sets - must not be null.

weights - must not be null.

Returns:

See Also:

Redis Documentation: ZUNIONSTORE

zUnionStore

default reactor.core.publisher.Mono<Long> zUnionStore(ByteBuffer destinationKey,
                                                      List<ByteBuffer> sets,
                                                      RedisZSetCommands.Weights weights)

Union sorted sets and store result in destination destinationKey and apply weights to individual sets.

Parameters:

destinationKey - must not be null.

sets - must not be null.

weights - must not be null.

Returns:

Since:

2.1

See Also:

Redis Documentation: ZUNIONSTORE

zUnionStore

default reactor.core.publisher.Mono<Long> zUnionStore(ByteBuffer destinationKey,
                                                      List<ByteBuffer> sets,
                                                      List<Double> weights,
                                                      @Nullable
                                                      RedisZSetCommands.Aggregate aggregateFunction)

Union sorted sets by applying aggregateFunction and store result in destination destinationKey and apply weights to individual sets.

Parameters:

destinationKey - must not be null.

sets - must not be null.

weights - can be null.

aggregateFunction - can be null.

Returns:

See Also:

Redis Documentation: ZUNIONSTORE

zUnionStore

default reactor.core.publisher.Mono<Long> zUnionStore(ByteBuffer destinationKey,
                                                      List<ByteBuffer> sets,
                                                      RedisZSetCommands.Weights weights,
                                                      @Nullable
                                                      RedisZSetCommands.Aggregate aggregateFunction)

Union sorted sets by applying aggregateFunction and store result in destination destinationKey and apply weights to individual sets.

Parameters:

destinationKey - must not be null.

sets - must not be null.

weights - can be null.

aggregateFunction - can be null.

Returns:

Since:

2.1

See Also:

Redis Documentation: ZUNIONSTORE

zUnionStore

reactor.core.publisher.Flux<ReactiveRedisConnection.NumericResponse<ReactiveZSetCommands.ZAggregateStoreCommand,Long>> zUnionStore(org.reactivestreams.Publisher<? extends ReactiveZSetCommands.ZAggregateStoreCommand> commands)

Union sorted sets by applying aggregateFunction and store result in destination destinationKey and apply weights to individual sets.

Parameters:

commands -

Returns:

See Also:

Redis Documentation: ZUNIONSTORE

zRangeByLex

default reactor.core.publisher.Flux<ByteBuffer> zRangeByLex(ByteBuffer key,
                                                            org.springframework.data.domain.Range<String> range)

Get all elements in Range from the sorted set at key in lexicographical ordering.

Parameters:

key - must not be null.

range - must not be null.

Returns:

See Also:

Redis Documentation: ZRANGEBYLEX

zRangeByLex

default reactor.core.publisher.Flux<ByteBuffer> zRangeByLex(ByteBuffer key,
                                                            org.springframework.data.domain.Range<String> range,
                                                            RedisZSetCommands.Limit limit)

Get all elements in Range from the sorted set at key in lexicographical ordering. Result is limited via RedisZSetCommands.Limit.

Parameters:

key - must not be null.

range - must not be null.

limit - can be null.

Returns:

See Also:

Redis Documentation: ZRANGEBYLEX

zRevRangeByLex

default reactor.core.publisher.Flux<ByteBuffer> zRevRangeByLex(ByteBuffer key,
                                                               org.springframework.data.domain.Range<String> range)

Get all elements in Range from the sorted set at key in lexicographical ordering.

Parameters:

key - must not be null.

range - must not be null.

Returns:

See Also:

Redis Documentation: ZREVRANGEBYLEX

zRevRangeByLex

default reactor.core.publisher.Flux<ByteBuffer> zRevRangeByLex(ByteBuffer key,
                                                               org.springframework.data.domain.Range<String> range,
                                                               RedisZSetCommands.Limit limit)

Get all elements in Range from the sorted set at key in lexicographical ordering. Result is limited via RedisZSetCommands.Limit.

Parameters:

key - must not be null.

range - must not be null.

limit - must not be null.

Returns:

See Also:

Redis Documentation: ZREVRANGEBYLEX

zRangeByLex

reactor.core.publisher.Flux<ReactiveRedisConnection.CommandResponse<ReactiveZSetCommands.ZRangeByLexCommand,reactor.core.publisher.Flux<ByteBuffer>>> zRangeByLex(org.reactivestreams.Publisher<ReactiveZSetCommands.ZRangeByLexCommand> commands)

Get all elements in Range from the sorted set at key in lexicographical ordering. Result is limited via RedisZSetCommands.Limit and sorted by ReactiveZSetCommands.ZRangeByLexCommand.getDirection().

Parameters:

commands - must not be null.

Returns:

See Also:

Redis Documentation: ZRANGEBYLEX, Redis Documentation: ZREVRANGEBYLEX