Uses of Class
io.lettuce.core.Limit

Packages that use Limit

Package	Description
io.lettuce.core	The Redis client package containing RedisClient for Redis Standalone and Redis Sentinel operations.
io.lettuce.core.api.async	Standalone Redis API for asynchronous executed commands.
io.lettuce.core.api.reactive	Standalone Redis API for reactive command execution.
io.lettuce.core.api.sync	Standalone Redis API for synchronous executed commands.
io.lettuce.core.cluster.api.async	Redis Cluster API for asynchronous executed commands.
io.lettuce.core.cluster.api.sync	Redis Cluster API for synchronous executed commands.

Uses of Limit in io.lettuce.core

Methods in io.lettuce.core that return Limit

Modifier and Type	Method and Description
static Limit	Limit.create(long offset, long count) Creates a Limit given offset and count.
static Limit	Limit.from(long count) Creates a Limit given count.
static Limit	Limit.unlimited()

Methods in io.lettuce.core with parameters of type Limit

Modifier and Type	Method and Description
SortArgs	SortArgs.limit(Limit limit) Limit the number of returned elements.
XPendingArgs<K>	XPendingArgs.limit(Limit limit)
static <K> XPendingArgs<K>	XPendingArgs.Builder.xpending(Consumer<K> consumer, Range<String> range, Limit limit) Create a new XPendingArgs .
RedisFuture<List<PendingMessage>>	AbstractRedisAsyncCommands.xpending(K key, Consumer<K> consumer, Range<String> range, Limit limit)
Flux<PendingMessage>	AbstractRedisReactiveCommands.xpending(K key, Consumer<K> consumer, Range<String> range, Limit limit)
RedisFuture<List<PendingMessage>>	AbstractRedisAsyncCommands.xpending(K key, K group, Range<String> range, Limit limit)
Flux<PendingMessage>	AbstractRedisReactiveCommands.xpending(K key, K group, Range<String> range, Limit limit)
static <K> XPendingArgs<K>	XPendingArgs.Builder.xpending(K group, Range<String> range, Limit limit) Create a new XPendingArgs .
RedisFuture<List<StreamMessage<K,V>>>	AbstractRedisAsyncCommands.xrange(K key, Range<String> range, Limit limit)
Flux<StreamMessage<K,V>>	AbstractRedisReactiveCommands.xrange(K key, Range<String> range, Limit limit)
RedisFuture<List<StreamMessage<K,V>>>	AbstractRedisAsyncCommands.xrevrange(K key, Range<String> range, Limit limit)
Flux<StreamMessage<K,V>>	AbstractRedisReactiveCommands.xrevrange(K key, Range<String> range, Limit limit)
RedisFuture<List<V>>	AbstractRedisAsyncCommands.zrangebylex(K key, Range<? extends V> range, Limit limit)
Flux<V>	AbstractRedisReactiveCommands.zrangebylex(K key, Range<? extends V> range, Limit limit)
RedisFuture<List<V>>	AbstractRedisAsyncCommands.zrangebyscore(K key, Range<? extends Number> range, Limit limit)
Flux<V>	AbstractRedisReactiveCommands.zrangebyscore(K key, Range<? extends Number> range, Limit limit)
RedisFuture<Long>	AbstractRedisAsyncCommands.zrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)
Mono<Long>	AbstractRedisReactiveCommands.zrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)
RedisFuture<List<ScoredValue<V>>>	AbstractRedisAsyncCommands.zrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit)
Flux<ScoredValue<V>>	AbstractRedisReactiveCommands.zrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit)
RedisFuture<Long>	AbstractRedisAsyncCommands.zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)
Mono<Long>	AbstractRedisReactiveCommands.zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)
RedisFuture<Long>	AbstractRedisAsyncCommands.zrangestorebylex(K dstKey, K srcKey, Range<? extends V> range, Limit limit)
Mono<Long>	AbstractRedisReactiveCommands.zrangestorebylex(K dstKey, K srcKey, Range<? extends V> range, Limit limit)
RedisFuture<Long>	AbstractRedisAsyncCommands.zrangestorebyscore(K dstKey, K srcKey, Range<? extends Number> range, Limit limit)
Mono<Long>	AbstractRedisReactiveCommands.zrangestorebyscore(K dstKey, K srcKey, Range<? extends Number> range, Limit limit)
RedisFuture<List<V>>	AbstractRedisAsyncCommands.zrevrangebylex(K key, Range<? extends V> range, Limit limit)
Flux<V>	AbstractRedisReactiveCommands.zrevrangebylex(K key, Range<? extends V> range, Limit limit)
RedisFuture<List<V>>	AbstractRedisAsyncCommands.zrevrangebyscore(K key, Range<? extends Number> range, Limit limit)
Flux<V>	AbstractRedisReactiveCommands.zrevrangebyscore(K key, Range<? extends Number> range, Limit limit)
RedisFuture<Long>	AbstractRedisAsyncCommands.zrevrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)
Mono<Long>	AbstractRedisReactiveCommands.zrevrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)
RedisFuture<List<ScoredValue<V>>>	AbstractRedisAsyncCommands.zrevrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit)
Flux<ScoredValue<V>>	AbstractRedisReactiveCommands.zrevrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit)
RedisFuture<Long>	AbstractRedisAsyncCommands.zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)
Mono<Long>	AbstractRedisReactiveCommands.zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)
RedisFuture<Long>	AbstractRedisAsyncCommands.zrevrangestorebylex(K dstKey, K srcKey, Range<? extends V> range, Limit limit)
Mono<Long>	AbstractRedisReactiveCommands.zrevrangestorebylex(K dstKey, K srcKey, Range<? extends V> range, Limit limit)
RedisFuture<Long>	AbstractRedisAsyncCommands.zrevrangestorebyscore(K dstKey, K srcKey, Range<? extends Number> range, Limit limit)
Mono<Long>	AbstractRedisReactiveCommands.zrevrangestorebyscore(K dstKey, K srcKey, Range<? extends Number> range, Limit limit)

Uses of Limit in io.lettuce.core.api.async

Methods in io.lettuce.core.api.async with parameters of type Limit

Modifier and Type	Method and Description
RedisFuture<List<PendingMessage>>	RedisStreamAsyncCommands.xpending(K key, Consumer<K> consumer, Range<String> range, Limit limit) Read pending messages from a stream within a specific Range.
RedisFuture<List<PendingMessage>>	RedisStreamAsyncCommands.xpending(K key, K group, Range<String> range, Limit limit) Read pending messages from a stream within a specific Range.
RedisFuture<List<StreamMessage<K,V>>>	RedisStreamAsyncCommands.xrange(K key, Range<String> range, Limit limit) Read messages from a stream within a specific Range applying a Limit.
RedisFuture<List<StreamMessage<K,V>>>	RedisStreamAsyncCommands.xrevrange(K key, Range<String> range, Limit limit) Read messages from a stream within a specific Range applying a Limit in reverse order.
RedisFuture<List<V>>	RedisSortedSetAsyncCommands.zrangebylex(K key, Range<? extends V> range, Limit limit) Return a range of members in a sorted set, by lexicographical range.
RedisFuture<List<V>>	RedisSortedSetAsyncCommands.zrangebyscore(K key, Range<? extends Number> range, Limit limit) Return a range of members in a sorted set, by score.
RedisFuture<Long>	RedisSortedSetAsyncCommands.zrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit) Stream over a range of members in a sorted set, by score.
RedisFuture<List<ScoredValue<V>>>	RedisSortedSetAsyncCommands.zrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit) Return a range of members with score in a sorted set, by score.
RedisFuture<Long>	RedisSortedSetAsyncCommands.zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit) Stream over a range of members with scores in a sorted set, by score.
RedisFuture<Long>	RedisSortedSetAsyncCommands.zrangestorebylex(K dstKey, K srcKey, Range<? extends V> range, Limit limit) Get the specified range of elements in the sorted set stored at srcKey and stores the result in the dstKey destination key.
RedisFuture<Long>	RedisSortedSetAsyncCommands.zrangestorebyscore(K dstKey, K srcKey, Range<? extends Number> range, Limit limit) Get the specified range of elements in the sorted set stored at srcKey and stores the result in the dstKey destination key.
RedisFuture<List<V>>	RedisSortedSetAsyncCommands.zrevrangebylex(K key, Range<? extends V> range, Limit limit) Return a range of members in a sorted set, by lexicographical range ordered from high to low.
RedisFuture<List<V>>	RedisSortedSetAsyncCommands.zrevrangebyscore(K key, Range<? extends Number> range, Limit limit) Return a range of members in a sorted set, by score, with scores ordered from high to low.
RedisFuture<Long>	RedisSortedSetAsyncCommands.zrevrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit) Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
RedisFuture<List<ScoredValue<V>>>	RedisSortedSetAsyncCommands.zrevrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit) Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
RedisFuture<Long>	RedisSortedSetAsyncCommands.zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit) Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
RedisFuture<Long>	RedisSortedSetAsyncCommands.zrevrangestorebylex(K dstKey, K srcKey, Range<? extends V> range, Limit limit) Get the lexicographical range ordered from high to low of elements in the sorted set stored at srcKey and stores the result in the dstKey destination key.
RedisFuture<Long>	RedisSortedSetAsyncCommands.zrevrangestorebyscore(K dstKey, K srcKey, Range<? extends Number> range, Limit limit) Get the specified range of elements in the sorted set stored at srcKey with scores ordered from high to low and stores the result in the {@code dstKey} destination key.

Uses of Limit in io.lettuce.core.api.reactive

Methods in io.lettuce.core.api.reactive with parameters of type Limit

Modifier and Type	Method and Description
Flux<PendingMessage>	RedisStreamReactiveCommands.xpending(K key, Consumer<K> consumer, Range<String> range, Limit limit) Read pending messages from a stream within a specific Range.
Flux<PendingMessage>	RedisStreamReactiveCommands.xpending(K key, K group, Range<String> range, Limit limit) Read pending messages from a stream within a specific Range.
Flux<StreamMessage<K,V>>	RedisStreamReactiveCommands.xrange(K key, Range<String> range, Limit limit) Read messages from a stream within a specific Range applying a Limit.
Flux<StreamMessage<K,V>>	RedisStreamReactiveCommands.xrevrange(K key, Range<String> range, Limit limit) Read messages from a stream within a specific Range applying a Limit in reverse order.
Flux<V>	RedisSortedSetReactiveCommands.zrangebylex(K key, Range<? extends V> range, Limit limit) Return a range of members in a sorted set, by lexicographical range.
Flux<V>	RedisSortedSetReactiveCommands.zrangebyscore(K key, Range<? extends Number> range, Limit limit) Return a range of members in a sorted set, by score.
Mono<Long>	RedisSortedSetReactiveCommands.zrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit) Deprecated. since 6.0 in favor of consuming large results through the Publisher returned by RedisSortedSetReactiveCommands.zrangebyscore(K, double, double).
Flux<ScoredValue<V>>	RedisSortedSetReactiveCommands.zrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit) Return a range of members with score in a sorted set, by score.
Mono<Long>	RedisSortedSetReactiveCommands.zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit) Deprecated. since 6.0 in favor of consuming large results through the Publisher returned by RedisSortedSetReactiveCommands.zrangebyscoreWithScores(K, double, double).
Mono<Long>	RedisSortedSetReactiveCommands.zrangestorebylex(K dstKey, K srcKey, Range<? extends V> range, Limit limit) Get the specified range of elements in the sorted set stored at srcKey and stores the result in the dstKey destination key.
Mono<Long>	RedisSortedSetReactiveCommands.zrangestorebyscore(K dstKey, K srcKey, Range<? extends Number> range, Limit limit) Get the specified range of elements in the sorted set stored at srcKey and stores the result in the dstKey destination key.
Flux<V>	RedisSortedSetReactiveCommands.zrevrangebylex(K key, Range<? extends V> range, Limit limit) Return a range of members in a sorted set, by lexicographical range ordered from high to low.
Flux<V>	RedisSortedSetReactiveCommands.zrevrangebyscore(K key, Range<? extends Number> range, Limit limit) Return a range of members in a sorted set, by score, with scores ordered from high to low.
Mono<Long>	RedisSortedSetReactiveCommands.zrevrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit) Deprecated. since 6.0 in favor of consuming large results through the Publisher returned by RedisSortedSetReactiveCommands.zrevrangebyscore(K, double, double).
Flux<ScoredValue<V>>	RedisSortedSetReactiveCommands.zrevrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit) Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
Mono<Long>	RedisSortedSetReactiveCommands.zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit) Deprecated. since 6.0 in favor of consuming large results through the Publisher returned by RedisSortedSetReactiveCommands.zrevrangebyscoreWithScores(K, double, double).
Mono<Long>	RedisSortedSetReactiveCommands.zrevrangestorebylex(K dstKey, K srcKey, Range<? extends V> range, Limit limit) Get the lexicographical range ordered from high to low of elements in the sorted set stored at srcKey and stores the result in the dstKey destination key.
Mono<Long>	RedisSortedSetReactiveCommands.zrevrangestorebyscore(K dstKey, K srcKey, Range<? extends Number> range, Limit limit) Get the specified range of elements in the sorted set stored at srcKey with scores ordered from high to low and stores the result in the {@code dstKey} destination key.

Uses of Limit in io.lettuce.core.api.sync

Methods in io.lettuce.core.api.sync with parameters of type Limit

Modifier and Type	Method and Description
List<PendingMessage>	RedisStreamCommands.xpending(K key, Consumer<K> consumer, Range<String> range, Limit limit) Read pending messages from a stream within a specific Range.
List<PendingMessage>	RedisStreamCommands.xpending(K key, K group, Range<String> range, Limit limit) Read pending messages from a stream within a specific Range.
List<StreamMessage<K,V>>	RedisStreamCommands.xrange(K key, Range<String> range, Limit limit) Read messages from a stream within a specific Range applying a Limit.
List<StreamMessage<K,V>>	RedisStreamCommands.xrevrange(K key, Range<String> range, Limit limit) Read messages from a stream within a specific Range applying a Limit in reverse order.
List<V>	RedisSortedSetCommands.zrangebylex(K key, Range<? extends V> range, Limit limit) Return a range of members in a sorted set, by lexicographical range.
List<V>	RedisSortedSetCommands.zrangebyscore(K key, Range<? extends Number> range, Limit limit) Return a range of members in a sorted set, by score.
Long	RedisSortedSetCommands.zrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit) Stream over a range of members in a sorted set, by score.
List<ScoredValue<V>>	RedisSortedSetCommands.zrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit) Return a range of members with score in a sorted set, by score.
Long	RedisSortedSetCommands.zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit) Stream over a range of members with scores in a sorted set, by score.
Long	RedisSortedSetCommands.zrangestorebylex(K dstKey, K srcKey, Range<? extends V> range, Limit limit) Get the specified range of elements in the sorted set stored at srcKey and stores the result in the dstKey destination key.
Long	RedisSortedSetCommands.zrangestorebyscore(K dstKey, K srcKey, Range<? extends Number> range, Limit limit) Get the specified range of elements in the sorted set stored at srcKey and stores the result in the dstKey destination key.
List<V>	RedisSortedSetCommands.zrevrangebylex(K key, Range<? extends V> range, Limit limit) Return a range of members in a sorted set, by lexicographical range ordered from high to low.
List<V>	RedisSortedSetCommands.zrevrangebyscore(K key, Range<? extends Number> range, Limit limit) Return a range of members in a sorted set, by score, with scores ordered from high to low.
Long	RedisSortedSetCommands.zrevrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit) Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
List<ScoredValue<V>>	RedisSortedSetCommands.zrevrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit) Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
Long	RedisSortedSetCommands.zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit) Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
Long	RedisSortedSetCommands.zrevrangestorebylex(K dstKey, K srcKey, Range<? extends V> range, Limit limit) Get the lexicographical range ordered from high to low of elements in the sorted set stored at srcKey and stores the result in the dstKey destination key.
Long	RedisSortedSetCommands.zrevrangestorebyscore(K dstKey, K srcKey, Range<? extends Number> range, Limit limit) Get the specified range of elements in the sorted set stored at srcKey with scores ordered from high to low and stores the result in the {@code dstKey} destination key.

Uses of Limit in io.lettuce.core.cluster.api.async

Methods in io.lettuce.core.cluster.api.async with parameters of type Limit

Modifier and Type	Method and Description
AsyncExecutions<List<PendingMessage>>	NodeSelectionStreamAsyncCommands.xpending(K key, Consumer<K> consumer, Range<String> range, Limit limit) Read pending messages from a stream within a specific Range.
AsyncExecutions<List<PendingMessage>>	NodeSelectionStreamAsyncCommands.xpending(K key, K group, Range<String> range, Limit limit) Read pending messages from a stream within a specific Range.
AsyncExecutions<List<StreamMessage<K,V>>>	NodeSelectionStreamAsyncCommands.xrange(K key, Range<String> range, Limit limit) Read messages from a stream within a specific Range applying a Limit.
AsyncExecutions<List<StreamMessage<K,V>>>	NodeSelectionStreamAsyncCommands.xrevrange(K key, Range<String> range, Limit limit) Read messages from a stream within a specific Range applying a Limit in reverse order.
AsyncExecutions<List<V>>	NodeSelectionSortedSetAsyncCommands.zrangebylex(K key, Range<? extends V> range, Limit limit) Return a range of members in a sorted set, by lexicographical range.
AsyncExecutions<List<V>>	NodeSelectionSortedSetAsyncCommands.zrangebyscore(K key, Range<? extends Number> range, Limit limit) Return a range of members in a sorted set, by score.
AsyncExecutions<Long>	NodeSelectionSortedSetAsyncCommands.zrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit) Stream over a range of members in a sorted set, by score.
AsyncExecutions<List<ScoredValue<V>>>	NodeSelectionSortedSetAsyncCommands.zrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit) Return a range of members with score in a sorted set, by score.
AsyncExecutions<Long>	NodeSelectionSortedSetAsyncCommands.zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit) Stream over a range of members with scores in a sorted set, by score.
AsyncExecutions<Long>	NodeSelectionSortedSetAsyncCommands.zrangestorebylex(K dstKey, K srcKey, Range<? extends V> range, Limit limit) Get the specified range of elements in the sorted set stored at srcKey and stores the result in the dstKey destination key.
AsyncExecutions<Long>	NodeSelectionSortedSetAsyncCommands.zrangestorebyscore(K dstKey, K srcKey, Range<? extends Number> range, Limit limit) Get the specified range of elements in the sorted set stored at srcKey and stores the result in the dstKey destination key.
AsyncExecutions<List<V>>	NodeSelectionSortedSetAsyncCommands.zrevrangebylex(K key, Range<? extends V> range, Limit limit) Return a range of members in a sorted set, by lexicographical range ordered from high to low.
AsyncExecutions<List<V>>	NodeSelectionSortedSetAsyncCommands.zrevrangebyscore(K key, Range<? extends Number> range, Limit limit) Return a range of members in a sorted set, by score, with scores ordered from high to low.
AsyncExecutions<Long>	NodeSelectionSortedSetAsyncCommands.zrevrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit) Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
AsyncExecutions<List<ScoredValue<V>>>	NodeSelectionSortedSetAsyncCommands.zrevrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit) Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
AsyncExecutions<Long>	NodeSelectionSortedSetAsyncCommands.zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit) Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
AsyncExecutions<Long>	NodeSelectionSortedSetAsyncCommands.zrevrangestorebylex(K dstKey, K srcKey, Range<? extends V> range, Limit limit) Get the lexicographical range ordered from high to low of elements in the sorted set stored at srcKey and stores the result in the dstKey destination key.
AsyncExecutions<Long>	NodeSelectionSortedSetAsyncCommands.zrevrangestorebyscore(K dstKey, K srcKey, Range<? extends Number> range, Limit limit) Get the specified range of elements in the sorted set stored at srcKey with scores ordered from high to low and stores the result in the {@code dstKey} destination key.

Uses of Limit in io.lettuce.core.cluster.api.sync

Methods in io.lettuce.core.cluster.api.sync with parameters of type Limit

Modifier and Type	Method and Description
Executions<List<PendingMessage>>	NodeSelectionStreamCommands.xpending(K key, Consumer<K> consumer, Range<String> range, Limit limit) Read pending messages from a stream within a specific Range.
Executions<List<PendingMessage>>	NodeSelectionStreamCommands.xpending(K key, K group, Range<String> range, Limit limit) Read pending messages from a stream within a specific Range.
Executions<List<StreamMessage<K,V>>>	NodeSelectionStreamCommands.xrange(K key, Range<String> range, Limit limit) Read messages from a stream within a specific Range applying a Limit.
Executions<List<StreamMessage<K,V>>>	NodeSelectionStreamCommands.xrevrange(K key, Range<String> range, Limit limit) Read messages from a stream within a specific Range applying a Limit in reverse order.
Executions<List<V>>	NodeSelectionSortedSetCommands.zrangebylex(K key, Range<? extends V> range, Limit limit) Return a range of members in a sorted set, by lexicographical range.
Executions<List<V>>	NodeSelectionSortedSetCommands.zrangebyscore(K key, Range<? extends Number> range, Limit limit) Return a range of members in a sorted set, by score.
Executions<Long>	NodeSelectionSortedSetCommands.zrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit) Stream over a range of members in a sorted set, by score.
Executions<List<ScoredValue<V>>>	NodeSelectionSortedSetCommands.zrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit) Return a range of members with score in a sorted set, by score.
Executions<Long>	NodeSelectionSortedSetCommands.zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit) Stream over a range of members with scores in a sorted set, by score.
Executions<Long>	NodeSelectionSortedSetCommands.zrangestorebylex(K dstKey, K srcKey, Range<? extends V> range, Limit limit) Get the specified range of elements in the sorted set stored at srcKey and stores the result in the dstKey destination key.
Executions<Long>	NodeSelectionSortedSetCommands.zrangestorebyscore(K dstKey, K srcKey, Range<? extends Number> range, Limit limit) Get the specified range of elements in the sorted set stored at srcKey and stores the result in the dstKey destination key.
Executions<List<V>>	NodeSelectionSortedSetCommands.zrevrangebylex(K key, Range<? extends V> range, Limit limit) Return a range of members in a sorted set, by lexicographical range ordered from high to low.
Executions<List<V>>	NodeSelectionSortedSetCommands.zrevrangebyscore(K key, Range<? extends Number> range, Limit limit) Return a range of members in a sorted set, by score, with scores ordered from high to low.
Executions<Long>	NodeSelectionSortedSetCommands.zrevrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit) Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
Executions<List<ScoredValue<V>>>	NodeSelectionSortedSetCommands.zrevrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit) Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
Executions<Long>	NodeSelectionSortedSetCommands.zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit) Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
Executions<Long>	NodeSelectionSortedSetCommands.zrevrangestorebylex(K dstKey, K srcKey, Range<? extends V> range, Limit limit) Get the lexicographical range ordered from high to low of elements in the sorted set stored at srcKey and stores the result in the dstKey destination key.
Executions<Long>	NodeSelectionSortedSetCommands.zrevrangestorebyscore(K dstKey, K srcKey, Range<? extends Number> range, Limit limit) Get the specified range of elements in the sorted set stored at srcKey with scores ordered from high to low and stores the result in the {@code dstKey} destination key.