Uses of Class
io.lettuce.core.Range
-
Packages that use Range 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.reactive Redis Cluster API for reactive command execution.io.lettuce.core.cluster.api.sync Redis Cluster API for synchronous executed commands.io.lettuce.core.models.stream Model and parser for the Stream-related command output such as XPENDING. -
-
Uses of Range in io.lettuce.core
Methods in io.lettuce.core that return Range Modifier and Type Method Description static <T> Range<T>
Range. create(T lower, T upper)
Create a new range fromlower
andupper
boundary values.static <T> Range<T>
Range. from(Range.Boundary<T> lower, Range.Boundary<T> upper)
Create a new range fromlower
andupper
boundaries.Range<T>
Range. gt(T lower)
Greater thanlower
.Range<T>
Range. gte(T lower)
Greater than or equalslower
.Range<T>
Range. lt(T upper)
Less thanlower
.Range<T>
Range. lte(T upper)
Less than or equalslower
.static <T> Range<T>
Range. unbounded()
Methods in io.lettuce.core with parameters of type Range Modifier and Type Method Description RedisFuture<String>
AbstractRedisAsyncCommands. clusterAddSlotsRange(Range<Integer>... ranges)
Mono<String>
AbstractRedisReactiveCommands. clusterAddSlotsRange(Range<Integer>... ranges)
RedisFuture<String>
AbstractRedisAsyncCommands. clusterDelSlotsRange(Range<Integer>... ranges)
Mono<String>
AbstractRedisReactiveCommands. clusterDelSlotsRange(Range<Integer>... ranges)
XPendingArgs<K>
XPendingArgs. range(Range<String> range)
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)
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)
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)
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)
Flux<StreamMessage<K,V>>
AbstractRedisReactiveCommands. xrevrange(K key, Range<String> range, Limit limit)
RedisFuture<Long>
AbstractRedisAsyncCommands. zcount(K key, Range<? extends Number> range)
Mono<Long>
AbstractRedisReactiveCommands. zcount(K key, Range<? extends Number> range)
RedisFuture<Long>
AbstractRedisAsyncCommands. zlexcount(K key, Range<? extends V> range)
Mono<Long>
AbstractRedisReactiveCommands. zlexcount(K key, Range<? extends V> range)
RedisFuture<List<V>>
AbstractRedisAsyncCommands. zrangebylex(K key, Range<? extends V> range)
RedisFuture<List<V>>
AbstractRedisAsyncCommands. zrangebylex(K key, Range<? extends V> range, Limit limit)
Flux<V>
AbstractRedisReactiveCommands. zrangebylex(K key, Range<? extends V> range)
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)
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)
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)
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)
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)
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)
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)
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)
Flux<ScoredValue<V>>
AbstractRedisReactiveCommands. zrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit)
RedisFuture<Long>
AbstractRedisAsyncCommands. zrangestore(K dstKey, K srcKey, Range<Long> range)
Mono<Long>
AbstractRedisReactiveCommands. zrangestore(K dstKey, K srcKey, Range<Long> range)
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<Long>
AbstractRedisAsyncCommands. zremrangebylex(K key, Range<? extends V> range)
Mono<Long>
AbstractRedisReactiveCommands. zremrangebylex(K key, Range<? extends V> range)
RedisFuture<Long>
AbstractRedisAsyncCommands. zremrangebyscore(K key, Range<? extends Number> range)
Mono<Long>
AbstractRedisReactiveCommands. zremrangebyscore(K key, Range<? extends Number> range)
RedisFuture<List<V>>
AbstractRedisAsyncCommands. zrevrangebylex(K key, Range<? extends V> range)
RedisFuture<List<V>>
AbstractRedisAsyncCommands. zrevrangebylex(K key, Range<? extends V> range, Limit limit)
Flux<V>
AbstractRedisReactiveCommands. zrevrangebylex(K key, Range<? extends V> range)
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)
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)
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)
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)
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)
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)
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)
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)
Flux<ScoredValue<V>>
AbstractRedisReactiveCommands. zrevrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit)
RedisFuture<Long>
AbstractRedisAsyncCommands. zrevrangestore(K dstKey, K srcKey, Range<Long> range)
Mono<Long>
AbstractRedisReactiveCommands. zrevrangestore(K dstKey, K srcKey, Range<Long> range)
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 Range in io.lettuce.core.api.async
Methods in io.lettuce.core.api.async with parameters of type Range 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)
Read 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)
Read messages from a stream within a specificRange
in reverse order.RedisFuture<List<StreamMessage<K,V>>>
RedisStreamAsyncCommands. xrevrange(K key, Range<String> range, Limit limit)
RedisFuture<Long>
RedisSortedSetAsyncCommands. zcount(K key, Range<? extends Number> range)
Count the members in a sorted set with scores within the givenRange
.RedisFuture<Long>
RedisSortedSetAsyncCommands. zlexcount(K key, Range<? extends V> range)
Count the number of members in a sorted set between a given lexicographical range.RedisFuture<List<V>>
RedisSortedSetAsyncCommands. zrangebylex(K key, Range<? extends V> range)
Return a range of members in a sorted set, by lexicographical range.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)
Stream over 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<V>>
RedisSortedSetAsyncCommands. zrangebyscore(K key, Range<? extends Number> range)
Return 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)
Stream over a range of members with scores 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)
Return a range of members with score 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. zrangestore(K dstKey, K srcKey, Range<Long> range)
Get the specified range of elements in the sorted set stored atsrcKey
and stores the result in thedstKey
destination key.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<Long>
RedisSortedSetAsyncCommands. zremrangebylex(K key, Range<? extends V> range)
Remove all members in a sorted set between the given lexicographical range.RedisFuture<Long>
RedisSortedSetAsyncCommands. zremrangebyscore(K key, Range<? extends Number> range)
Remove all members in a sorted set within the given scores.RedisFuture<List<V>>
RedisSortedSetAsyncCommands. zrevrangebylex(K key, Range<? extends V> range)
Return a range of members in a sorted set, by lexicographical range ordered from high to low.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)
Stream over 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<V>>
RedisSortedSetAsyncCommands. zrevrangebyscore(K key, Range<? extends Number> range)
Return 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)
Stream over 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<List<ScoredValue<V>>>
RedisSortedSetAsyncCommands. zrevrangebyscoreWithScores(K key, Range<? extends Number> range)
Return 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. zrevrangestore(K dstKey, K srcKey, Range<Long> range)
Get the specified range of elements ordered from high to low in the sorted set stored atsrcKey
and stores the result in thedstKey
destination key.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 Range in io.lettuce.core.api.reactive
Methods in io.lettuce.core.api.reactive with parameters of type Range 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)
Read 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)
Read messages from a stream within a specificRange
in reverse order.Flux<StreamMessage<K,V>>
RedisStreamReactiveCommands. xrevrange(K key, Range<String> range, Limit limit)
Mono<Long>
RedisSortedSetReactiveCommands. zcount(K key, Range<? extends Number> range)
Count the members in a sorted set with scores within the givenRange
.Mono<Long>
RedisSortedSetReactiveCommands. zlexcount(K key, Range<? extends V> range)
Count the number of members in a sorted set between a given lexicographical range.Flux<V>
RedisSortedSetReactiveCommands. zrangebylex(K key, Range<? extends V> range)
Return a range of members in a sorted set, by lexicographical range.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)
Deprecated.since 6.0 in favor of consuming large results through thePublisher
returned byRedisSortedSetReactiveCommands.zrangebyscore(K, double, double)
.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)
Return a range of members in a sorted set, by score.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)
Deprecated.since 6.0 in favor of consuming large results through thePublisher
returned byRedisSortedSetReactiveCommands.zrangebyscoreWithScores(K, double, double)
.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)
Return a range of members with score in a sorted set, by score.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. zrangestore(K dstKey, K srcKey, Range<Long> range)
Get the specified range of elements in the sorted set stored atsrcKey
and stores the result in thedstKey
destination key.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.Mono<Long>
RedisSortedSetReactiveCommands. zremrangebylex(K key, Range<? extends V> range)
Remove all members in a sorted set between the given lexicographical range.Mono<Long>
RedisSortedSetReactiveCommands. zremrangebyscore(K key, Range<? extends Number> range)
Remove all members in a sorted set within the given scores.Flux<V>
RedisSortedSetReactiveCommands. zrevrangebylex(K key, Range<? extends V> range)
Return a range of members in a sorted set, by lexicographical range ordered from high to low.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)
Deprecated.since 6.0 in favor of consuming large results through thePublisher
returned byRedisSortedSetReactiveCommands.zrevrangebyscore(K, double, double)
.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)
Return a range of members in a sorted set, by score, with scores 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. zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range)
Deprecated.since 6.0 in favor of consuming large results through thePublisher
returned byRedisSortedSetReactiveCommands.zrevrangebyscoreWithScores(K, double, double)
.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)
Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.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. zrevrangestore(K dstKey, K srcKey, Range<Long> range)
Get the specified range of elements ordered from high to low in the sorted set stored atsrcKey
and stores the result in thedstKey
destination key.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 Range in io.lettuce.core.api.sync
Methods in io.lettuce.core.api.sync with parameters of type Range 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)
Read 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)
Read messages from a stream within a specificRange
in reverse order.List<StreamMessage<K,V>>
RedisStreamCommands. xrevrange(K key, Range<String> range, Limit limit)
Long
RedisSortedSetCommands. zcount(K key, Range<? extends Number> range)
Count the members in a sorted set with scores within the givenRange
.Long
RedisSortedSetCommands. zlexcount(K key, Range<? extends V> range)
Count the number of members in a sorted set between a given lexicographical range.List<V>
RedisSortedSetCommands. zrangebylex(K key, Range<? extends V> range)
Return a range of members in a sorted set, by lexicographical range.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)
Stream over 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<V>
RedisSortedSetCommands. zrangebyscore(K key, Range<? extends Number> range)
Return 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)
Stream over a range of members with scores 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)
Return a range of members with score 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. zrangestore(K dstKey, K srcKey, Range<Long> range)
Get the specified range of elements in the sorted set stored atsrcKey
and stores the result in thedstKey
destination key.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.Long
RedisSortedSetCommands. zremrangebylex(K key, Range<? extends V> range)
Remove all members in a sorted set between the given lexicographical range.Long
RedisSortedSetCommands. zremrangebyscore(K key, Range<? extends Number> range)
Remove all members in a sorted set within the given scores.List<V>
RedisSortedSetCommands. zrevrangebylex(K key, Range<? extends V> range)
Return a range of members in a sorted set, by lexicographical range ordered from high to low.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)
Stream over 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<V>
RedisSortedSetCommands. zrevrangebyscore(K key, Range<? extends Number> range)
Return 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)
Stream over 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.List<ScoredValue<V>>
RedisSortedSetCommands. zrevrangebyscoreWithScores(K key, Range<? extends Number> range)
Return 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. zrevrangestore(K dstKey, K srcKey, Range<Long> range)
Get the specified range of elements ordered from high to low in the sorted set stored atsrcKey
and stores the result in thedstKey
destination key.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 Range in io.lettuce.core.cluster.api.async
Methods in io.lettuce.core.cluster.api.async with parameters of type Range Modifier and Type Method Description RedisFuture<String>
RedisClusterAsyncCommands. clusterAddSlotsRange(Range<Integer>... ranges)
Takes a list of slot ranges (specified by start and end slots) to assign to the node.RedisFuture<String>
RedisClusterAsyncCommands. clusterDelSlotsRange(Range<Integer>... ranges)
Takes a list of slot ranges (specified by start and end slots) to remove to the node.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)
Read 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)
Read messages from a stream within a specificRange
in reverse order.AsyncExecutions<List<StreamMessage<K,V>>>
NodeSelectionStreamAsyncCommands. xrevrange(K key, Range<String> range, Limit limit)
AsyncExecutions<Long>
NodeSelectionSortedSetAsyncCommands. zcount(K key, Range<? extends Number> range)
Count the members in a sorted set with scores within the givenRange
.AsyncExecutions<Long>
NodeSelectionSortedSetAsyncCommands. zlexcount(K key, Range<? extends V> range)
Count the number of members in a sorted set between a given lexicographical range.AsyncExecutions<List<V>>
NodeSelectionSortedSetAsyncCommands. zrangebylex(K key, Range<? extends V> range)
Return a range of members in a sorted set, by lexicographical range.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)
Stream over 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<V>>
NodeSelectionSortedSetAsyncCommands. zrangebyscore(K key, Range<? extends Number> range)
Return 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)
Stream over a range of members with scores 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)
Return a range of members with score 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. zrangestore(K dstKey, K srcKey, Range<Long> range)
Get the specified range of elements in the sorted set stored atsrcKey
and stores the result in thedstKey
destination key.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<Long>
NodeSelectionSortedSetAsyncCommands. zremrangebylex(K key, Range<? extends V> range)
Remove all members in a sorted set between the given lexicographical range.AsyncExecutions<Long>
NodeSelectionSortedSetAsyncCommands. zremrangebyscore(K key, Range<? extends Number> range)
Remove all members in a sorted set within the given scores.AsyncExecutions<List<V>>
NodeSelectionSortedSetAsyncCommands. zrevrangebylex(K key, Range<? extends V> range)
Return a range of members in a sorted set, by lexicographical range ordered from high to low.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)
Stream over 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<V>>
NodeSelectionSortedSetAsyncCommands. zrevrangebyscore(K key, Range<? extends Number> range)
Return 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)
Stream over 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<List<ScoredValue<V>>>
NodeSelectionSortedSetAsyncCommands. zrevrangebyscoreWithScores(K key, Range<? extends Number> range)
Return 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. zrevrangestore(K dstKey, K srcKey, Range<Long> range)
Get the specified range of elements ordered from high to low in the sorted set stored atsrcKey
and stores the result in thedstKey
destination key.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 Range in io.lettuce.core.cluster.api.reactive
Methods in io.lettuce.core.cluster.api.reactive with parameters of type Range Modifier and Type Method Description Mono<String>
RedisClusterReactiveCommands. clusterAddSlotsRange(Range<Integer>... ranges)
Takes a list of slot ranges (specified by start and end slots) to assign to the node.Mono<String>
RedisClusterReactiveCommands. clusterDelSlotsRange(Range<Integer>... ranges)
Takes a list of slot ranges (specified by start and end slots) to remove to the node. -
Uses of Range in io.lettuce.core.cluster.api.sync
Methods in io.lettuce.core.cluster.api.sync with parameters of type Range Modifier and Type Method Description String
RedisClusterCommands. clusterAddSlotsRange(Range<Integer>... ranges)
Takes a list of slot ranges (specified by start and end slots) to assign to the node.String
RedisClusterCommands. clusterDelSlotsRange(Range<Integer>... ranges)
Takes a list of slot ranges (specified by start and end slots) to remove to the node.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)
Read 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)
Read messages from a stream within a specificRange
in reverse order.Executions<List<StreamMessage<K,V>>>
NodeSelectionStreamCommands. xrevrange(K key, Range<String> range, Limit limit)
Executions<Long>
NodeSelectionSortedSetCommands. zcount(K key, Range<? extends Number> range)
Count the members in a sorted set with scores within the givenRange
.Executions<Long>
NodeSelectionSortedSetCommands. zlexcount(K key, Range<? extends V> range)
Count the number of members in a sorted set between a given lexicographical range.Executions<List<V>>
NodeSelectionSortedSetCommands. zrangebylex(K key, Range<? extends V> range)
Return a range of members in a sorted set, by lexicographical range.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)
Stream over 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<V>>
NodeSelectionSortedSetCommands. zrangebyscore(K key, Range<? extends Number> range)
Return 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)
Stream over a range of members with scores 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)
Return a range of members with score 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. zrangestore(K dstKey, K srcKey, Range<Long> range)
Get the specified range of elements in the sorted set stored atsrcKey
and stores the result in thedstKey
destination key.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<Long>
NodeSelectionSortedSetCommands. zremrangebylex(K key, Range<? extends V> range)
Remove all members in a sorted set between the given lexicographical range.Executions<Long>
NodeSelectionSortedSetCommands. zremrangebyscore(K key, Range<? extends Number> range)
Remove all members in a sorted set within the given scores.Executions<List<V>>
NodeSelectionSortedSetCommands. zrevrangebylex(K key, Range<? extends V> range)
Return a range of members in a sorted set, by lexicographical range ordered from high to low.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)
Stream over 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<V>>
NodeSelectionSortedSetCommands. zrevrangebyscore(K key, Range<? extends Number> range)
Return 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)
Stream over 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<List<ScoredValue<V>>>
NodeSelectionSortedSetCommands. zrevrangebyscoreWithScores(K key, Range<? extends Number> range)
Return 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. zrevrangestore(K dstKey, K srcKey, Range<Long> range)
Get the specified range of elements ordered from high to low in the sorted set stored atsrcKey
and stores the result in thedstKey
destination key.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. -
Uses of Range in io.lettuce.core.models.stream
Methods in io.lettuce.core.models.stream that return Range Modifier and Type Method Description Range<String>
PendingMessages. getMessageIds()
Constructors in io.lettuce.core.models.stream with parameters of type Range Constructor Description PendingMessages(long count, Range<String> messageIds, Map<String,Long> consumerMessageCount)
-