Uses of Class
io.lettuce.core.Range

Packages that use Range

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.
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 from lower and upper boundary values.
static <T> Range<T>	Range.from(Range.Boundary<T> lower, Range.Boundary<T> upper)	Create a new range from lower and upper boundaries.
Range<T>	Range.gt(T lower)	Greater than lower.
Range<T>	Range.gte(T lower)	Greater than or equals lower.
Range<T>	Range.lt(T upper)	Less than lower.
Range<T>	Range.lte(T upper)	Less than or equals lower.
static <T> Range<T>	Range.unbounded()

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

Modifier and Type	Method	Description
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 new XPendingArgs .
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.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.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 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)	Read 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)	Read messages from a stream within a specific Range in reverse order.
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<Long>	RedisSortedSetAsyncCommands.zcount(K key, Range<? extends Number> range)	Count the members in a sorted set with scores within the given Range.
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.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<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.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 {@code srcKey with scores ordered from high to low and stores the result in the {@code dstKey} destination key. @param dstKey the src key. @param srcKey the dst key. @param range the score range. @return The number of elements in the resulting sorted set. @since 6.1

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 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)	Read 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)	Read messages from a stream within a specific Range in reverse order.
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.
Mono<Long>	RedisSortedSetReactiveCommands.zcount(K key, Range<? extends Number> range)	Count the members in a sorted set with scores within the given Range.
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 the Publisher returned by RedisSortedSetReactiveCommands.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 the Publisher returned by RedisSortedSetReactiveCommands.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 the Publisher returned by RedisSortedSetReactiveCommands.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 the Publisher returned by RedisSortedSetReactiveCommands.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.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.
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 the Publisher returned by RedisSortedSetReactiveCommands.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 the Publisher returned by RedisSortedSetReactiveCommands.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 the Publisher returned by RedisSortedSetReactiveCommands.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 the Publisher returned by RedisSortedSetReactiveCommands.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.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 {@code srcKey with scores ordered from high to low and stores the result in the {@code dstKey} destination key. @param dstKey the src key. @param srcKey the dst key. @param range the score range. @return The number of elements in the resulting sorted set. @since 6.1

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 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)	Read 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)	Read messages from a stream within a specific Range in reverse order.
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.
Long	RedisSortedSetCommands.zcount(K key, Range<? extends Number> range)	Count the members in a sorted set with scores within the given Range.
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.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.
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.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 {@code srcKey with scores ordered from high to low and stores the result in the {@code dstKey} destination key. @param dstKey the src key. @param srcKey the dst key. @param range the score range. @return The number of elements in the resulting sorted set. @since 6.1

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
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)	Read 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)	Read messages from a stream within a specific Range in reverse order.
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<Long>	NodeSelectionSortedSetAsyncCommands.zcount(K key, Range<? extends Number> range)	Count the members in a sorted set with scores within the given Range.
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.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<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.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 {@code srcKey with scores ordered from high to low and stores the result in the {@code dstKey} destination key. @param dstKey the src key. @param srcKey the dst key. @param range the score range. @return The number of elements in the resulting sorted set. @since 6.1

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
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)	Read 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)	Read messages from a stream within a specific Range in reverse order.
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<Long>	NodeSelectionSortedSetCommands.zcount(K key, Range<? extends Number> range)	Count the members in a sorted set with scores within the given Range.
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.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<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.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 {@code srcKey with scores ordered from high to low and stores the result in the {@code dstKey} destination key. @param dstKey the src key. @param srcKey the dst key. @param range the score range. @return The number of elements in the resulting sorted set. @since 6.1

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)