org.springframework.data.redis.connection

Interface RedisZSetCommands

All Known Subinterfaces:

DefaultedRedisClusterConnection, DefaultedRedisConnection, RedisClusterConnection, RedisCommands, RedisConnection, RedisConnectionUtils.RedisConnectionProxy, StringRedisConnection

All Known Implementing Classes:

AbstractRedisConnection, DefaultStringRedisConnection, JedisClusterConnection, JedisConnection, LettuceClusterConnection, LettuceConnection

public interface RedisZSetCommands

ZSet(SortedSet)-specific commands supported by Redis.

Author:

Costin Leau, Christoph Strobl, Thomas Darimont, David Liu, Mark Paluch, Andrey Shlykov

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	RedisZSetCommands.Aggregate Sort aggregation operations.
static class	RedisZSetCommands.Limit
static class	RedisZSetCommands.Range RedisZSetCommands.Range defines min and max values to retrieve from a ZSET.
static interface	RedisZSetCommands.Tuple ZSet tuple.
static class	RedisZSetCommands.Weights Value object encapsulating a multiplication factor for each input sorted set.

Method Summary

Modifier and Type	Method and Description
Boolean	zAdd(byte[] key, double score, byte[] value) Add value to a sorted set at key, or update its score if it already exists.
Long	zAdd(byte[] key, Set<RedisZSetCommands.Tuple> tuples) Add tuples to a sorted set at key, or update its score if it already exists.
Long	zCard(byte[] key) Get the size of sorted set with key.
default Long	zCount(byte[] key, double min, double max) Count number of elements within sorted set with scores between min and max.
Long	zCount(byte[] key, RedisZSetCommands.Range range) Count number of elements within sorted set with scores between Range#min and Range#max.
Double	zIncrBy(byte[] key, double increment, byte[] value) Increment the score of element with value in sorted set by increment.
Long	zInterStore(byte[] destKey, byte[]... sets) Intersect sorted sets and store result in destination key.
default Long	zInterStore(byte[] destKey, RedisZSetCommands.Aggregate aggregate, int[] weights, byte[]... sets) Intersect sorted sets and store result in destination key.
Long	zInterStore(byte[] destKey, RedisZSetCommands.Aggregate aggregate, RedisZSetCommands.Weights weights, byte[]... sets) Intersect sorted sets and store result in destination key.
Long	zLexCount(byte[] key, RedisZSetCommands.Range range) Count number of elements within sorted set with value between Range#min and Range#max applying lexicographical ordering.
Set<byte[]>	zRange(byte[] key, long start, long end) Get elements between start and end from sorted set.
default Set<byte[]>	zRangeByLex(byte[] key) Get all the elements in the sorted set at key in lexicographical ordering.
default Set<byte[]>	zRangeByLex(byte[] key, RedisZSetCommands.Range range) Get all the elements in RedisZSetCommands.Range from the sorted set at key in lexicographical ordering.
Set<byte[]>	zRangeByLex(byte[] key, RedisZSetCommands.Range range, RedisZSetCommands.Limit limit) Get all the elements in RedisZSetCommands.Range from the sorted set at key in lexicographical ordering.
default Set<byte[]>	zRangeByScore(byte[] key, double min, double max) Get elements where score is between min and max from sorted set.
default Set<byte[]>	zRangeByScore(byte[] key, double min, double max, long offset, long count) Get elements in range from start to end where score is between min and max from sorted set.
default Set<byte[]>	zRangeByScore(byte[] key, RedisZSetCommands.Range range) Get elements where score is between Range#min and Range#max from sorted set.
Set<byte[]>	zRangeByScore(byte[] key, RedisZSetCommands.Range range, RedisZSetCommands.Limit limit) Get elements in range from Limit#count to Limit#offset where score is between Range#min and Range#max from sorted set.
default Set<byte[]>	zRangeByScore(byte[] key, String min, String max) Get elements where score is between min and max from sorted set.
Set<byte[]>	zRangeByScore(byte[] key, String min, String max, long offset, long count) Get elements in range from start to end where score is between min and max from sorted set.
default Set<RedisZSetCommands.Tuple>	zRangeByScoreWithScores(byte[] key, double min, double max) Get set of RedisZSetCommands.Tuples where score is between min and max from sorted set.
default Set<RedisZSetCommands.Tuple>	zRangeByScoreWithScores(byte[] key, double min, double max, long offset, long count) Get set of RedisZSetCommands.Tuples in range from start to end where score is between min and max from sorted set.
default Set<RedisZSetCommands.Tuple>	zRangeByScoreWithScores(byte[] key, RedisZSetCommands.Range range) Get set of RedisZSetCommands.Tuples where score is between Range#min and Range#max from sorted set.
Set<RedisZSetCommands.Tuple>	zRangeByScoreWithScores(byte[] key, RedisZSetCommands.Range range, RedisZSetCommands.Limit limit) Get set of RedisZSetCommands.Tuples in range from Limit#offset to Limit#offset + Limit#count where score is between Range#min and Range#max from sorted set.
Set<RedisZSetCommands.Tuple>	zRangeWithScores(byte[] key, long start, long end) Get set of RedisZSetCommands.Tuples between start and end from sorted set.
Long	zRank(byte[] key, byte[] value) Determine the index of element with value in a sorted set.
Long	zRem(byte[] key, byte[]... values) Remove values from sorted set.
Long	zRemRange(byte[] key, long start, long end) Remove elements in range between start and end from sorted set with key.
default Long	zRemRangeByScore(byte[] key, double min, double max) Remove elements with scores between min and max from sorted set with key.
Long	zRemRangeByScore(byte[] key, RedisZSetCommands.Range range) Remove elements with scores between Range#min and Range#max from sorted set with key.
Set<byte[]>	zRevRange(byte[] key, long start, long end) Get elements in range from start to end from sorted set ordered from high to low.
default Set<byte[]>	zRevRangeByLex(byte[] key) Get all the elements in the sorted set at key in reversed lexicographical ordering.
default Set<byte[]>	zRevRangeByLex(byte[] key, RedisZSetCommands.Range range) Get all the elements in RedisZSetCommands.Range from the sorted set at key in reversed lexicographical ordering.
Set<byte[]>	zRevRangeByLex(byte[] key, RedisZSetCommands.Range range, RedisZSetCommands.Limit limit) Get all the elements in RedisZSetCommands.Range from the sorted set at key in reversed lexicographical ordering.
default Set<byte[]>	zRevRangeByScore(byte[] key, double min, double max) Get elements where score is between min and max from sorted set ordered from high to low.
default Set<byte[]>	zRevRangeByScore(byte[] key, double min, double max, long offset, long count) Get elements in range from start to end where score is between min and max from sorted set ordered high -> low.
default Set<byte[]>	zRevRangeByScore(byte[] key, RedisZSetCommands.Range range) Get elements where score is between Range#min and Range#max from sorted set ordered from high to low.
Set<byte[]>	zRevRangeByScore(byte[] key, RedisZSetCommands.Range range, RedisZSetCommands.Limit limit) Get elements in range from Limit#offset to Limit#offset + Limit#count where score is between Range#min and Range#max from sorted set ordered high -> low.
default Set<RedisZSetCommands.Tuple>	zRevRangeByScoreWithScores(byte[] key, double min, double max) Get set of RedisZSetCommands.Tuple where score is between min and max from sorted set ordered from high to low.
default Set<RedisZSetCommands.Tuple>	zRevRangeByScoreWithScores(byte[] key, double min, double max, long offset, long count) Get set of RedisZSetCommands.Tuple in range from start to end where score is between min and max from sorted set ordered high -> low.
default Set<RedisZSetCommands.Tuple>	zRevRangeByScoreWithScores(byte[] key, RedisZSetCommands.Range range) Get set of RedisZSetCommands.Tuple where score is between Range#min and Range#max from sorted set ordered from high to low.
Set<RedisZSetCommands.Tuple>	zRevRangeByScoreWithScores(byte[] key, RedisZSetCommands.Range range, RedisZSetCommands.Limit limit) Get set of RedisZSetCommands.Tuple in range from Limit#offset to Limit#count where score is between Range#min and Range#max from sorted set ordered high -> low.
Set<RedisZSetCommands.Tuple>	zRevRangeWithScores(byte[] key, long start, long end) Get set of RedisZSetCommands.Tuples in range from start to end from sorted set ordered from high to low.
Long	zRevRank(byte[] key, byte[] value) Determine the index of element with value in a sorted set when scored high to low.
Cursor<RedisZSetCommands.Tuple>	zScan(byte[] key, ScanOptions options) Use a Cursor to iterate over elements in sorted set at key.
Double	zScore(byte[] key, byte[] value) Get the score of element with value from sorted set with key key.
Long	zUnionStore(byte[] destKey, byte[]... sets) Union sorted sets and store result in destination key.
default Long	zUnionStore(byte[] destKey, RedisZSetCommands.Aggregate aggregate, int[] weights, byte[]... sets) Union sorted sets and store result in destination key.
Long	zUnionStore(byte[] destKey, RedisZSetCommands.Aggregate aggregate, RedisZSetCommands.Weights weights, byte[]... sets) Union sorted sets and store result in destination key.

Method Detail

zAdd

@Nullable
Boolean zAdd(byte[] key,
                       double score,
                       byte[] value)

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

Parameters:

key - must not be null.

score - the score.

value - the value.

Returns:

null when used in pipeline / transaction.

See Also:

Redis Documentation: ZADD

zAdd

@Nullable
Long zAdd(byte[] key,
                    Set<RedisZSetCommands.Tuple> tuples)

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

Parameters:

key - must not be null.

tuples - must not be null.

Returns:

null when used in pipeline / transaction.

See Also:

Redis Documentation: ZADD

zRem

@Nullable
Long zRem(byte[] key,
                    byte[]... values)

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

Parameters:

key - must not be null.

values - must not be null.

Returns:

null when used in pipeline / transaction.

See Also:

Redis Documentation: ZREM

zIncrBy

@Nullable
Double zIncrBy(byte[] key,
                         double increment,
                         byte[] value)

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

Parameters:

key - must not be null.

increment -

value - the value.

Returns:

null when used in pipeline / transaction.

See Also:

Redis Documentation: ZINCRBY

zRank

@Nullable
Long zRank(byte[] key,
                     byte[] value)

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

Parameters:

key - must not be null.

value - the value. Must not be null.

Returns:

null when used in pipeline / transaction.

See Also:

Redis Documentation: ZRANK

zRevRank

@Nullable
Long zRevRank(byte[] key,
                        byte[] value)

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

Parameters:

key - must not be null.

value - the value.

Returns:

null when used in pipeline / transaction.

See Also:

Redis Documentation: ZREVRANK

zRange

@Nullable
Set<byte[]> zRange(byte[] key,
                             long start,
                             long end)

Get elements between start and end from sorted set.

Parameters:

key - must not be null.

start -

end -

Returns:

empty Set when key does not exists or no members in range. null when used in pipeline / transaction.

See Also:

Redis Documentation: ZRANGE

zRangeWithScores

@Nullable
Set<RedisZSetCommands.Tuple> zRangeWithScores(byte[] key,
                                                        long start,
                                                        long end)

Get set of RedisZSetCommands.Tuples between start and end from sorted set.

Parameters:

key - must not be null.

start -

end -

Returns:

empty Set when key does not exists or no members in range. null when used in pipeline / transaction.

See Also:

Redis Documentation: ZRANGE

zRangeByScore

@Nullable
default Set<byte[]> zRangeByScore(byte[] key,
                                            double min,
                                            double max)

Get elements where score is between min and max from sorted set.

Parameters:

key - must not be null.

min -

max -

Returns:

empty Set when key does not exists or no members in range. null when used in pipeline / transaction.

See Also:

Redis Documentation: ZRANGEBYSCORE

zRangeByScoreWithScores

@Nullable
default Set<RedisZSetCommands.Tuple> zRangeByScoreWithScores(byte[] key,
                                                                       RedisZSetCommands.Range range)

Get set of RedisZSetCommands.Tuples where score is between Range#min and Range#max from sorted set.

Parameters:

key - must not be null.

range - must not be null.

Returns:

empty Set when key does not exists or no members in range. null when used in pipeline / transaction.

Since:

1.6

See Also:

Redis Documentation: ZRANGEBYSCORE

zRangeByScoreWithScores

@Nullable
default Set<RedisZSetCommands.Tuple> zRangeByScoreWithScores(byte[] key,
                                                                       double min,
                                                                       double max)

Get set of RedisZSetCommands.Tuples where score is between min and max from sorted set.

Parameters:

key - must not be null.

min -

max -

Returns:

empty Set when key does not exists or no members in range. null when used in pipeline / transaction.

See Also:

Redis Documentation: ZRANGEBYSCORE

zRangeByScore

@Nullable
default Set<byte[]> zRangeByScore(byte[] key,
                                            double min,
                                            double max,
                                            long offset,
                                            long count)

Get elements in range from start to end where score is between min and max from sorted set.

Parameters:

key - must not be null.

min -

max -

offset -

count -

Returns:

empty Set when key does not exists or no members in range. null when used in pipeline / transaction.

See Also:

Redis Documentation: ZRANGEBYSCORE

zRangeByScoreWithScores

@Nullable
default Set<RedisZSetCommands.Tuple> zRangeByScoreWithScores(byte[] key,
                                                                       double min,
                                                                       double max,
                                                                       long offset,
                                                                       long count)

Get set of RedisZSetCommands.Tuples in range from start to end where score is between min and max from sorted set.

Parameters:

key - must not be null.

min -

max -

offset -

count -

Returns:

empty Set when key does not exists or no members in range. null when used in pipeline / transaction.

See Also:

Redis Documentation: ZRANGEBYSCORE

zRangeByScoreWithScores

@Nullable
Set<RedisZSetCommands.Tuple> zRangeByScoreWithScores(byte[] key,
                                                               RedisZSetCommands.Range range,
                                                               RedisZSetCommands.Limit limit)

Get set of RedisZSetCommands.Tuples in range from Limit#offset to Limit#offset + Limit#count where score is between Range#min and Range#max from sorted set.

Parameters:

key - must not be null.

range - must not be null.

limit - must not be null.

Returns:

empty Set when key does not exists or no members in range. null when used in pipeline / transaction.

Since:

1.6

See Also:

Redis Documentation: ZRANGEBYSCORE

zRevRange

@Nullable
Set<byte[]> zRevRange(byte[] key,
                                long start,
                                long end)

Get elements in range from start to end from sorted set ordered from high to low.

Parameters:

key - must not be null.

start -

end -

Returns:

empty Set when key does not exists or no members in range. null when used in pipeline / transaction.

See Also:

Redis Documentation: ZREVRANGE

zRevRangeWithScores

@Nullable
Set<RedisZSetCommands.Tuple> zRevRangeWithScores(byte[] key,
                                                           long start,
                                                           long end)

Get set of RedisZSetCommands.Tuples in range from start to end from sorted set ordered from high to low.

Parameters:

key - must not be null.

start -

end -

Returns:

empty Set when key does not exists or no members in range. null when used in pipeline / transaction.

See Also:

Redis Documentation: ZREVRANGE

zRevRangeByScore

@Nullable
default Set<byte[]> zRevRangeByScore(byte[] key,
                                               double min,
                                               double max)

Get elements where score is between min and max from sorted set ordered from high to low.

Parameters:

key - must not be null.

min -

max -

Returns:

empty Set when key does not exists or no members in range. null when used in pipeline / transaction.

See Also:

Redis Documentation: ZREVRANGE

zRevRangeByScore

@Nullable
default Set<byte[]> zRevRangeByScore(byte[] key,
                                               RedisZSetCommands.Range range)

Get elements where score is between Range#min and Range#max from sorted set ordered from high to low.

Parameters:

key - must not be null.

range - must not be null.

Returns:

empty Set when key does not exists or no members in range. null when used in pipeline / transaction.

Since:

1.6

See Also:

Redis Documentation: ZREVRANGEBYSCORE

zRevRangeByScoreWithScores

@Nullable
default Set<RedisZSetCommands.Tuple> zRevRangeByScoreWithScores(byte[] key,
                                                                          double min,
                                                                          double max)

Get set of RedisZSetCommands.Tuple where score is between min and max from sorted set ordered from high to low.

Parameters:

key - must not be null.

min -

max -

Returns:

empty Set when key does not exists or no members in range. null when used in pipeline / transaction.

See Also:

Redis Documentation: ZREVRANGEBYSCORE

zRevRangeByScore

@Nullable
default Set<byte[]> zRevRangeByScore(byte[] key,
                                               double min,
                                               double max,
                                               long offset,
                                               long count)

Get elements in range from start to end where score is between min and max from sorted set ordered high -> low.

Parameters:

key - must not be null.

min -

max -

offset -

count -

Returns:

null when used in pipeline / transaction.

See Also:

Redis Documentation: ZREVRANGEBYSCORE

zRevRangeByScore

@Nullable
Set<byte[]> zRevRangeByScore(byte[] key,
                                       RedisZSetCommands.Range range,
                                       RedisZSetCommands.Limit limit)

Get elements in range from Limit#offset to Limit#offset + Limit#count where score is between Range#min and Range#max from sorted set ordered high -> low.

Parameters:

key - must not be null.

range - must not be null.

limit - must not be null.

Returns:

null when used in pipeline / transaction.

Since:

1.6

See Also:

Redis Documentation: ZREVRANGEBYSCORE

zRevRangeByScoreWithScores

@Nullable
default Set<RedisZSetCommands.Tuple> zRevRangeByScoreWithScores(byte[] key,
                                                                          double min,
                                                                          double max,
                                                                          long offset,
                                                                          long count)

Get set of RedisZSetCommands.Tuple in range from start to end where score is between min and max from sorted set ordered high -> low.

Parameters:

key - must not be null.

min -

max -

offset -

count -

Returns:

null when used in pipeline / transaction.

See Also:

Redis Documentation: ZREVRANGEBYSCORE

zRevRangeByScoreWithScores

@Nullable
default Set<RedisZSetCommands.Tuple> zRevRangeByScoreWithScores(byte[] key,
                                                                          RedisZSetCommands.Range range)

Get set of RedisZSetCommands.Tuple where score is between Range#min and Range#max from sorted set ordered from high to low.

Parameters:

key - must not be null.

range - must not be null.

Returns:

null when used in pipeline / transaction.

Since:

1.6

See Also:

Redis Documentation: ZREVRANGEBYSCORE

zRevRangeByScoreWithScores

@Nullable
Set<RedisZSetCommands.Tuple> zRevRangeByScoreWithScores(byte[] key,
                                                                  RedisZSetCommands.Range range,
                                                                  RedisZSetCommands.Limit limit)

Get set of RedisZSetCommands.Tuple in range from Limit#offset to Limit#count where score is between Range#min and Range#max from sorted set ordered high -> low.

Parameters:

key - must not be null.

range - must not be null.

limit - must not be null.

Returns:

null when used in pipeline / transaction.

Since:

1.6

See Also:

Redis Documentation: ZREVRANGEBYSCORE

zCount

@Nullable
default Long zCount(byte[] key,
                              double min,
                              double max)

Count number of elements within sorted set with scores between min and max.

Parameters:

key - must not be null.

min -

max -

Returns:

null when used in pipeline / transaction.

See Also:

Redis Documentation: ZCOUNT

zCount

@Nullable
Long zCount(byte[] key,
                      RedisZSetCommands.Range range)

Count number of elements within sorted set with scores between Range#min and Range#max.

Parameters:

key - must not be null.

range - must not be null.

Returns:

null when used in pipeline / transaction.

Since:

1.6

See Also:

Redis Documentation: ZCOUNT

zLexCount

@Nullable
Long zLexCount(byte[] key,
                         RedisZSetCommands.Range range)

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

Parameters:

key - must not be null.

range - must not be null.

Returns:

null when used in pipeline / transaction.

Since:

2.4

See Also:

Redis Documentation: ZLEXCOUNT

zCard

@Nullable
Long zCard(byte[] key)

Get the size of sorted set with key.

Parameters:

key - must not be null.

Returns:

null when used in pipeline / transaction.

See Also:

Redis Documentation: ZCARD

zScore

@Nullable
Double zScore(byte[] key,
                        byte[] value)

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

Parameters:

key - must not be null.

value - the value.

Returns:

null when used in pipeline / transaction.

See Also:

Redis Documentation: ZSCORE

zRemRange

@Nullable
Long zRemRange(byte[] key,
                         long start,
                         long end)

Remove elements in range between start and end from sorted set with key.

Parameters:

key - must not be null.

start -

end -

Returns:

null when used in pipeline / transaction.

See Also:

Redis Documentation: ZREMRANGEBYRANK

zRemRangeByScore

@Nullable
default Long zRemRangeByScore(byte[] key,
                                        double min,
                                        double max)

Remove elements with scores between min and max from sorted set with key.

Parameters:

key - must not be null.

min -

max -

Returns:

null when used in pipeline / transaction.

See Also:

Redis Documentation: ZREMRANGEBYSCORE

zRemRangeByScore

@Nullable
Long zRemRangeByScore(byte[] key,
                                RedisZSetCommands.Range range)

Remove elements with scores between Range#min and Range#max from sorted set with key.

Parameters:

key - must not be null.

range - must not be null.

Returns:

null when used in pipeline / transaction.

Since:

1.6

See Also:

Redis Documentation: ZREMRANGEBYSCORE

zUnionStore

@Nullable
Long zUnionStore(byte[] destKey,
                           byte[]... sets)

Union sorted sets and store result in destination key.

Parameters:

destKey - must not be null.

sets - must not be null.

Returns:

null when used in pipeline / transaction.

See Also:

Redis Documentation: ZUNIONSTORE

zUnionStore

@Nullable
default Long zUnionStore(byte[] destKey,
                                   RedisZSetCommands.Aggregate aggregate,
                                   int[] weights,
                                   byte[]... sets)

Union sorted sets and store result in destination key.

Parameters:

destKey - must not be null.

aggregate - must not be null.

weights - must not be null.

sets - must not be null.

Returns:

null when used in pipeline / transaction.

See Also:

Redis Documentation: ZUNIONSTORE

zUnionStore

@Nullable
Long zUnionStore(byte[] destKey,
                           RedisZSetCommands.Aggregate aggregate,
                           RedisZSetCommands.Weights weights,
                           byte[]... sets)

Union sorted sets and store result in destination key.

Parameters:

destKey - must not be null.

aggregate - must not be null.

weights - must not be null.

sets - must not be null.

Returns:

null when used in pipeline / transaction.

Since:

2.1

See Also:

Redis Documentation: ZUNIONSTORE

zInterStore

@Nullable
Long zInterStore(byte[] destKey,
                           byte[]... sets)

Intersect sorted sets and store result in destination key.

Parameters:

destKey - must not be null.

sets - must not be null.

Returns:

null when used in pipeline / transaction.

See Also:

Redis Documentation: ZINTERSTORE

zInterStore

@Nullable
default Long zInterStore(byte[] destKey,
                                   RedisZSetCommands.Aggregate aggregate,
                                   int[] weights,
                                   byte[]... sets)

Intersect sorted sets and store result in destination key.

Parameters:

destKey - must not be null.

aggregate - must not be null.

weights -

sets - must not be null.

Returns:

See Also:

Redis Documentation: ZINTERSTORE

zInterStore

@Nullable
Long zInterStore(byte[] destKey,
                           RedisZSetCommands.Aggregate aggregate,
                           RedisZSetCommands.Weights weights,
                           byte[]... sets)

Intersect sorted sets and store result in destination key.

Parameters:

destKey - must not be null.

aggregate - must not be null.

weights - must not be null.

sets - must not be null.

Returns:

Since:

2.1

See Also:

Redis Documentation: ZINTERSTORE

zScan

Cursor<RedisZSetCommands.Tuple> zScan(byte[] key,
                                      ScanOptions options)

Use a Cursor to iterate over elements in sorted set at key.

Parameters:

key - must not be null.

options - must not be null.

Returns:

Since:

1.4

See Also:

Redis Documentation: ZSCAN

zRangeByScore

@Nullable
default Set<byte[]> zRangeByScore(byte[] key,
                                            String min,
                                            String max)

Get elements where score is between min and max from sorted set.

Parameters:

key - must not be null.

min -

max -

Returns:

null when used in pipeline / transaction.

Since:

1.5

See Also:

Redis Documentation: ZRANGEBYSCORE

zRangeByScore

@Nullable
default Set<byte[]> zRangeByScore(byte[] key,
                                            RedisZSetCommands.Range range)

Get elements where score is between Range#min and Range#max from sorted set.

Parameters:

key - must not be null.

range - must not be null.

Returns:

null when used in pipeline / transaction.

Since:

1.6

See Also:

Redis Documentation: ZRANGEBYSCORE

zRangeByScore

@Nullable
Set<byte[]> zRangeByScore(byte[] key,
                                    String min,
                                    String max,
                                    long offset,
                                    long count)

Get elements in range from start to end where score is between min and max from sorted set.

Parameters:

key - must not be null.

min - must not be null.

max - must not be null.

offset -

count -

Returns:

null when used in pipeline / transaction.

Since:

1.5

See Also:

Redis Documentation: ZRANGEBYSCORE

zRangeByScore

@Nullable
Set<byte[]> zRangeByScore(byte[] key,
                                    RedisZSetCommands.Range range,
                                    RedisZSetCommands.Limit limit)

Get elements in range from Limit#count to Limit#offset where score is between Range#min and Range#max from sorted set.

Parameters:

key - must not be null.

range - must not be null.

limit - must not be null.

Returns:

null when used in pipeline / transaction.

Since:

1.6

See Also:

Redis Documentation: ZRANGEBYSCORE

zRangeByLex

@Nullable
default Set<byte[]> zRangeByLex(byte[] key)

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

Parameters:

key - must not be null.

Returns:

null when used in pipeline / transaction.

Since:

1.6

See Also:

Redis Documentation: ZRANGEBYLEX

zRangeByLex

@Nullable
default Set<byte[]> zRangeByLex(byte[] key,
                                          RedisZSetCommands.Range range)

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

Parameters:

key - must not be null.

range - must not be null.

Returns:

null when used in pipeline / transaction.

Since:

1.6

See Also:

Redis Documentation: ZRANGEBYLEX

zRangeByLex

@Nullable
Set<byte[]> zRangeByLex(byte[] key,
                                  RedisZSetCommands.Range range,
                                  RedisZSetCommands.Limit limit)

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

Parameters:

key - must not be null.

range - must not be null.

limit - must not be null.

Returns:

null when used in pipeline / transaction.

Since:

1.6

See Also:

Redis Documentation: ZRANGEBYLEX

zRevRangeByLex

@Nullable
default Set<byte[]> zRevRangeByLex(byte[] key)

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

Parameters:

key - must not be null.

Returns:

null when used in pipeline / transaction.

Since:

2.4

See Also:

Redis Documentation: ZREVRANGEBYLEX

zRevRangeByLex

@Nullable
default Set<byte[]> zRevRangeByLex(byte[] key,
                                             RedisZSetCommands.Range range)

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

Parameters:

key - must not be null.

range - must not be null.

Returns:

null when used in pipeline / transaction.

Since:

2.4

See Also:

Redis Documentation: ZREVRANGEBYLEX

zRevRangeByLex

@Nullable
Set<byte[]> zRevRangeByLex(byte[] key,
                                     RedisZSetCommands.Range range,
                                     RedisZSetCommands.Limit limit)

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

Parameters:

key - must not be null.

range - must not be null.

limit - must not be null.

Returns:

null when used in pipeline / transaction.

Since:

2.4

See Also:

Redis Documentation: ZREVRANGEBYLEX