org.springframework.data.redis.connection

Interface RedisZSetCommands

All Known Subinterfaces:

RedisCommands, RedisConnection, StringRedisConnection

All Known Implementing Classes:

AbstractRedisConnection, DefaultStringRedisConnection, JedisConnection, JredisConnection, LettuceConnection, SrpConnection

public interface RedisZSetCommands

ZSet(SortedSet)-specific commands supported by Redis.

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.

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.
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.
Long	zInterStore(byte[] destKey, RedisZSetCommands.Aggregate aggregate, int[] weights, byte[]... sets) Intersect sorted sets and store result in destination key.
Set<byte[]>	zRange(byte[] key, long begin, long end) Get elements between begin and end from sorted set.
Set<byte[]>	zRangeByLex(byte[] key) Get all the elements in the sorted set at key in lexicographical ordering.
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.
Set<byte[]>	zRangeByScore(byte[] key, double min, double max) Get elements where score is between min and max from sorted set.
Set<byte[]>	zRangeByScore(byte[] key, double min, double max, long offset, long count) Get elements in range from begin to end where score is between min and max from sorted set.
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.
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 begin to end where score is between min and max from sorted set.
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.
Set<RedisZSetCommands.Tuple>	zRangeByScoreWithScores(byte[] key, double min, double max, long offset, long count) Get set of RedisZSetCommands.Tuples in range from begin to end where score is between min and max from sorted set.
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 begin, long end) Get set of RedisZSetCommands.Tuples between begin 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 begin, long end) Remove elements in range between begin and end from sorted set with key.
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 begin, long end) Get elements in range from begin to end from sorted set ordered from high to low.
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.
Set<byte[]>	zRevRangeByScore(byte[] key, double min, double max, long offset, long count) Get elements in range from begin to end where score is between min and max from sorted set ordered high -> low.
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.
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.
Set<RedisZSetCommands.Tuple>	zRevRangeByScoreWithScores(byte[] key, double min, double max, long offset, long count) Get set of RedisZSetCommands.Tuple in range from begin to end where score is between min and max from sorted set ordered high -> low.
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 begin, long end) Get set of RedisZSetCommands.Tuples in range from begin 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.
Long	zUnionStore(byte[] destKey, RedisZSetCommands.Aggregate aggregate, int[] weights, byte[]... sets) Union sorted sets and store result in destination key.

Method Detail

zAdd

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

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

See http://redis.io/commands/zadd

Parameters:

key -

score -

value -

Returns:

zAdd

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

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

See http://redis.io/commands/zadd

Parameters:

key -

tuples -

Returns:

zRem

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

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

See http://redis.io/commands/zrem

Parameters:

key -

values -

Returns:

zIncrBy

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

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

See http://redis.io/commands/zincrby

Parameters:

key -

increment -

value -

Returns:

zRank

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

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

See http://redis.io/commands/zrank

Parameters:

key -

value -

Returns:

zRevRank

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

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

See http://redis.io/commands/zrevrank

Parameters:

key -

value -

Returns:

zRange

Set<byte[]> zRange(byte[] key,
                   long begin,
                   long end)

Get elements between begin and end from sorted set.

See http://redis.io/commands/zrange

Parameters:

key -

begin -

end -

Returns:

zRangeWithScores

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

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

See http://redis.io/commands/zrange

Parameters:

key -

begin -

end -

Returns:

zRangeByScore

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

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

See http://redis.io/commands/zrangebyscore

Parameters:

key -

min -

max -

Returns:

zRangeByScoreWithScores

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 -

range -

Returns:

Since:

1.6

zRangeByScoreWithScores

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.

See http://redis.io/commands/zrangebyscore

Parameters:

key -

min -

max -

Returns:

zRangeByScore

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

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

See http://redis.io/commands/zrangebyscore

Parameters:

key -

min -

max -

offset -

count -

Returns:

zRangeByScoreWithScores

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

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

See http://redis.io/commands/zrangebyscore

Parameters:

key -

min -

max -

offset -

count -

Returns:

zRangeByScoreWithScores

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 -

range -

limit -

Returns:

Since:

1.6

zRevRange

Set<byte[]> zRevRange(byte[] key,
                      long begin,
                      long end)

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

See http://redis.io/commands/zrevrange

Parameters:

key -

begin -

end -

Returns:

zRevRangeWithScores

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

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

See http://redis.io/commands/zrevrange

Parameters:

key -

begin -

end -

Returns:

zRevRangeByScore

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.

See http://redis.io/commands/zrevrange

Parameters:

key -

min -

max -

Returns:

zRevRangeByScore

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 -

range -

Returns:

Since:

1.6

zRevRangeByScoreWithScores

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.

See http://redis.io/commands/zrevrange

Parameters:

key -

min -

max -

Returns:

zRevRangeByScore

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

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

See http://redis.io/commands/zrevrangebyscore

Parameters:

key -

min -

max -

offset -

count -

Returns:

zRevRangeByScore

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 -

range -

limit -

Returns:

Since:

1.6

zRevRangeByScoreWithScores

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

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

See http://redis.io/commands/zrevrangebyscore

Parameters:

key -

min -

max -

offset -

count -

Returns:

zRevRangeByScoreWithScores

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 -

range -

Returns:

Since:

1.6

zRevRangeByScoreWithScores

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 -

range -

limit -

Returns:

Since:

1.6

zCount

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

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

See http://redis.io/commands/zcount

Parameters:

key -

min -

max -

Returns:

zCount

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

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

Parameters:

key -

min -

max -

Returns:

Since:

1.6

zCard

Long zCard(byte[] key)

Get the size of sorted set with key.

See http://redis.io/commands/zcard

Parameters:

key -

Returns:

zScore

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

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

See http://redis.io/commands/zrem

Parameters:

key -

value -

Returns:

zRemRange

Long zRemRange(byte[] key,
               long begin,
               long end)

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

See http://redis.io/commands/zremrange

Parameters:

key -

begin -

end -

Returns:

zRemRangeByScore

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

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

See http://redis.io/commands/zremrangebyscore

Parameters:

key -

min -

max -

Returns:

zRemRangeByScore

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

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

Parameters:

key -

range -

Returns:

Since:

1.6

zUnionStore

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

Union sorted sets and store result in destination key.

See http://redis.io/commands/zunionstore

Parameters:

destKey -

sets -

Returns:

zUnionStore

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

Union sorted sets and store result in destination key.

See http://redis.io/commands/zunionstore

Parameters:

destKey -

aggregate -

weights -

sets -

Returns:

zInterStore

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

Intersect sorted sets and store result in destination key.

See http://redis.io/commands/zinterstore

Parameters:

destKey -

sets -

Returns:

zInterStore

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

Intersect sorted sets and store result in destination key.

See http://redis.io/commands/zinterstore

Parameters:

destKey -

sets -

Returns:

zScan

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

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

See http://redis.io/commands/scan

Parameters:

key -

options -

Returns:

Since:

1.4

zRangeByScore

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

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

See http://redis.io/commands/zrangebyscore

Parameters:

key -

min -

max -

Returns:

Since:

1.5

zRangeByScore

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

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

Parameters:

key -

range -

Returns:

Since:

1.6

zRangeByScore

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

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

See http://redis.io/commands/zrangebyscore

Parameters:

key -

min -

max -

offset -

count -

Returns:

Since:

1.5

zRangeByScore

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 -

range -

limit -

Returns:

Since:

1.6

zRangeByLex

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:

Since:

1.6

zRangeByLex

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:

Since:

1.6

zRangeByLex

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.

range - can be null.

Returns:

Since:

1.6