Uses of Class
io.lettuce.core.Limit
-
Packages that use Limit Package Description io.lettuce.core The Redis client package containingRedisClient
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 Description static Limit
Limit. create(long offset, long count)
static Limit
Limit. from(long count)
Creates aLimit
givencount
.static Limit
Limit. unlimited()
Methods in io.lettuce.core with parameters of type Limit Modifier and Type Method Description SortArgs
SortArgs. limit(Limit limit)
Limit the number of returned elements.XPendingArgs<K>
XPendingArgs. limit(Limit limit)
RedisFuture<List<PendingMessage>>
AbstractRedisAsyncCommands. 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, Consumer<K> consumer, 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(Consumer<K> consumer, Range<String> range, Limit limit)
Create a newXPendingArgs
.static <K> XPendingArgs<K>
XPendingArgs.Builder. xpending(K group, Range<String> range, Limit limit)
Create a newXPendingArgs
.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<Long>
AbstractRedisAsyncCommands. zrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)
RedisFuture<List<V>>
AbstractRedisAsyncCommands. zrangebyscore(K key, Range<? extends Number> range, Limit limit)
Mono<Long>
AbstractRedisReactiveCommands. zrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)
Flux<V>
AbstractRedisReactiveCommands. zrangebyscore(K key, Range<? extends Number> range, Limit limit)
RedisFuture<Long>
AbstractRedisAsyncCommands. zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)
RedisFuture<List<ScoredValue<V>>>
AbstractRedisAsyncCommands. zrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit)
Mono<Long>
AbstractRedisReactiveCommands. zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)
Flux<ScoredValue<V>>
AbstractRedisReactiveCommands. zrangebyscoreWithScores(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<Long>
AbstractRedisAsyncCommands. zrevrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)
RedisFuture<List<V>>
AbstractRedisAsyncCommands. zrevrangebyscore(K key, Range<? extends Number> range, Limit limit)
Mono<Long>
AbstractRedisReactiveCommands. zrevrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)
Flux<V>
AbstractRedisReactiveCommands. zrevrangebyscore(K key, Range<? extends Number> range, Limit limit)
RedisFuture<Long>
AbstractRedisAsyncCommands. zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)
RedisFuture<List<ScoredValue<V>>>
AbstractRedisAsyncCommands. zrevrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit)
Mono<Long>
AbstractRedisReactiveCommands. zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)
Flux<ScoredValue<V>>
AbstractRedisReactiveCommands. zrevrangebyscoreWithScores(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 Description RedisFuture<List<PendingMessage>>
RedisStreamAsyncCommands. xpending(K key, Consumer<K> consumer, Range<String> range, Limit limit)
Read pending messages from a stream within a specificRange
.RedisFuture<List<PendingMessage>>
RedisStreamAsyncCommands. xpending(K key, K group, Range<String> range, Limit limit)
Read pending messages from a stream within a specificRange
.RedisFuture<List<StreamMessage<K,V>>>
RedisStreamAsyncCommands. xrange(K key, Range<String> range, Limit limit)
RedisFuture<List<StreamMessage<K,V>>>
RedisStreamAsyncCommands. xrevrange(K key, Range<String> range, Limit limit)
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<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<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. 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<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. zrangestorebylex(K dstKey, K srcKey, Range<? extends V> range, Limit limit)
Get the specified range of elements in the sorted set stored atsrcKey
and stores the result in thedstKey
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 atsrcKey
and stores the result in thedstKey
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<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<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. 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<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. 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 atsrcKey
and stores the result in thedstKey
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 {@code 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 Description Flux<PendingMessage>
RedisStreamReactiveCommands. xpending(K key, Consumer<K> consumer, Range<String> range, Limit limit)
Read pending messages from a stream within a specificRange
.Flux<PendingMessage>
RedisStreamReactiveCommands. xpending(K key, K group, Range<String> range, Limit limit)
Read pending messages from a stream within a specificRange
.Flux<StreamMessage<K,V>>
RedisStreamReactiveCommands. xrange(K key, Range<String> range, Limit limit)
Flux<StreamMessage<K,V>>
RedisStreamReactiveCommands. xrevrange(K key, Range<String> range, Limit limit)
Flux<V>
RedisSortedSetReactiveCommands. zrangebylex(K key, Range<? extends V> range, Limit limit)
Return a range of members in a sorted set, by lexicographical range.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 thePublisher
returned byRedisSortedSetReactiveCommands.zrangebyscore(K, double, double)
.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. zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)
Deprecated.since 6.0 in favor of consuming large results through thePublisher
returned byRedisSortedSetReactiveCommands.zrangebyscoreWithScores(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. zrangestorebylex(K dstKey, K srcKey, Range<? extends V> range, Limit limit)
Get the specified range of elements in the sorted set stored atsrcKey
and stores the result in thedstKey
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 atsrcKey
and stores the result in thedstKey
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.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 thePublisher
returned byRedisSortedSetReactiveCommands.zrevrangebyscore(K, double, double)
.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. zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)
Deprecated.since 6.0 in favor of consuming large results through thePublisher
returned byRedisSortedSetReactiveCommands.zrevrangebyscoreWithScores(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. 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 atsrcKey
and stores the result in thedstKey
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 {@code 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 Description List<PendingMessage>
RedisStreamCommands. xpending(K key, Consumer<K> consumer, Range<String> range, Limit limit)
Read pending messages from a stream within a specificRange
.List<PendingMessage>
RedisStreamCommands. xpending(K key, K group, Range<String> range, Limit limit)
Read pending messages from a stream within a specificRange
.List<StreamMessage<K,V>>
RedisStreamCommands. xrange(K key, Range<String> range, Limit limit)
List<StreamMessage<K,V>>
RedisStreamCommands. xrevrange(K key, Range<String> range, Limit limit)
List<V>
RedisSortedSetCommands. zrangebylex(K key, Range<? extends V> range, Limit limit)
Return a range of members in a sorted set, by lexicographical range.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<V>
RedisSortedSetCommands. zrangebyscore(K key, Range<? extends Number> range, Limit limit)
Return a range of members 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.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. zrangestorebylex(K dstKey, K srcKey, Range<? extends V> range, Limit limit)
Get the specified range of elements in the sorted set stored atsrcKey
and stores the result in thedstKey
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 atsrcKey
and stores the result in thedstKey
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.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<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. 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.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. 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 atsrcKey
and stores the result in thedstKey
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 {@code 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 Description AsyncExecutions<List<PendingMessage>>
NodeSelectionStreamAsyncCommands. xpending(K key, Consumer<K> consumer, Range<String> range, Limit limit)
Read pending messages from a stream within a specificRange
.AsyncExecutions<List<PendingMessage>>
NodeSelectionStreamAsyncCommands. xpending(K key, K group, Range<String> range, Limit limit)
Read pending messages from a stream within a specificRange
.AsyncExecutions<List<StreamMessage<K,V>>>
NodeSelectionStreamAsyncCommands. xrange(K key, Range<String> range, Limit limit)
AsyncExecutions<List<StreamMessage<K,V>>>
NodeSelectionStreamAsyncCommands. xrevrange(K key, Range<String> range, Limit limit)
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<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<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. 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<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. zrangestorebylex(K dstKey, K srcKey, Range<? extends V> range, Limit limit)
Get the specified range of elements in the sorted set stored atsrcKey
and stores the result in thedstKey
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 atsrcKey
and stores the result in thedstKey
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<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<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. 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<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. 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 atsrcKey
and stores the result in thedstKey
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 {@code 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 Description Executions<List<PendingMessage>>
NodeSelectionStreamCommands. xpending(K key, Consumer<K> consumer, Range<String> range, Limit limit)
Read pending messages from a stream within a specificRange
.Executions<List<PendingMessage>>
NodeSelectionStreamCommands. xpending(K key, K group, Range<String> range, Limit limit)
Read pending messages from a stream within a specificRange
.Executions<List<StreamMessage<K,V>>>
NodeSelectionStreamCommands. xrange(K key, Range<String> range, Limit limit)
Executions<List<StreamMessage<K,V>>>
NodeSelectionStreamCommands. xrevrange(K key, Range<String> range, Limit limit)
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<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<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. 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<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. zrangestorebylex(K dstKey, K srcKey, Range<? extends V> range, Limit limit)
Get the specified range of elements in the sorted set stored atsrcKey
and stores the result in thedstKey
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 atsrcKey
and stores the result in thedstKey
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<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<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. 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<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. 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 atsrcKey
and stores the result in thedstKey
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 {@code srcKey with scores ordered from high to low and stores the result in the {@code dstKey} destination key.
-