DefaultStringRedisConnection (Spring Data Redis 2.6.9 API)

java.lang.Object
- org.springframework.data.redis.connection.DefaultStringRedisConnection

All Implemented Interfaces:

AutoCloseable, DecoratedRedisConnection, RedisCommands, RedisConnection, RedisConnectionCommands, RedisGeoCommands, RedisHashCommands, RedisHyperLogLogCommands, RedisKeyCommands, RedisListCommands, RedisPubSubCommands, RedisScriptingCommands, RedisServerCommands, RedisSetCommands, RedisStreamCommands, RedisStringCommands, RedisTxCommands, RedisZSetCommands, StringRedisConnection
```
public class DefaultStringRedisConnection
extends Object
implements StringRedisConnection, DecoratedRedisConnection
```
Default implementation of StringRedisConnection.

Author:

Costin Leau, Jennifer Hickey, Christoph Strobl, Thomas Darimont, Mark Paluch, Ninad Divadkar, Tugdual Grall, Andrey Shlykov, dengliming, ihaohong

Nested Class Summary
- Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.StringRedisConnection
  StringRedisConnection.StringTuple
- Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisStringCommands
  RedisStringCommands.BitOperation, RedisStringCommands.SetOption
- Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisListCommands
  RedisListCommands.Direction, RedisListCommands.Position
- Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisZSetCommands
  RedisZSetCommands.Aggregate, RedisZSetCommands.Limit, RedisZSetCommands.Range, RedisZSetCommands.Tuple, RedisZSetCommands.Weights, RedisZSetCommands.ZAddArgs
- Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisServerCommands
  RedisServerCommands.MigrateOption, RedisServerCommands.ShutdownOption
- Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisStreamCommands
  RedisStreamCommands.XAddOptions, RedisStreamCommands.XClaimOptions, RedisStreamCommands.XPendingOptions
- Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisGeoCommands
  RedisGeoCommands.DistanceUnit, RedisGeoCommands.GeoCommandArgs, RedisGeoCommands.GeoLocation<T>, RedisGeoCommands.GeoRadiusCommandArgs, RedisGeoCommands.GeoSearchCommandArgs, RedisGeoCommands.GeoSearchStoreCommandArgs

Constructor Summary

Constructors
Constructor and Description
`DefaultStringRedisConnection(RedisConnection connection)` Constructs a new `DefaultStringRedisConnection` instance.
`DefaultStringRedisConnection(RedisConnection connection, RedisSerializer<String> serializer)` Constructs a new `DefaultStringRedisConnection` instance.

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`Long`	`append(byte[] key, byte[] value)` Append a `value` to `key`.
`Long`	`append(String key, String value)` Append a `value` to `key`.
`void`	`bgReWriteAof()` Start an Append Only File rewrite process on server.
`void`	`bgSave()` Start background saving of db on server.
`void`	`bgWriteAof()` Deprecated. As of 1.3, use `bgReWriteAof()`.
`Long`	`bitCount(byte[] key)` Count the number of set bits (population counting) in value stored at `key`.
`Long`	`bitCount(byte[] key, long start, long end)` Count the number of set bits (population counting) of value stored at `key` between `start` and `end`.
`Long`	`bitCount(String key)` Count the number of set bits (population counting) in value stored at `key`.
`Long`	`bitCount(String key, long start, long end)` Count the number of set bits (population counting) of value stored at `key` between `start` and `end`.
`List<Long>`	`bitField(byte[] key, BitFieldSubCommands subCommands)` Get / Manipulate specific integer fields of varying bit widths and arbitrary non (necessary) aligned offset stored at a given `key`.
`List<Long>`	`bitfield(String key, BitFieldSubCommands operation)` Get / Manipulate specific integer fields of varying bit widths and arbitrary non (necessary) aligned offset stored at a given `key`.
`Long`	`bitOp(RedisStringCommands.BitOperation op, byte[] destination, byte[]... keys)` Perform bitwise operations between strings.
`Long`	`bitOp(RedisStringCommands.BitOperation op, String destination, String... keys)` Perform bitwise operations between strings.
`Long`	`bitPos(byte[] key, boolean bit, Range<Long> range)` Return the position of the first bit set to given `bit` in a string.
`Long`	`bitPos(String key, boolean bit, Range<Long> range)` Return the position of the first bit set to given `bit` in a string.
`byte[]`	`bLMove(byte[] sourceKey, byte[] destinationKey, RedisListCommands.Direction from, RedisListCommands.Direction to, double timeout)` Atomically returns and removes the first/last element (head/tail depending on the `from` argument) of the list stored at `sourceKey`, and pushes the element at the first/last element (head/tail depending on the `to` argument) of the list stored at `destinationKey`.
`String`	`bLMove(String sourceKey, String destinationKey, RedisListCommands.Direction from, RedisListCommands.Direction to, double timeout)` Atomically returns and removes the first/last element (head/tail depending on the `from` argument) of the list stored at `sourceKey`, and pushes the element at the first/last element (head/tail depending on the `to` argument) of the list stored at `destinationKey`.
`List<byte[]>`	`bLPop(int timeout, byte[]... keys)` Removes and returns first element from lists stored at `keys`.
`List<String>`	`bLPop(int timeout, String... keys)` Removes and returns first element from lists stored at `keys` (see: `RedisListCommands.lPop(byte[])`).
`List<byte[]>`	`bRPop(int timeout, byte[]... keys)` Removes and returns last element from lists stored at `keys`.
`List<String>`	`bRPop(int timeout, String... keys)` Removes and returns last element from lists stored at `keys` (see: `RedisListCommands.rPop(byte[])`).
`byte[]`	`bRPopLPush(int timeout, byte[] srcKey, byte[] dstKey)` Remove the last element from list at `srcKey`, append it to `dstKey` and return its value.
`String`	`bRPopLPush(int timeout, String srcKey, String dstKey)` Remove the last element from list at `srcKey`, append it to `dstKey` and return its value (see `RedisListCommands.rPopLPush(byte[], byte[])`).
`RedisZSetCommands.Tuple`	`bZPopMax(byte[] key, long timeout, TimeUnit unit)` Remove and return the value with its score having the highest score from sorted set at `key`.
`StringRedisConnection.StringTuple`	`bZPopMax(String key, long timeout, TimeUnit unit)` Remove and return the value with its score having the highest score from sorted set at `key`.
`RedisZSetCommands.Tuple`	`bZPopMin(byte[] key, long timeout, TimeUnit unit)` Remove and return the value with its score having the lowest score from sorted set at `key`.
`StringRedisConnection.StringTuple`	`bZPopMin(String key, long timeout, TimeUnit unit)` Remove and return the value with its score having the lowest score from sorted set at `key`.
`void`	`close()` Closes (or quits) the connection.
`List<Object>`	`closePipeline()` Executes the commands in the pipeline and returns their result.
`Boolean`	`copy(byte[] sourceKey, byte[] targetKey, boolean replace)` Copy given `sourceKey` to `targetKey`.
`Boolean`	`copy(String sourceKey, String targetKey, boolean replace)` Copy given `sourceKey` to `targetKey`.
`Long`	`dbSize()` Get the total number of available keys in currently selected database.
`Long`	`decr(byte[] key)` Decrement an integer value stored as string value of `key` by 1.
`Long`	`decr(String key)` Decrement an integer value stored as string value of `key` by 1.
`Long`	`decrBy(byte[] key, long value)` Decrement an integer value stored as string value of `key` by `value`.
`Long`	`decrBy(String key, long value)` Decrement an integer value stored as string value of `key` by `value`.
`Long`	`del(byte[]... keys)` Delete given `keys`.
`Long`	`del(String... keys)` Delete given `keys`.
`void`	`discard()` Discard all commands issued after `RedisTxCommands.multi()`.
`byte[]`	`dump(byte[] key)` Retrieve serialized version of the value stored at `key`.
`byte[]`	`echo(byte[] message)` Returns `message` via server roundtrip.
`String`	`echo(String message)` Returns `message` via server roundtrip.
`ValueEncoding`	`encodingOf(byte[] key)` Get the type of internal representation used for storing the value at the given `key`.
`ValueEncoding`	`encodingOf(String key)` Get the type of internal representation used for storing the value at the given `key`.
`<T> T`	`eval(byte[] script, ReturnType returnType, int numKeys, byte[]... keysAndArgs)` Evaluate given `script`.
`<T> T`	`eval(String script, ReturnType returnType, int numKeys, String... keysAndArgs)` NOTE: This method will not deserialize Strings returned by Lua scripts, as they may not be encoded with the same serializer used here.
`<T> T`	`evalSha(byte[] scriptSha1, ReturnType returnType, int numKeys, byte[]... keysAndArgs)` Evaluate given `scriptSha`.
`<T> T`	`evalSha(String scriptSha1, ReturnType returnType, int numKeys, byte[]... keysAndArgs)` Evaluate given `scriptSha`.
`<T> T`	`evalSha(String scriptSha1, ReturnType returnType, int numKeys, String... keysAndArgs)` NOTE: This method will not deserialize Strings returned by Lua scripts, as they may not be encoded with the same serializer used here.
`List<Object>`	`exec()` Executes all queued commands in a transaction started with `RedisTxCommands.multi()`.
`Object`	`execute(String command)` 'Native' or 'raw' execution of the given command along-side the given arguments.
`Object`	`execute(String command, byte[]... args)` 'Native' or 'raw' execution of the given command along-side the given arguments.
`Object`	`execute(String command, String... args)` 'Native' or 'raw' execution of the given command along-side the given arguments.
`Long`	`exists(byte[]... keys)` Count how many of the given `keys` exist.
`Boolean`	`exists(byte[] key)` Determine if given `key` exists.
`Long`	`exists(String... keys)` Count how many of the given `keys` exist.
`Boolean`	`exists(String key)` Determine if given `key` exists.
`Boolean`	`expire(byte[] key, long seconds)` Set time to live for given `key` in seconds.
`Boolean`	`expire(String key, long seconds)` Set time to live for given `key` in seconds.
`Boolean`	`expireAt(byte[] key, long unixTime)` Set the expiration for given `key` as a UNIX timestamp.
`Boolean`	`expireAt(String key, long unixTime)` Set the expiration for given `key` as a UNIX timestamp.
`void`	`flushAll()` Delete all all keys from all databases.
`void`	`flushDb()` Delete all keys of the currently selected database.
`Long`	`geoAdd(byte[] key, Iterable<RedisGeoCommands.GeoLocation<byte[]>> locations)` Add `RedisGeoCommands.GeoLocation`s to key
`Long`	`geoAdd(byte[] key, Map<byte[],Point> memberCoordinateMap)` Add `Map` of member / `Point` pairs to key.
`Long`	`geoAdd(byte[] key, Point point, byte[] member)` Add `Point` with given member name to key.
`Long`	`geoAdd(byte[] key, RedisGeoCommands.GeoLocation<byte[]> location)` Add `RedisGeoCommands.GeoLocation` to key.
`Long`	`geoAdd(String key, Iterable<RedisGeoCommands.GeoLocation<String>> locations)` Add `GeoLocation`s to key
`Long`	`geoAdd(String key, Map<String,Point> memberCoordinateMap)` Add `Map` of member / `Point` pairs to key.
`Long`	`geoAdd(String key, Point point, String member)` Add `Point` with given member name to key.
`Long`	`geoAdd(String key, RedisGeoCommands.GeoLocation<String> location)` Add `GeoLocation` to key.
`Distance`	`geoDist(byte[] key, byte[] member1, byte[] member2)` Get the `Distance` between member1 and member2.
`Distance`	`geoDist(byte[] key, byte[] member1, byte[] member2, Metric metric)` Get the `Distance` between member1 and member2 in the given `Metric`.
`Distance`	`geoDist(String key, String member1, String member2)` Get the `Distance` between member1 and member2.
`Distance`	`geoDist(String key, String member1, String member2, Metric metric)` Get the `Distance` between member1 and member2 in the given `Metric`.
`List<String>`	`geoHash(byte[] key, byte[]... members)` Get Geohash representation of the position for one or more members.
`List<String>`	`geoHash(String key, String... members)` Get geohash representation of the position for one or more members.
`List<Point>`	`geoPos(byte[] key, byte[]... members)` Get the `Point` representation of positions for one or more members.
`List<Point>`	`geoPos(String key, String... members)` Get the `Point` representation of positions for one or more members.
`GeoResults<RedisGeoCommands.GeoLocation<byte[]>>`	`geoRadius(byte[] key, Circle within)` Get the members within the boundaries of a given `Circle`.
`GeoResults<RedisGeoCommands.GeoLocation<byte[]>>`	`geoRadius(byte[] key, Circle within, RedisGeoCommands.GeoRadiusCommandArgs args)` Get the members within the boundaries of a given `Circle` applying `RedisGeoCommands.GeoRadiusCommandArgs`.
`GeoResults<RedisGeoCommands.GeoLocation<String>>`	`geoRadius(String key, Circle within)` Get the members within the boundaries of a given `Circle`.
`GeoResults<RedisGeoCommands.GeoLocation<String>>`	`geoRadius(String key, Circle within, RedisGeoCommands.GeoRadiusCommandArgs args)` Get the members within the boundaries of a given `Circle` applying `GeoRadiusCommandArgs`.
`GeoResults<RedisGeoCommands.GeoLocation<byte[]>>`	`geoRadiusByMember(byte[] key, byte[] member, Distance radius)` Get the members within the circle defined by the members coordinates and given `Distance`.
`GeoResults<RedisGeoCommands.GeoLocation<byte[]>>`	`geoRadiusByMember(byte[] key, byte[] member, Distance radius, RedisGeoCommands.GeoRadiusCommandArgs args)` Get the members within the circle defined by the members coordinates, given `Distance` and `RedisGeoCommands.GeoRadiusCommandArgs`.
`GeoResults<RedisGeoCommands.GeoLocation<byte[]>>`	`geoRadiusByMember(byte[] key, byte[] member, double radius)` Get the members within the circle defined by the members coordinates and given radius.
`GeoResults<RedisGeoCommands.GeoLocation<String>>`	`geoRadiusByMember(String key, String member, Distance radius)` Get the members within the circle defined by the members coordinates and given `Distance`.
`GeoResults<RedisGeoCommands.GeoLocation<String>>`	`geoRadiusByMember(String key, String member, Distance radius, RedisGeoCommands.GeoRadiusCommandArgs args)` Get the members within the circle defined by the members coordinates and given `Distance` and `GeoRadiusCommandArgs`.
`GeoResults<RedisGeoCommands.GeoLocation<String>>`	`geoRadiusByMember(String key, String member, double radius)` Get the members within the circle defined by the members coordinates and given radius.
`Long`	`geoRemove(byte[] key, byte[]... members)` Remove the members.
`Long`	`geoRemove(String key, String... members)` Remove the members.
`GeoResults<RedisGeoCommands.GeoLocation<byte[]>>`	`geoSearch(byte[] key, GeoReference<byte[]> reference, GeoShape predicate, RedisGeoCommands.GeoSearchCommandArgs args)` Return the members of a geo set which are within the borders of the area specified by a given `shape`.
`GeoResults<RedisGeoCommands.GeoLocation<String>>`	`geoSearch(String key, GeoReference<String> reference, GeoShape predicate, RedisGeoCommands.GeoSearchCommandArgs args)` Return the members of a geo set which are within the borders of the area specified by a given `shape`.
`Long`	`geoSearchStore(byte[] destKey, byte[] key, GeoReference<byte[]> reference, GeoShape predicate, RedisGeoCommands.GeoSearchStoreCommandArgs args)` Query the members of a geo set which are within the borders of the area specified by a given `shape` and store the result at `destKey`.
`Long`	`geoSearchStore(String destKey, String key, GeoReference<String> reference, GeoShape predicate, RedisGeoCommands.GeoSearchStoreCommandArgs args)` Query the members of a geo set which are within the borders of the area specified by a given `shape` and store the result at `destKey`.
`byte[]`	`get(byte[] key)` Get the value of `key`.
`String`	`get(String key)` Get the value of `key`.
`Boolean`	`getBit(byte[] key, long offset)` Get the bit value at `offset` of value at `key`.
`Boolean`	`getBit(String key, long offset)` Get the bit value at `offset` of value at `key`.
`List<RedisClientInfo>`	`getClientList()` Request information and statistics about connected clients.
`String`	`getClientName()` Returns the name of the current connection.
`Properties`	`getConfig(String pattern)` Load configuration parameters for given `pattern` from server.
`byte[]`	`getDel(byte[] key)` Return the value at `key` and delete the key.
`String`	`getDel(String key)` Return the value at `key` and delete the key.
`RedisConnection`	`getDelegate()` Gets the underlying `RedisConnection`.
`byte[]`	`getEx(byte[] key, Expiration expiration)` Return the value at `key` and expire the key by applying `Expiration`.
`String`	`getEx(String key, Expiration expiration)` Return the value at `key` and expire the key by applying `Expiration`.
`Object`	`getNativeConnection()` Returns the native connection (the underlying library/driver object).
`byte[]`	`getRange(byte[] key, long start, long end)` Get a substring of value of `key` between `start` and `end`.
`String`	`getRange(String key, long start, long end)` Get a substring of value of `key` between `start` and `end`.
`RedisSentinelConnection`	`getSentinelConnection()`
`byte[]`	`getSet(byte[] key, byte[] value)` Set `value` of `key` and return its old value.
`String`	`getSet(String key, String value)` Set `value` of `key` and return its old value.
`Subscription`	`getSubscription()` Returns the current subscription for this connection or null if the connection is not subscribed.
`Long`	`hDel(byte[] key, byte[]... fields)` Delete given hash `fields`.
`Long`	`hDel(String key, String... fields)` Delete given hash `fields`.
`Boolean`	`hExists(byte[] key, byte[] field)` Determine if given hash `field` exists.
`Boolean`	`hExists(String key, String field)` Determine if given hash `field` exists.
`byte[]`	`hGet(byte[] key, byte[] field)` Get value for given `field` from hash at `key`.
`String`	`hGet(String key, String field)` Get value for given `field` from hash at `key`.
`Map<byte[],byte[]>`	`hGetAll(byte[] key)` Get entire hash stored at `key`.
`Map<String,String>`	`hGetAll(String key)` Get entire hash stored at `key`.
`Double`	`hIncrBy(byte[] key, byte[] field, double delta)` Increment `value` of a hash `field` by the given `delta`.
`Long`	`hIncrBy(byte[] key, byte[] field, long delta)` Increment `value` of a hash `field` by the given `delta`.
`Double`	`hIncrBy(String key, String field, double delta)` Increment `value` of a hash `field` by the given `delta`.
`Long`	`hIncrBy(String key, String field, long delta)` Increment `value` of a hash `field` by the given `delta`.
`Set<byte[]>`	`hKeys(byte[] key)` Get key set (fields) of hash at `key`.
`Set<String>`	`hKeys(String key)` Get key set (fields) of hash at `key`.
`Long`	`hLen(byte[] key)` Get size of hash at `key`.
`Long`	`hLen(String key)` Get size of hash at `key`.
`List<byte[]>`	`hMGet(byte[] key, byte[]... fields)` Get values for given `fields` from hash at `key`.
`List<String>`	`hMGet(String key, String... fields)` Get values for given `fields` from hash at `key`.
`void`	`hMSet(byte[] key, Map<byte[],byte[]> hashes)` Set multiple hash fields to multiple values using data provided in `hashes`
`void`	`hMSet(String key, Map<String,String> hashes)` Set multiple hash fields to multiple values using data provided in `hashes`
`byte[]`	`hRandField(byte[] key)` Return a random field from the hash stored at `key`.
`List<byte[]>`	`hRandField(byte[] key, long count)` Return a random field from the hash stored at `key`.
`String`	`hRandField(String key)` Return a random field from the hash stored at `key`.
`List<String>`	`hRandField(String key, long count)` Return a random field from the hash stored at `key`.
`Map.Entry<byte[],byte[]>`	`hRandFieldWithValues(byte[] key)` Return a random field from the hash along with its value stored at `key`.
`List<Map.Entry<byte[],byte[]>>`	`hRandFieldWithValues(byte[] key, long count)` Return a random field from the hash along with its value stored at `key`.
`Map.Entry<String,String>`	`hRandFieldWithValues(String key)` Return a random field from the hash along with its value stored at `key`.
`List<Map.Entry<String,String>>`	`hRandFieldWithValues(String key, long count)` Return a random field from the hash along with its value stored at `key`.
`Cursor<Map.Entry<byte[],byte[]>>`	`hScan(byte[] key, ScanOptions options)` Use a `Cursor` to iterate over entries in hash at `key`.
`Cursor<Map.Entry<String,String>>`	`hScan(String key, ScanOptions options)` Use a `Cursor` to iterate over entries in hash at `key`.
`Boolean`	`hSet(byte[] key, byte[] field, byte[] value)` Set the `value` of a hash `field`.
`Boolean`	`hSet(String key, String field, String value)` Set the `value` of a hash `field`.
`Boolean`	`hSetNX(byte[] key, byte[] field, byte[] value)` Set the `value` of a hash `field` only if `field` does not exist.
`Boolean`	`hSetNX(String key, String field, String value)` Set the `value` of a hash `field` only if `field` does not exist.
`Long`	`hStrLen(byte[] key, byte[] field)` Returns the length of the value associated with `field` in the hash stored at `key`.
`Long`	`hStrLen(String key, String field)` Returns the length of the value associated with `field` in the hash stored at `key`.
`List<byte[]>`	`hVals(byte[] key)` Get entry set (values) of hash at `field`.
`List<String>`	`hVals(String key)` Get entry set (values) of hash at `field`.
`Duration`	`idletime(byte[] key)` Get the `Duration` since the object stored at the given `key` is idle.
`Duration`	`idletime(String key)` Get the `Duration` since the object stored at the given `key` is idle.
`Long`	`incr(byte[] key)` Increment an integer value stored as string value of `key` by 1.
`Long`	`incr(String key)` Increment an integer value stored as string value of `key` by 1.
`Double`	`incrBy(byte[] key, double value)` Increment a floating point number value of `key` by `delta`.
`Long`	`incrBy(byte[] key, long value)` Increment an integer value stored of `key` by `delta`.
`Double`	`incrBy(String key, double value)` Increment a floating point number value of `key` by `delta`.
`Long`	`incrBy(String key, long value)` Increment an integer value stored of `key` by `delta`.
`Properties`	`info()` Load default server information like memory cpu utilization replication
`Properties`	`info(String section)` Load server information for given `selection`.
`boolean`	`isClosed()` Indicates whether the underlying connection is closed or not.
`boolean`	`isPipelined()` Indicates whether the connection is currently pipelined or not.
`boolean`	`isQueueing()` Indicates whether the connection is in "queue"(or "MULTI") mode or not.
`boolean`	`isSubscribed()` Indicates whether the current connection is subscribed (to at least one channel) or not.
`Set<byte[]>`	`keys(byte[] pattern)` Find all keys matching the given `pattern`.
`Collection<String>`	`keys(String pattern)` Find all keys matching the given `pattern`.
`void`	`killClient(String host, int port)` Closes a given client connection identified by host:port.
`Long`	`lastSave()` Get time of last `RedisServerCommands.bgSave()` operation in seconds.
`byte[]`	`lIndex(byte[] key, long index)` Get element at `index` form list at `key`.
`String`	`lIndex(String key, long index)` Get element at `index` form list at `key`.
`Long`	`lInsert(byte[] key, RedisListCommands.Position where, byte[] pivot, byte[] value)` Insert `value` `RedisListCommands.Position.BEFORE` or `RedisListCommands.Position.AFTER` existing `pivot` for `key`.
`Long`	`lInsert(String key, RedisListCommands.Position where, String pivot, String value)` Insert `value` `Position#BEFORE` or `Position#AFTER` existing `pivot` for `key`.
`Long`	`lLen(byte[] key)` Get the size of list stored at `key`.
`Long`	`lLen(String key)` Get the size of list stored at `key`.
`byte[]`	`lMove(byte[] sourceKey, byte[] destinationKey, RedisListCommands.Direction from, RedisListCommands.Direction to)` Atomically returns and removes the first/last element (head/tail depending on the `from` argument) of the list stored at `sourceKey`, and pushes the element at the first/last element (head/tail depending on the `to` argument) of the list stored at `destinationKey`.
`String`	`lMove(String sourceKey, String destinationKey, RedisListCommands.Direction from, RedisListCommands.Direction to)` Atomically returns and removes the first/last element (head/tail depending on the `from` argument) of the list stored at `sourceKey`, and pushes the element at the first/last element (head/tail depending on the `to` argument) of the list stored at `destinationKey`.
`byte[]`	`lPop(byte[] key)` Removes and returns first element in list stored at `key`.
`List<byte[]>`	`lPop(byte[] key, long count)` Removes and returns first elements in list stored at `key`.
`String`	`lPop(String key)` Removes and returns first element in list stored at `key`.
`List<String>`	`lPop(String key, long count)` Removes and returns first elements in list stored at `key`.
`List<Long>`	`lPos(byte[] key, byte[] element, Integer rank, Integer count)` Returns the index of matching elements inside the list stored at given key.
`List<Long>`	`lPos(String key, String element, Integer rank, Integer count)` Returns the index of matching elements inside the list stored at given key.
`Long`	`lPush(byte[] key, byte[]... values)` Prepend `values` to `key`.
`Long`	`lPush(String key, String... values)` Prepend `values` to `key`.
`Long`	`lPushX(byte[] key, byte[] value)` Prepend `values` to `key` only if the list exists.
`Long`	`lPushX(String key, String value)` Prepend `values` to `key` only if the list exists.
`List<byte[]>`	`lRange(byte[] key, long start, long end)` Get elements between `start` and `end` from list at `key`.
`List<String>`	`lRange(String key, long start, long end)` Get elements between `start` and `end` from list at `key`.
`Long`	`lRem(byte[] key, long count, byte[] value)` Removes the first `count` occurrences of `value` from the list stored at `key`.
`Long`	`lRem(String key, long count, String value)` Removes the first `count` occurrences of `value` from the list stored at `key`.
`void`	`lSet(byte[] key, long index, byte[] value)` Set the `value` list element at `index`.
`void`	`lSet(String key, long index, String value)` Set the `value` list element at `index`.
`void`	`lTrim(byte[] key, long start, long end)` Trim list at `key` to elements between `start` and `end`.
`void`	`lTrim(String key, long start, long end)` Trim list at `key` to elements between `start` and `end`.
`List<byte[]>`	`mGet(byte[]... keys)` Get multiple `keys`.
`List<String>`	`mGet(String... keys)` Get multiple `keys`.
`void`	`migrate(byte[] key, RedisNode target, int dbIndex, RedisServerCommands.MigrateOption option)` Atomically transfer a key from a source Redis instance to a destination Redis instance.
`void`	`migrate(byte[] key, RedisNode target, int dbIndex, RedisServerCommands.MigrateOption option, long timeout)` Atomically transfer a key from a source Redis instance to a destination Redis instance.
`Boolean`	`move(byte[] key, int dbIndex)` Move given `key` to database with `index`.
`Boolean`	`move(String key, int dbIndex)` Move given `key` to database with `index`.
`Boolean`	`mSet(Map<byte[],byte[]> tuple)` Set multiple keys to multiple values using key-value pairs provided in `tuple`.
`Boolean`	`mSetNX(Map<byte[],byte[]> tuple)` Set multiple keys to multiple values using key-value pairs provided in `tuple` only if the provided key does not exist.
`Boolean`	`mSetNXString(Map<String,String> tuple)` Set multiple keys to multiple values using key-value pairs provided in `tuple` only if the provided key does not exist.
`Boolean`	`mSetString(Map<String,String> tuple)` Set multiple keys to multiple values using key-value pairs provided in `tuple`.
`void`	`multi()` Mark the start of a transaction block.
`void`	`openPipeline()` Activates the pipeline mode for this connection.
`Boolean`	`persist(byte[] key)` Remove the expiration from given `key`.
`Boolean`	`persist(String key)` Remove the expiration from given `key`.
`Boolean`	`pExpire(byte[] key, long millis)` Set time to live for given `key` in milliseconds.
`Boolean`	`pExpire(String key, long millis)` Set time to live for given `key` in milliseconds.
`Boolean`	`pExpireAt(byte[] key, long unixTimeInMillis)` Set the expiration for given `key` as a UNIX timestamp in milliseconds.
`Boolean`	`pExpireAt(String key, long unixTimeInMillis)` Set the expiration for given `key` as a UNIX timestamp in milliseconds.
`Long`	`pfAdd(byte[] key, byte[]... values)` Adds given values to the HyperLogLog stored at given key.
`Long`	`pfAdd(String key, String... values)` Adds given values to the HyperLogLog stored at given key.
`Long`	`pfCount(byte[]... keys)` Return the approximated cardinality of the structures observed by the HyperLogLog at key(s).
`Long`	`pfCount(String... keys)` Return the approximated cardinality of the structures observed by the HyperLogLog at key(s).
`void`	`pfMerge(byte[] destinationKey, byte[]... sourceKeys)` Merge N different HyperLogLogs at sourceKeys into a single destinationKey.
`void`	`pfMerge(String destinationKey, String... sourceKeys)` Merge N different HyperLogLogs at sourceKeys into a single destinationKey.
`String`	`ping()` Test connection.
`Boolean`	`pSetEx(byte[] key, long milliseconds, byte[] value)` Set the `value` and expiration in `milliseconds` for `key`.
`Boolean`	`pSetEx(String key, long seconds, String value)` Set the `value` and expiration in `milliseconds` for `key`.
`void`	`pSubscribe(MessageListener listener, byte[]... patterns)` Subscribes the connection to all channels matching the given patterns.
`void`	`pSubscribe(MessageListener listener, String... patterns)` Subscribes the connection to all channels matching the given patterns.
`Long`	`pTtl(byte[] key)` Get the precise time to live for `key` in milliseconds.
`Long`	`pTtl(byte[] key, TimeUnit timeUnit)` Get the precise time to live for `key` in and convert it to the given `TimeUnit`.
`Long`	`pTtl(String key)` Get the precise time to live for `key` in milliseconds.
`Long`	`pTtl(String key, TimeUnit timeUnit)` Get the precise time to live for `key` in and convert it to the given `TimeUnit`.
`Long`	`publish(byte[] channel, byte[] message)` Publishes the given message to the given channel.
`Long`	`publish(String channel, String message)` Publishes the given message to the given channel.
`byte[]`	`randomKey()` Return a random key from the keyspace.
`Long`	`refcount(byte[] key)` Get the number of references of the value associated with the specified `key`.
`Long`	`refcount(String key)` Get the number of references of the value associated with the specified `key`.
`void`	`rename(byte[] oldKey, byte[] newKey)` Rename key `oldKey` to `newKey`.
`void`	`rename(String oldKey, String newKey)` Rename key `oldKey` to `newKey`.
`Boolean`	`renameNX(byte[] oldKey, byte[] newKey)` Rename key `oldKey` to `newKey` only if `newKey` does not exist.
`Boolean`	`renameNX(String oldKey, String newKey)` Rename key `oldKey` to `newKey` only if `newKey` does not exist.
`void`	`resetConfigStats()` Reset statistic counters on server.
`void`	`restore(byte[] key, long ttlInMillis, byte[] serializedValue, boolean replace)` Create `key` using the `serializedValue`, previously obtained using `RedisKeyCommands.dump(byte[])`.
`void`	`rewriteConfig()` Rewrites the `redis.conf` file.
`byte[]`	`rPop(byte[] key)` Removes and returns last element in list stored at `key`.
`List<byte[]>`	`rPop(byte[] key, long count)` Removes and returns last elements in list stored at `key`.
`String`	`rPop(String key)` Removes and returns last element in list stored at `key`.
`List<String>`	`rPop(String key, long count)` Removes and returns last elements in list stored at `key`.
`byte[]`	`rPopLPush(byte[] srcKey, byte[] dstKey)` Remove the last element from list at `srcKey`, append it to `dstKey` and return its value.
`String`	`rPopLPush(String srcKey, String dstKey)` Remove the last element from list at `srcKey`, append it to `dstKey` and return its value.
`Long`	`rPush(byte[] key, byte[]... values)` Append `values` to `key`.
`Long`	`rPush(String key, String... values)` Append `values` to `key`.
`Long`	`rPushX(byte[] key, byte[] value)` Append `values` to `key` only if the list exists.
`Long`	`rPushX(String key, String value)` Append `values` to `key` only if the list exists.
`Long`	`sAdd(byte[] key, byte[]... values)` Add given `values` to set at `key`.
`Long`	`sAdd(String key, String... values)` Add given `values` to set at `key`.
`void`	`save()` Synchronous save current db snapshot on server.
`Cursor<byte[]>`	`scan(ScanOptions options)` Use a `Cursor` to iterate over keys.
`Long`	`sCard(byte[] key)` Get size of set at `key`.
`Long`	`sCard(String key)` Get size of set at `key`.
`List<Boolean>`	`scriptExists(String... scriptSha1)` Check if given `scriptShas` exist in script cache.
`void`	`scriptFlush()` Flush lua script cache.
`void`	`scriptKill()` Kill current lua script execution.
`String`	`scriptLoad(byte[] script)` Load lua script into scripts cache, without executing it.
`String`	`scriptLoad(String script)` Load lua script into scripts cache, without executing it.
`Set<byte[]>`	`sDiff(byte[]... keys)` Diff all sets for given `keys`.
`Set<String>`	`sDiff(String... keys)` Diff all sets for given `keys`.
`Long`	`sDiffStore(byte[] destKey, byte[]... keys)` Diff all sets for given `keys` and store result in `destKey`.
`Long`	`sDiffStore(String destKey, String... keys)` Diff all sets for given `keys` and store result in `destKey`.
`void`	`select(int dbIndex)` Select the DB with given positive `dbIndex`.
`Boolean`	`set(byte[] key, byte[] value)` Set `value` for `key`.
`Boolean`	`set(byte[] key, byte[] value, Expiration expiration, RedisStringCommands.SetOption option)` Set `value` for `key` applying timeouts from `expiration` if set and inserting/updating values depending on `option`.
`Boolean`	`set(String key, String value)` Set `value` for `key`.
`Boolean`	`set(String key, String value, Expiration expiration, RedisStringCommands.SetOption option)` Set `value` for `key` applying timeouts from `expiration` if set and inserting/updating values depending on `option`.
`Boolean`	`setBit(byte[] key, long offset, boolean value)` Sets the bit at `offset` in value stored at `key`.
`Boolean`	`setBit(String key, long offset, boolean value)` Sets the bit at `offset` in value stored at `key`.
`void`	`setClientName(byte[] name)` Assign given name to current connection.
`void`	`setClientName(String name)` Assign given name to current connection.
`void`	`setConfig(String param, String value)` Set server configuration for `param` to `value`.
`void`	`setDeserializePipelineAndTxResults(boolean deserializePipelineAndTxResults)` Specifies if pipelined and tx results should be deserialized to Strings.
`Boolean`	`setEx(byte[] key, long seconds, byte[] value)` Set the `value` and expiration in `seconds` for `key`.
`Boolean`	`setEx(String key, long seconds, String value)` Set the `value` and expiration in `seconds` for `key`.
`Boolean`	`setNX(byte[] key, byte[] value)` Set `value` for `key`, only if `key` does not exist.
`Boolean`	`setNX(String key, String value)` Set `value` for `key`, only if `key` does not exist.
`void`	`setRange(byte[] key, byte[] value, long start)` Overwrite parts of `key` starting at the specified `offset` with given `value`.
`void`	`setRange(String key, String value, long start)` Overwrite parts of `key` starting at the specified `offset` with given `value`.
`void`	`shutdown()` Shutdown server.
`void`	`shutdown(RedisServerCommands.ShutdownOption option)` Shutdown server.
`Set<byte[]>`	`sInter(byte[]... keys)` Returns the members intersecting all given sets at `keys`.
`Set<String>`	`sInter(String... keys)` Returns the members intersecting all given sets at `keys`.
`Long`	`sInterStore(byte[] destKey, byte[]... keys)` Intersect all given sets at `keys` and store result in `destKey`.
`Long`	`sInterStore(String destKey, String... keys)` Intersect all given sets at `keys` and store result in `destKey`.
`Boolean`	`sIsMember(byte[] key, byte[] value)` Check if set at `key` contains `value`.
`Boolean`	`sIsMember(String key, String value)` Check if set at `key` contains `value`.
`void`	`slaveOf(String host, int port)` Change redis replication setting to new master.
`void`	`slaveOfNoOne()` Change server into master.
`Set<byte[]>`	`sMembers(byte[] key)` Get all elements of set at `key`.
`Set<String>`	`sMembers(String key)` Get all elements of set at `key`.
`List<Boolean>`	`sMIsMember(byte[] key, byte[]... values)` Check if set at `key` contains one or more `values`.
`List<Boolean>`	`sMIsMember(String key, String... values)` Check if set at `key` contains one or more `values`.
`Boolean`	`sMove(byte[] srcKey, byte[] destKey, byte[] value)` Move `value` from `srcKey` to `destKey`
`Boolean`	`sMove(String srcKey, String destKey, String value)` Move `value` from `srcKey` to `destKey`
`List<byte[]>`	`sort(byte[] key, SortParameters params)` Sort the elements for `key`.
`Long`	`sort(byte[] key, SortParameters params, byte[] storeKey)` Sort the elements for `key` and store result in `storeKey`.
`List<String>`	`sort(String key, SortParameters params)` Sort the elements for `key`.
`Long`	`sort(String key, SortParameters params, String storeKey)` Sort the elements for `key` and store result in `storeKey`.
`byte[]`	`sPop(byte[] key)` Remove and return a random member from set at `key`.
`List<byte[]>`	`sPop(byte[] key, long count)` Remove and return `count` random members from set at `key`.
`String`	`sPop(String key)` Remove and return a random member from set at `key`.
`List<String>`	`sPop(String key, long count)` Remove and return `count` random members from set at `key`.
`byte[]`	`sRandMember(byte[] key)` Get random element from set at `key`.
`List<byte[]>`	`sRandMember(byte[] key, long count)` Get `count` random elements from set at `key`.
`String`	`sRandMember(String key)` Get random element from set at `key`.
`List<String>`	`sRandMember(String key, long count)` Get `count` random elements from set at `key`.
`Long`	`sRem(byte[] key, byte[]... values)` Remove given `values` from set at `key` and return the number of removed elements.
`Long`	`sRem(String key, String... values)` Remove given `values` from set at `key` and return the number of removed elements.
`Cursor<byte[]>`	`sScan(byte[] key, ScanOptions options)` Use a `Cursor` to iterate over elements in set at `key`.
`Cursor<String>`	`sScan(String key, ScanOptions options)` Use a `Cursor` to iterate over elements in set at `key`.
`Long`	`strLen(byte[] key)` Get the length of the value stored at `key`.
`Long`	`strLen(String key)` Get the length of the value stored at `key`.
`void`	`subscribe(MessageListener listener, byte[]... channels)` Subscribes the connection to the given channels.
`void`	`subscribe(MessageListener listener, String... channels)` Subscribes the connection to the given channels.
`Set<byte[]>`	`sUnion(byte[]... keys)` Union all sets at given `keys`.
`Set<String>`	`sUnion(String... keys)` Union all sets at given `keys`.
`Long`	`sUnionStore(byte[] destKey, byte[]... keys)` Union all sets at given `keys` and store result in `destKey`.
`Long`	`sUnionStore(String destKey, String... keys)` Union all sets at given `keys` and store result in `destKey`.
`Long`	`time()` Request server timestamp using `TIME` command in `TimeUnit.MILLISECONDS`.
`Long`	`time(TimeUnit timeUnit)` Request server timestamp using `TIME` command.
`Long`	`touch(byte[]... keys)` Alter the last access time of given `key(s)`.
`Long`	`touch(String... keys)` Alter the last access time of given `key(s)`.
`Long`	`ttl(byte[] key)` Get the time to live for `key` in seconds.
`Long`	`ttl(byte[] key, TimeUnit timeUnit)` Get the time to live for `key` in and convert it to the given `TimeUnit`.
`Long`	`ttl(String key)` Get the time to live for `key` in seconds.
`Long`	`ttl(String key, TimeUnit timeUnit)` Get the time to live for `key` in and convert it to the given `TimeUnit`.
`DataType`	`type(byte[] key)` Determine the type stored at `key`.
`DataType`	`type(String key)` Determine the type stored at `key`.
`Long`	`unlink(byte[]... keys)` Unlink the `keys` from the keyspace.
`Long`	`unlink(String... keys)` Unlink the `keys` from the keyspace.
`void`	`unwatch()` Flushes all the previously `#watch(byte[]...)` keys.
`void`	`watch(byte[]... keys)` Watch given `keys` for modifications during transaction started with `RedisTxCommands.multi()`.
`Long`	`xAck(byte[] key, String group, RecordId... recordIds)` Acknowledge one or more records, identified via their id, as processed.
`Long`	`xAck(String key, String group, RecordId... recordIds)`
`RecordId`	`xAdd(MapRecord<byte[],byte[],byte[]> record, RedisStreamCommands.XAddOptions options)` Append the given `record` to the stream stored at `Record#getStream`.
`RecordId`	`xAdd(StringRecord record, RedisStreamCommands.XAddOptions options)` Append the given `StringRecord` to the stream stored at `Record.getStream()`.
`List<ByteRecord>`	`xClaim(byte[] key, String group, String newOwner, RedisStreamCommands.XClaimOptions options)` Change the ownership of a pending message to the given new consumer.
`List<StringRecord>`	`xClaim(String key, String group, String consumer, RedisStreamCommands.XClaimOptions options)` Change the ownership of a pending message to the given new consumer.
`List<RecordId>`	`xClaimJustId(byte[] key, String group, String newOwner, RedisStreamCommands.XClaimOptions options)` Change the ownership of a pending message to the given new consumer without increasing the delivered count.
`List<RecordId>`	`xClaimJustId(String key, String group, String consumer, RedisStreamCommands.XClaimOptions options)` Change the ownership of a pending message to the given new consumer without increasing the delivered count.
`Long`	`xDel(byte[] key, RecordId... recordIds)` Removes the records with the given id's from the stream.
`Long`	`xDel(String key, RecordId... recordIds)`
`String`	`xGroupCreate(byte[] key, String groupName, ReadOffset readOffset)` Create a consumer group.
`String`	`xGroupCreate(byte[] key, String groupName, ReadOffset readOffset, boolean mkStream)` Create a consumer group.
`String`	`xGroupCreate(String key, ReadOffset readOffset, String group)` Create a consumer group.
`String`	`xGroupCreate(String key, ReadOffset readOffset, String group, boolean mkStream)` Create a consumer group.
`Boolean`	`xGroupDelConsumer(byte[] key, Consumer consumer)` Delete a consumer from a consumer group.
`Boolean`	`xGroupDelConsumer(String key, Consumer consumer)` Delete a consumer from a consumer group.
`Boolean`	`xGroupDestroy(byte[] key, String groupName)` Destroy a consumer group.
`Boolean`	`xGroupDestroy(String key, String group)` Destroy a consumer group.
`StreamInfo.XInfoStream`	`xInfo(byte[] key)` Obtain general information about the stream stored at the specified key.
`StreamInfo.XInfoStream`	`xInfo(String key)` Obtain general information about the stream stored at the specified key.
`StreamInfo.XInfoConsumers`	`xInfoConsumers(byte[] key, String groupName)` Obtain information about every consumer in a specific consumer group for the stream stored at the specified key.
`StreamInfo.XInfoConsumers`	`xInfoConsumers(String key, String groupName)` Obtain information about every consumer in a specific consumer group for the stream stored at the specified key.
`StreamInfo.XInfoGroups`	`xInfoGroups(byte[] key)` Obtain information about consumer groups associated with the stream stored at the specified key.
`StreamInfo.XInfoGroups`	`xInfoGroups(String key)` Obtain information about consumer groups associated with the stream stored at the specified key.
`Long`	`xLen(byte[] key)` Get the length of a stream.
`Long`	`xLen(String key)` Get the length of a stream.
`PendingMessagesSummary`	`xPending(byte[] key, String groupName)` Obtain the `PendingMessagesSummary` for a given consumer group.
`PendingMessages`	`xPending(byte[] key, String groupName, RedisStreamCommands.XPendingOptions options)` Obtain detailed information about pending `messages` applying given `options`.
`PendingMessagesSummary`	`xPending(String key, String groupName)` Obtain the `PendingMessagesSummary` for a given consumer group.
`PendingMessages`	`xPending(String key, String groupName, Range<String> range, Long count)` Obtain detailed information about pending `messages` for a given `Range` within a consumer group.
`PendingMessages`	`xPending(String key, String groupName, RedisStreamCommands.XPendingOptions options)` Obtain detailed information about pending `messages` applying given `options`.
`PendingMessages`	`xPending(String key, String groupName, String consumer, Range<String> range, Long count)` Obtain detailed information about pending `messages` for a given `Range` within a consumer group.
`List<ByteRecord>`	`xRange(byte[] key, Range<String> range, RedisZSetCommands.Limit limit)` Retrieve a `limited number` of `records` within a specific `Range` from the stream stored at key.
`List<StringRecord>`	`xRange(String key, Range<String> range, RedisZSetCommands.Limit limit)` Read records from a stream within a specific `Range` applying a `Limit`.
`List<ByteRecord>`	`xRead(StreamReadOptions readOptions, StreamOffset<byte[]>... streams)` Read records from one or more `StreamOffset`s.
`List<StringRecord>`	`xReadAsString(StreamReadOptions readOptions, StreamOffset<String>... streams)` Read records from one or more `StreamOffset`s.
`List<ByteRecord>`	`xReadGroup(Consumer consumer, StreamReadOptions readOptions, StreamOffset<byte[]>... streams)` Read records from one or more `StreamOffset`s using a consumer group.
`List<StringRecord>`	`xReadGroupAsString(Consumer consumer, StreamReadOptions readOptions, StreamOffset<String>... streams)` Read records from one or more `StreamOffset`s using a consumer group.
`List<ByteRecord>`	`xRevRange(byte[] key, Range<String> range, RedisZSetCommands.Limit limit)` Read records from a stream within a specific `Range` applying a `RedisZSetCommands.Limit` in reverse order.
`List<StringRecord>`	`xRevRange(String key, Range<String> range, RedisZSetCommands.Limit limit)` Read records from a stream within a specific `Range` applying a `Limit` in reverse order.
`Long`	`xTrim(byte[] key, long count)` Trims the stream to `count` elements.
`Long`	`xTrim(byte[] key, long count, boolean approximateTrimming)` Trims the stream to `count` elements.
`Long`	`xTrim(String key, long count)` Trims the stream to `count` elements.
`Long`	`xTrim(String key, long count, boolean approximateTrimming)` Trims the stream to `count` elements.
`Boolean`	`zAdd(byte[] key, double score, byte[] value, RedisZSetCommands.ZAddArgs args)` Add `value` to a sorted set at `key`, or update its `score` depending on the given `args`.
`Long`	`zAdd(byte[] key, Set<RedisZSetCommands.Tuple> tuples, RedisZSetCommands.ZAddArgs args)` Add `tuples` to a sorted set at `key`, or update its `score` depending on the given `args`.
`Boolean`	`zAdd(String key, double score, String value)` Add `value` to a sorted set at `key`, or update its `score` if it already exists.
`Boolean`	`zAdd(String key, double score, String value, RedisZSetCommands.ZAddArgs args)` Add the `value` to a sorted set at `key`, or update its `score` depending on the given `args`.
`Long`	`zAdd(String key, Set<StringRedisConnection.StringTuple> tuples)` Add `tuples` to a sorted set at `key`, or update its `score` if it already exists.
`Long`	`zAdd(String key, Set<StringRedisConnection.StringTuple> tuples, RedisZSetCommands.ZAddArgs args)` Add `tuples` to a sorted set at `key`, or update its `score` depending on the given `args`.
`Long`	`zCard(byte[] key)` Get the size of sorted set with `key`.
`Long`	`zCard(String 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`.
`Long`	`zCount(String key, double min, double max)` Count number of elements within sorted set with scores between `min` and `max`.
`Set<byte[]>`	`zDiff(byte[]... sets)` Diff sorted `sets`.
`Set<String>`	`zDiff(String... sets)` Diff sorted `sets`.
`Long`	`zDiffStore(byte[] destKey, byte[]... sets)` Diff sorted `sets` and store result in destination `destKey`.
`Long`	`zDiffStore(String destKey, String... sets)` Diff sorted `sets` and store result in destination `destKey`.
`Set<RedisZSetCommands.Tuple>`	`zDiffWithScores(byte[]... sets)` Diff sorted `sets`.
`Set<StringRedisConnection.StringTuple>`	`zDiffWithScores(String... sets)` Diff sorted `sets`.
`Double`	`zIncrBy(byte[] key, double increment, byte[] value)` Increment the score of element with `value` in sorted set by `increment`.
`Double`	`zIncrBy(String key, double increment, String value)` Increment the score of element with `value` in sorted set by `increment`.
`Set<byte[]>`	`zInter(byte[]... sets)` Intersect sorted `sets`.
`Set<String>`	`zInter(String... sets)` Intersect sorted `sets`.
`Long`	`zInterStore(byte[] destKey, byte[]... sets)` Intersect sorted `sets` and store result in destination `destKey`.
`Long`	`zInterStore(byte[] destKey, RedisZSetCommands.Aggregate aggregate, RedisZSetCommands.Weights weights, byte[]... sets)` Intersect sorted `sets` and store result in destination `destKey`.
`Long`	`zInterStore(String destKey, RedisZSetCommands.Aggregate aggregate, int[] weights, String... sets)` Intersect sorted `sets` and store result in destination `key`.
`Long`	`zInterStore(String destKey, String... sets)` Intersect sorted `sets` and store result in destination `key`.
`Set<RedisZSetCommands.Tuple>`	`zInterWithScores(byte[]... sets)` Intersect sorted `sets`.
`Set<RedisZSetCommands.Tuple>`	`zInterWithScores(RedisZSetCommands.Aggregate aggregate, RedisZSetCommands.Weights weights, byte[]... sets)` Intersect sorted `sets`.
`Set<StringRedisConnection.StringTuple>`	`zInterWithScores(RedisZSetCommands.Aggregate aggregate, RedisZSetCommands.Weights weights, String... sets)` Intersect sorted `sets`.
`Set<StringRedisConnection.StringTuple>`	`zInterWithScores(String... sets)` Intersect sorted `sets`.
`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.
`Long`	`zLexCount(String key, RedisZSetCommands.Range range)` Count number of elements within sorted set with value between `Range#min` and `Range#max` applying lexicographical ordering.
`List<Double>`	`zMScore(byte[] key, byte[]... values)` Get the scores of elements with `values` from sorted set with key `key`.
`List<Double>`	`zMScore(String key, String... values)` Get the scores of elements with `values` from sorted set with key `key`.
`RedisZSetCommands.Tuple`	`zPopMax(byte[] key)` Remove and return the value with its score having the highest score from sorted set at `key`.
`Set<RedisZSetCommands.Tuple>`	`zPopMax(byte[] key, long count)` Remove and return `count` values with their score having the highest score from sorted set at `key`.
`StringRedisConnection.StringTuple`	`zPopMax(String key)` Remove and return the value with its score having the highest score from sorted set at `key`.
`Set<StringRedisConnection.StringTuple>`	`zPopMax(String key, long count)` Remove and return `count` values with their score having the highest score from sorted set at `key`.
`RedisZSetCommands.Tuple`	`zPopMin(byte[] key)` Remove and return the value with its score having the lowest score from sorted set at `key`.
`Set<RedisZSetCommands.Tuple>`	`zPopMin(byte[] key, long count)` Remove and return `count` values with their score having the lowest score from sorted set at `key`.
`StringRedisConnection.StringTuple`	`zPopMin(String key)` Remove and return the value with its score having the lowest score from sorted set at `key`.
`Set<StringRedisConnection.StringTuple>`	`zPopMin(String key, long count)` Remove and return `count` values with their score having the lowest score from sorted set at `key`.
`byte[]`	`zRandMember(byte[] key)` Get random element from sorted set at `key`.
`List<byte[]>`	`zRandMember(byte[] key, long count)` Get `count` random elements from sorted set at `key`.
`String`	`zRandMember(String key)` Get random element from sorted set at `key`.
`List<String>`	`zRandMember(String key, long count)` Get `count` random elements from sorted set at `key`.
`RedisZSetCommands.Tuple`	`zRandMemberWithScore(byte[] key)` Get random element from sorted set at `key`.
`List<RedisZSetCommands.Tuple>`	`zRandMemberWithScore(byte[] key, long count)` Get `count` random elements from sorted set at `key`.
`StringRedisConnection.StringTuple`	`zRandMemberWithScore(String key)` Get random element from sorted set at `key`.
`List<StringRedisConnection.StringTuple>`	`zRandMemberWithScores(String key, long count)` Get `count` random elements from sorted set at `key`.
`Set<byte[]>`	`zRange(byte[] key, long start, long end)` Get elements between `start` and `end` from sorted set.
`Set<String>`	`zRange(String key, long start, long end)` Get elements between `start` 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<String>`	`zRangeByLex(String key)` Get all the elements in the sorted set at key in lexicographical ordering.
`Set<String>`	`zRangeByLex(String key, RedisZSetCommands.Range range)` Get all the elements in `Range` from the sorted set at key in lexicographical ordering.
`Set<String>`	`zRangeByLex(String key, RedisZSetCommands.Range range, RedisZSetCommands.Limit limit)` Get all the elements in `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 `start` 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 `start` to `end` where score is between `min` and `max` from sorted set.
`Set<String>`	`zRangeByScore(String key, double min, double max)` Get elements where score is between `min` and `max` from sorted set.
`Set<String>`	`zRangeByScore(String 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.
`Set<String>`	`zRangeByScore(String key, String min, String max)` Get elements where score is between `min` and `max` from sorted set.
`Set<String>`	`zRangeByScore(String 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.
`Set<RedisZSetCommands.Tuple>`	`zRangeByScoreWithScores(byte[] key, double min, double max)` Get set of `RedisZSetCommands.Tuple`s 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.Tuple`s in range from `start` 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.Tuple`s 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.Tuple`s in range from `Limit#offset` to `Limit#offset + Limit#count` where score is between `Range#min` and `Range#max` from sorted set.
`Set<StringRedisConnection.StringTuple>`	`zRangeByScoreWithScores(String key, double min, double max)` Get set of `Tuple`s where score is between `min` and `max` from sorted set.
`Set<StringRedisConnection.StringTuple>`	`zRangeByScoreWithScores(String key, double min, double max, long offset, long count)` Get set of `Tuple`s in range from `start` to `end` where score is between `min` and `max` from sorted set.
`Set<RedisZSetCommands.Tuple>`	`zRangeWithScores(byte[] key, long start, long end)` Get set of `RedisZSetCommands.Tuple`s between `start` and `end` from sorted set.
`Set<StringRedisConnection.StringTuple>`	`zRangeWithScores(String key, long start, long end)` Get set of `Tuple`s 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`	`zRank(String key, String value)` Determine the index of element with `value` in a sorted set.
`Long`	`zRem(byte[] key, byte[]... values)` Remove `values` from sorted set.
`Long`	`zRem(String key, String... 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`.
`Long`	`zRemRange(String key, long start, long end)` Remove elements in range between `start` and `end` from sorted set with `key`.
`Long`	`zRemRangeByLex(byte[] key, RedisZSetCommands.Range range)` Remove all elements between the lexicographical `RedisZSetCommands.Range`.
`Long`	`zRemRangeByLex(String key, RedisZSetCommands.Range range)` Remove all elements between the lexicographical `Range`.
`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`.
`Long`	`zRemRangeByScore(String key, double min, double max)` Remove elements with scores between `min` and `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.
`Set<String>`	`zRevRange(String key, long start, long end)` Get elements in range from `start` to `end` from sorted set ordered from high to low.
`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.
`Set<String>`	`zRevRangeByLex(String key, RedisZSetCommands.Range range, RedisZSetCommands.Limit limit)` Get all the elements in `Range` from the sorted set at key in reversed lexicographical ordering.
`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 `start` 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<String>`	`zRevRangeByScore(String key, double min, double max)` Get elements where score is between `min` and `max` from sorted set ordered from high to low.
`Set<String>`	`zRevRangeByScore(String 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.
`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 `start` 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<StringRedisConnection.StringTuple>`	`zRevRangeByScoreWithScores(String key, double min, double max)` Get set of `Tuple` where score is between `min` and `max` from sorted set ordered from high to low.
`Set<StringRedisConnection.StringTuple>`	`zRevRangeByScoreWithScores(String key, double min, double max, long offset, long count)` Get set of `Tuple` in range from `start` to `end` where score is between `min` and `max` from sorted set ordered high -> low.
`Set<RedisZSetCommands.Tuple>`	`zRevRangeWithScores(byte[] key, long start, long end)` Get set of `RedisZSetCommands.Tuple`s in range from `start` to `end` from sorted set ordered from high to low.
`Set<StringRedisConnection.StringTuple>`	`zRevRangeWithScores(String key, long start, long end)` Get set of `Tuple`s 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.
`Long`	`zRevRank(String key, String 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`.
`Cursor<StringRedisConnection.StringTuple>`	`zScan(String 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`.
`Double`	`zScore(String key, String value)` Get the score of element with `value` from sorted set with key `key`.
`Set<byte[]>`	`zUnion(byte[]... sets)` Union sorted `sets`.
`Set<String>`	`zUnion(String... sets)` Union sorted `sets`.
`Long`	`zUnionStore(byte[] destKey, byte[]... sets)` Union sorted `sets`.
`Long`	`zUnionStore(byte[] destKey, RedisZSetCommands.Aggregate aggregate, RedisZSetCommands.Weights weights, byte[]... sets)` Union sorted `sets` and store result in destination `destKey`.
`Long`	`zUnionStore(String destKey, RedisZSetCommands.Aggregate aggregate, int[] weights, String... sets)` Union sorted `sets` and store result in destination `key`.
`Long`	`zUnionStore(String destKey, String... sets)` Union sorted `sets` and store result in destination `key`.
`Set<RedisZSetCommands.Tuple>`	`zUnionWithScores(byte[]... sets)` Union sorted `sets`.
`Set<RedisZSetCommands.Tuple>`	`zUnionWithScores(RedisZSetCommands.Aggregate aggregate, RedisZSetCommands.Weights weights, byte[]... sets)` Union sorted `sets`.
`Set<StringRedisConnection.StringTuple>`	`zUnionWithScores(RedisZSetCommands.Aggregate aggregate, RedisZSetCommands.Weights weights, String... sets)` Union sorted `sets`.
`Set<StringRedisConnection.StringTuple>`	`zUnionWithScores(String... sets)` Union sorted `sets`.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.springframework.data.redis.connection.StringRedisConnection
bitPos, entryIds, lPos, xAck, xAdd, xAdd, xClaim, xDel, xRange, xReadAsString, xReadAsString, xReadAsString, xReadGroupAsString, xReadGroupAsString, xReadGroupAsString, xRevRange, zInterWithScores, zRevRangeByLex, zRevRangeByLex, zUnionWithScores

Methods inherited from interface org.springframework.data.redis.connection.RedisConnection
geoCommands, hashCommands, hyperLogLogCommands, keyCommands, listCommands, scriptingCommands, serverCommands, setCommands, streamCommands, stringCommands, zSetCommands

Methods inherited from interface org.springframework.data.redis.connection.RedisKeyCommands
restore, scan

Methods inherited from interface org.springframework.data.redis.connection.RedisStringCommands
bitPos

Methods inherited from interface org.springframework.data.redis.connection.RedisListCommands
lPos

Methods inherited from interface org.springframework.data.redis.connection.RedisZSetCommands
zAdd, zAdd, zInterStore, zInterWithScores, zRevRangeByLex, zRevRangeByLex, zUnionStore, zUnionWithScores

Methods inherited from interface org.springframework.data.redis.connection.RedisStreamCommands
xAck, xAdd, xAdd, xClaim, xDel, xGroupDelConsumer, xPending, xPending, xPending, xPending, xPending, xRange, xRead, xReadGroup, xRevRange

- Constructor Detail
  - DefaultStringRedisConnection
```
public DefaultStringRedisConnection(RedisConnection connection)
```
    Constructs a new DefaultStringRedisConnection instance. Uses StringRedisSerializer as underlying serializer.
    
    Parameters:
    
    connection - Redis connection
  - DefaultStringRedisConnection
```
public DefaultStringRedisConnection(RedisConnection connection,
                                    RedisSerializer<String> serializer)
```
    Constructs a new DefaultStringRedisConnection instance.
    
    Parameters:
    
    connection - Redis connection
    
    serializer - String serializer
- Method Detail
  - append
```
public Long append(byte[] key,
                   byte[] value)
```
    Description copied from interface: RedisStringCommands
    
    Append a value to key.
    
    Specified by:
    
    append in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    value - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: APPEND
  - bgSave
```
public void bgSave()
```
    Description copied from interface: RedisServerCommands
    
    Start background saving of db on server.
    
    Specified by:
    
    bgSave in interface RedisServerCommands
    
    See Also:
    
    Redis Documentation: BGSAVE
  - bgReWriteAof
```
public void bgReWriteAof()
```
    Description copied from interface: RedisServerCommands
    
    Start an Append Only File rewrite process on server.
    
    Specified by:
    
    bgReWriteAof in interface RedisServerCommands
    
    See Also:
    
    Redis Documentation: BGREWRITEAOF
  - bgWriteAof
```
@Deprecated
public void bgWriteAof()
```
    Deprecated. As of 1.3, use bgReWriteAof().
    
    Description copied from interface: RedisServerCommands
    
    Start an Append Only File rewrite process on server.
    
    Specified by:
    
    bgWriteAof in interface RedisServerCommands
    
    See Also:
    
    Redis Documentation: BGREWRITEAOF
  - bLPop
```
public List<byte[]> bLPop(int timeout,
                          byte[]... keys)
```
    Description copied from interface: RedisListCommands
    
    Removes and returns first element from lists stored at keys.
    Blocks connection until element available or timeout reached.
    
    Specified by:
    
    bLPop in interface RedisListCommands
    
    Parameters:
    
    timeout - seconds to block.
    
    keys - must not be null.
    
    Returns:
    
    empty List when no element could be popped and the timeout was reached. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: BLPOP, RedisListCommands.lPop(byte[])
  - bRPop
```
public List<byte[]> bRPop(int timeout,
                          byte[]... keys)
```
    Description copied from interface: RedisListCommands
    
    Removes and returns last element from lists stored at keys.
    Blocks connection until element available or timeout reached.
    
    Specified by:
    
    bRPop in interface RedisListCommands
    
    Parameters:
    
    timeout - seconds to block.
    
    keys - must not be null.
    
    Returns:
    
    empty List when no element could be popped and the timeout was reached. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: BRPOP, RedisListCommands.rPop(byte[])
  - bRPopLPush
```
public byte[] bRPopLPush(int timeout,
                         byte[] srcKey,
                         byte[] dstKey)
```
    Description copied from interface: RedisListCommands
    
    Remove the last element from list at srcKey, append it to dstKey and return its value.
    Blocks connection until element available or timeout reached.
    
    Specified by:
    
    bRPopLPush in interface RedisListCommands
    
    Parameters:
    
    timeout - seconds to block.
    
    srcKey - must not be null.
    
    dstKey - must not be null.
    
    Returns:
    
    can be null.
    
    See Also:
    
    Redis Documentation: BRPOPLPUSH, RedisListCommands.rPopLPush(byte[], byte[])
  - close
```
public void close()
           throws RedisSystemException
```
    Description copied from interface: RedisConnection
    
    Closes (or quits) the connection.
    
    Specified by:
    
    close in interface AutoCloseable
    
    Specified by:
    
    close in interface RedisConnection
    
    Throws:
    
    RedisSystemException
  - copy
```
public Boolean copy(byte[] sourceKey,
                    byte[] targetKey,
                    boolean replace)
```
    Description copied from interface: RedisKeyCommands
    
    Copy given sourceKey to targetKey.
    
    Specified by:
    
    copy in interface RedisKeyCommands
    
    Parameters:
    
    sourceKey - must not be null.
    
    targetKey - must not be null.
    
    replace - whether to replace existing keys.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: COPY
  - dbSize
```
public Long dbSize()
```
    Description copied from interface: RedisServerCommands
    
    Get the total number of available keys in currently selected database.
    
    Specified by:
    
    dbSize in interface RedisServerCommands
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: DBSIZE
  - decr
```
public Long decr(byte[] key)
```
    Description copied from interface: RedisStringCommands
    
    Decrement an integer value stored as string value of key by 1.
    
    Specified by:
    
    decr in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: DECR
  - decrBy
```
public Long decrBy(byte[] key,
                   long value)
```
    Description copied from interface: RedisStringCommands
    
    Decrement an integer value stored as string value of key by value.
    
    Specified by:
    
    decrBy in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: DECRBY
  - del
```
public Long del(byte[]... keys)
```
    Description copied from interface: RedisKeyCommands
    
    Delete given keys.
    
    Specified by:
    
    del in interface RedisKeyCommands
    
    Parameters:
    
    keys - must not be null.
    
    Returns:
    
    The number of keys that were removed. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: DEL
  - unlink
```
public Long unlink(byte[]... keys)
```
    Description copied from interface: RedisKeyCommands
    
    Unlink the keys from the keyspace. Unlike with #del(byte[]...) the actual memory reclaiming here happens asynchronously.
    
    Specified by:
    
    unlink in interface RedisKeyCommands
    
    Parameters:
    
    keys - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: UNLINK
  - discard
```
public void discard()
```
    Description copied from interface: RedisTxCommands
    
    Discard all commands issued after RedisTxCommands.multi().
    
    Specified by:
    
    discard in interface RedisTxCommands
    
    See Also:
    
    Redis Documentation: DISCARD
  - echo
```
public byte[] echo(byte[] message)
```
    Description copied from interface: RedisConnectionCommands
    
    Returns message via server roundtrip.
    
    Specified by:
    
    echo in interface RedisConnectionCommands
    
    Parameters:
    
    message - the message to echo.
    
    Returns:
    
    the message or null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ECHO
  - exec
```
public List<Object> exec()
```
    Description copied from interface: RedisTxCommands
    
    Executes all queued commands in a transaction started with RedisTxCommands.multi().
    If used along with #watch(byte[]...) the operation will fail if any of watched keys has been modified.
    
    Specified by:
    
    exec in interface RedisTxCommands
    
    Returns:
    
    List of replies for each executed command.
    
    See Also:
    
    Redis Documentation: EXEC
  - exists
```
public Boolean exists(byte[] key)
```
    Description copied from interface: RedisKeyCommands
    
    Determine if given key exists.
    
    Specified by:
    
    exists in interface RedisKeyCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    true if key exists. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: EXISTS
  - exists
```
public Long exists(String... keys)
```
    Description copied from interface: StringRedisConnection
    
    Count how many of the given keys exist.
    
    Specified by:
    
    exists in interface StringRedisConnection
    
    Parameters:
    
    keys - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: EXISTS, RedisKeyCommands.exists(byte[][])
  - exists
```
public Long exists(byte[]... keys)
```
    Description copied from interface: RedisKeyCommands
    
    Count how many of the given keys exist. Providing the very same key more than once also counts multiple times.
    
    Specified by:
    
    exists in interface RedisKeyCommands
    
    Parameters:
    
    keys - must not be null.
    
    Returns:
    
    the number of keys existing among the ones specified as arguments. null when used in pipeline / transaction.
  - expire
```
public Boolean expire(byte[] key,
                      long seconds)
```
    Description copied from interface: RedisKeyCommands
    
    Set time to live for given key in seconds.
    
    Specified by:
    
    expire in interface RedisKeyCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: EXPIRE
  - expireAt
```
public Boolean expireAt(byte[] key,
                        long unixTime)
```
    Description copied from interface: RedisKeyCommands
    
    Set the expiration for given key as a UNIX timestamp.
    
    Specified by:
    
    expireAt in interface RedisKeyCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: EXPIREAT
  - flushAll
```
public void flushAll()
```
    Description copied from interface: RedisServerCommands
    
    Delete all all keys from all databases.
    
    Specified by:
    
    flushAll in interface RedisServerCommands
    
    See Also:
    
    Redis Documentation: FLUSHALL
  - flushDb
```
public void flushDb()
```
    Description copied from interface: RedisServerCommands
    
    Delete all keys of the currently selected database.
    
    Specified by:
    
    flushDb in interface RedisServerCommands
    
    See Also:
    
    Redis Documentation: FLUSHDB
  - get
```
public byte[] get(byte[] key)
```
    Description copied from interface: RedisStringCommands
    
    Get the value of key.
    
    Specified by:
    
    get in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when key does not exist or used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: GET
  - getDel
```
@Nullable
public byte[] getDel(byte[] key)
```
    Description copied from interface: RedisStringCommands
    
    Return the value at key and delete the key.
    
    Specified by:
    
    getDel in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when key does not exist or used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: GETDEL
  - getDel
```
@Nullable
public String getDel(String key)
```
    Description copied from interface: StringRedisConnection
    
    Return the value at key and delete the key.
    
    Specified by:
    
    getDel in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when key does not exist or used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: GETDEL
  - getEx
```
@Nullable
public byte[] getEx(byte[] key,
                              Expiration expiration)
```
    Description copied from interface: RedisStringCommands
    
    Return the value at key and expire the key by applying Expiration.
    Use Expiration.seconds(long) for EX.
    Use Expiration.milliseconds(long) for PX.
    Use Expiration.unixTimestamp(long, TimeUnit) for EXAT | PXAT.
    
    Specified by:
    
    getEx in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    expiration - must not be null.
    
    Returns:
    
    null when key does not exist or used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: GETEX
  - getEx
```
@Nullable
public String getEx(String key,
                              Expiration expiration)
```
    Description copied from interface: StringRedisConnection
    
    Return the value at key and expire the key by applying Expiration.
    
    Specified by:
    
    getEx in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    expiration - must not be null.
    
    Returns:
    
    null when key does not exist or used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: GETEX
  - getBit
```
public Boolean getBit(byte[] key,
                      long offset)
```
    Description copied from interface: RedisStringCommands
    
    Get the bit value at offset of value at key.
    
    Specified by:
    
    getBit in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: GETBIT
  - getConfig
```
public Properties getConfig(String pattern)
```
    Description copied from interface: RedisServerCommands
    
    Load configuration parameters for given pattern from server.
    
    Specified by:
    
    getConfig in interface RedisServerCommands
    
    Parameters:
    
    pattern - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: CONFIG GET
  - getNativeConnection
```
public Object getNativeConnection()
```
    Description copied from interface: RedisConnection
    
    Returns the native connection (the underlying library/driver object).
    
    Specified by:
    
    getNativeConnection in interface RedisConnection
    
    Returns:
    
    underlying, native object
  - getRange
```
public byte[] getRange(byte[] key,
                       long start,
                       long end)
```
    Description copied from interface: RedisStringCommands
    
    Get a substring of value of key between start and end.
    
    Specified by:
    
    getRange in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: GETRANGE
  - getSet
```
public byte[] getSet(byte[] key,
                     byte[] value)
```
    Description copied from interface: RedisStringCommands
    
    Set value of key and return its old value.
    
    Specified by:
    
    getSet in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    value - must not be null.
    
    Returns:
    
    null if key did not exist before or when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: GETSET
  - getSubscription
```
public Subscription getSubscription()
```
    Description copied from interface: RedisPubSubCommands
    
    Returns the current subscription for this connection or null if the connection is not subscribed.
    
    Specified by:
    
    getSubscription in interface RedisPubSubCommands
    
    Returns:
    
    the current subscription, null if none is available.
  - hDel
```
public Long hDel(byte[] key,
                 byte[]... fields)
```
    Description copied from interface: RedisHashCommands
    
    Delete given hash fields.
    
    Specified by:
    
    hDel in interface RedisHashCommands
    
    Parameters:
    
    key - must not be null.
    
    fields - must not be empty.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: HDEL
  - hExists
```
public Boolean hExists(byte[] key,
                       byte[] field)
```
    Description copied from interface: RedisHashCommands
    
    Determine if given hash field exists.
    
    Specified by:
    
    hExists in interface RedisHashCommands
    
    Parameters:
    
    key - must not be null.
    
    field - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: HEXISTS
  - hGet
```
public byte[] hGet(byte[] key,
                   byte[] field)
```
    Description copied from interface: RedisHashCommands
    
    Get value for given field from hash at key.
    
    Specified by:
    
    hGet in interface RedisHashCommands
    
    Parameters:
    
    key - must not be null.
    
    field - must not be null.
    
    Returns:
    
    null when key or field do not exists or when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: HGET
  - hGetAll
```
public Map<byte[],byte[]> hGetAll(byte[] key)
```
    Description copied from interface: RedisHashCommands
    
    Get entire hash stored at key.
    
    Specified by:
    
    hGetAll in interface RedisHashCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    empty Map if key does not exist or null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: HGETALL
  - hIncrBy
```
public Long hIncrBy(byte[] key,
                    byte[] field,
                    long delta)
```
    Description copied from interface: RedisHashCommands
    
    Increment value of a hash field by the given delta.
    
    Specified by:
    
    hIncrBy in interface RedisHashCommands
    
    Parameters:
    
    key - must not be null.
    
    field - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: HINCRBY
  - hIncrBy
```
public Double hIncrBy(byte[] key,
                      byte[] field,
                      double delta)
```
    Description copied from interface: RedisHashCommands
    
    Increment value of a hash field by the given delta.
    
    Specified by:
    
    hIncrBy in interface RedisHashCommands
    
    Parameters:
    
    key - must not be null.
    
    field - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: HINCRBYFLOAT
  - hKeys
```
public Set<byte[]> hKeys(byte[] key)
```
    Description copied from interface: RedisHashCommands
    
    Get key set (fields) of hash at key.
    
    Specified by:
    
    hKeys in interface RedisHashCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: HKEYS?
  - hLen
```
public Long hLen(byte[] key)
```
    Description copied from interface: RedisHashCommands
    
    Get size of hash at key.
    
    Specified by:
    
    hLen in interface RedisHashCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: HLEN
  - hMGet
```
public List<byte[]> hMGet(byte[] key,
                          byte[]... fields)
```
    Description copied from interface: RedisHashCommands
    
    Get values for given fields from hash at key. Values are in the order of the requested keys Absent field values are represented using null in the resulting List.
    
    Specified by:
    
    hMGet in interface RedisHashCommands
    
    Parameters:
    
    key - must not be null.
    
    fields - must not be empty.
    
    Returns:
    
    empty List if key does not exist. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: HMGET
  - hMSet
```
public void hMSet(byte[] key,
                  Map<byte[],byte[]> hashes)
```
    Description copied from interface: RedisHashCommands
    
    Set multiple hash fields to multiple values using data provided in hashes
    
    Specified by:
    
    hMSet in interface RedisHashCommands
    
    Parameters:
    
    key - must not be null.
    
    hashes - must not be null.
    
    See Also:
    
    Redis Documentation: HMSET
  - hSet
```
public Boolean hSet(byte[] key,
                    byte[] field,
                    byte[] value)
```
    Description copied from interface: RedisHashCommands
    
    Set the value of a hash field.
    
    Specified by:
    
    hSet in interface RedisHashCommands
    
    Parameters:
    
    key - must not be null.
    
    field - must not be null.
    
    value - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: HSET
  - hSetNX
```
public Boolean hSetNX(byte[] key,
                      byte[] field,
                      byte[] value)
```
    Description copied from interface: RedisHashCommands
    
    Set the value of a hash field only if field does not exist.
    
    Specified by:
    
    hSetNX in interface RedisHashCommands
    
    Parameters:
    
    key - must not be null.
    
    field - must not be null.
    
    value - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: HSETNX
  - hVals
```
public List<byte[]> hVals(byte[] key)
```
    Description copied from interface: RedisHashCommands
    
    Get entry set (values) of hash at field.
    
    Specified by:
    
    hVals in interface RedisHashCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    empty List if key does not exist. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: HVALS
  - incr
```
public Long incr(byte[] key)
```
    Description copied from interface: RedisStringCommands
    
    Increment an integer value stored as string value of key by 1.
    
    Specified by:
    
    incr in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: INCR
  - incrBy
```
public Long incrBy(byte[] key,
                   long value)
```
    Description copied from interface: RedisStringCommands
    
    Increment an integer value stored of key by delta.
    
    Specified by:
    
    incrBy in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: INCRBY
  - incrBy
```
public Double incrBy(byte[] key,
                     double value)
```
    Description copied from interface: RedisStringCommands
    
    Increment a floating point number value of key by delta.
    
    Specified by:
    
    incrBy in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: INCRBYFLOAT
  - info
```
public Properties info()
```
    Description copied from interface: RedisServerCommands
    Load default server information like
    - memory
    - cpu utilization
    - replication
    Specified by:
    
    info in interface RedisServerCommands
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: INFO
  - info
```
public Properties info(String section)
```
    Description copied from interface: RedisServerCommands
    
    Load server information for given selection.
    
    Specified by:
    
    info in interface RedisServerCommands
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: INFO
  - isClosed
```
public boolean isClosed()
```
    Description copied from interface: RedisConnection
    
    Indicates whether the underlying connection is closed or not.
    
    Specified by:
    
    isClosed in interface RedisConnection
    
    Returns:
    
    true if the connection is closed, false otherwise.
  - isQueueing
```
public boolean isQueueing()
```
    Description copied from interface: RedisConnection
    
    Indicates whether the connection is in "queue"(or "MULTI") mode or not. When queueing, all commands are postponed until EXEC or DISCARD commands are issued. Since in queueing no results are returned, the connection will return NULL on all operations that interact with the data.
    
    Specified by:
    
    isQueueing in interface RedisConnection
    
    Returns:
    
    true if the connection is in queue/MULTI mode, false otherwise
  - isSubscribed
```
public boolean isSubscribed()
```
    Description copied from interface: RedisPubSubCommands
    
    Indicates whether the current connection is subscribed (to at least one channel) or not.
    
    Specified by:
    
    isSubscribed in interface RedisPubSubCommands
    
    Returns:
    
    true if the connection is subscribed, false otherwise
  - keys
```
public Set<byte[]> keys(byte[] pattern)
```
    Description copied from interface: RedisKeyCommands
    
    Find all keys matching the given pattern.
    
    Specified by:
    
    keys in interface RedisKeyCommands
    
    Parameters:
    
    pattern - must not be null.
    
    Returns:
    
    empty Set if no match found. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: KEYS
  - lastSave
```
public Long lastSave()
```
    Description copied from interface: RedisServerCommands
    
    Get time of last RedisServerCommands.bgSave() operation in seconds.
    
    Specified by:
    
    lastSave in interface RedisServerCommands
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: LASTSAVE
  - lIndex
```
public byte[] lIndex(byte[] key,
                     long index)
```
    Description copied from interface: RedisListCommands
    
    Get element at index form list at key.
    
    Specified by:
    
    lIndex in interface RedisListCommands
    
    Parameters:
    
    key - must not be null.
    
    index - zero based index value. Use negative number to designate elements starting at the tail.
    
    Returns:
    
    null when index is out of range or when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: LINDEX
  - lInsert
```
public Long lInsert(byte[] key,
                    RedisListCommands.Position where,
                    byte[] pivot,
                    byte[] value)
```
    Description copied from interface: RedisListCommands
    
    Insert value RedisListCommands.Position.BEFORE or RedisListCommands.Position.AFTER existing pivot for key.
    
    Specified by:
    
    lInsert in interface RedisListCommands
    
    Parameters:
    
    key - must not be null.
    
    where - must not be null.
    
    pivot - must not be null.
    
    value - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: LINSERT
  - lMove
```
public byte[] lMove(byte[] sourceKey,
                    byte[] destinationKey,
                    RedisListCommands.Direction from,
                    RedisListCommands.Direction to)
```
    Description copied from interface: RedisListCommands
    
    Atomically returns and removes the first/last element (head/tail depending on the from argument) of the list stored at sourceKey, and pushes the element at the first/last element (head/tail depending on the to argument) of the list stored at destinationKey.
    
    Specified by:
    
    lMove in interface RedisListCommands
    
    Parameters:
    
    sourceKey - must not be null.
    
    destinationKey - must not be null.
    
    from - must not be null.
    
    to - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: LMOVE, RedisListCommands.bLMove(byte[], byte[], Direction, Direction, double)
  - bLMove
```
public byte[] bLMove(byte[] sourceKey,
                     byte[] destinationKey,
                     RedisListCommands.Direction from,
                     RedisListCommands.Direction to,
                     double timeout)
```
    Description copied from interface: RedisListCommands
    
    Atomically returns and removes the first/last element (head/tail depending on the from argument) of the list stored at sourceKey, and pushes the element at the first/last element (head/tail depending on the to argument) of the list stored at destinationKey.
    Blocks connection until element available or timeout reached.
    
    Specified by:
    
    bLMove in interface RedisListCommands
    
    Parameters:
    
    sourceKey - must not be null.
    
    destinationKey - must not be null.
    
    from - must not be null.
    
    to - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: BLMOVE, RedisListCommands.lMove(byte[], byte[], Direction, Direction)
  - lMove
```
public String lMove(String sourceKey,
                    String destinationKey,
                    RedisListCommands.Direction from,
                    RedisListCommands.Direction to)
```
    Description copied from interface: StringRedisConnection
    
    Atomically returns and removes the first/last element (head/tail depending on the from argument) of the list stored at sourceKey, and pushes the element at the first/last element (head/tail depending on the to argument) of the list stored at destinationKey.
    
    Specified by:
    
    lMove in interface StringRedisConnection
    
    Parameters:
    
    sourceKey - must not be null.
    
    destinationKey - must not be null.
    
    from - must not be null.
    
    to - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: LMOVE, RedisListCommands.bLMove(byte[], byte[], Direction, Direction, double), RedisListCommands.lMove(byte[], byte[], Direction, Direction)
  - bLMove
```
public String bLMove(String sourceKey,
                     String destinationKey,
                     RedisListCommands.Direction from,
                     RedisListCommands.Direction to,
                     double timeout)
```
    Description copied from interface: StringRedisConnection
    
    Atomically returns and removes the first/last element (head/tail depending on the from argument) of the list stored at sourceKey, and pushes the element at the first/last element (head/tail depending on the to argument) of the list stored at destinationKey.
    
    Specified by:
    
    bLMove in interface StringRedisConnection
    
    Parameters:
    
    sourceKey - must not be null.
    
    destinationKey - must not be null.
    
    from - must not be null.
    
    to - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: BLMOVE, RedisListCommands.lMove(byte[], byte[], Direction, Direction), RedisListCommands.bLMove(byte[], byte[], Direction, Direction, double)
  - lLen
```
public Long lLen(byte[] key)
```
    Description copied from interface: RedisListCommands
    
    Get the size of list stored at key.
    
    Specified by:
    
    lLen in interface RedisListCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: LLEN
  - lPop
```
public byte[] lPop(byte[] key)
```
    Description copied from interface: RedisListCommands
    
    Removes and returns first element in list stored at key.
    
    Specified by:
    
    lPop in interface RedisListCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when key does not exist or used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: LPOP
  - lPop
```
public List<byte[]> lPop(byte[] key,
                         long count)
```
    Description copied from interface: RedisListCommands
    
    Removes and returns first elements in list stored at key.
    
    Specified by:
    
    lPop in interface RedisListCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when key does not exist or used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: LPOP
  - lPos
```
public List<Long> lPos(byte[] key,
                       byte[] element,
                       @Nullable
                       Integer rank,
                       @Nullable
                       Integer count)
```
    Description copied from interface: RedisListCommands
    
    Returns the index of matching elements inside the list stored at given key.
    Requires Redis 6.0.6 or newer.
    
    Specified by:
    
    lPos in interface RedisListCommands
    
    Parameters:
    
    key - must not be null.
    
    element - must not be null.
    
    rank - specifies the "rank" of the first element to return, in case there are multiple matches. A rank of 1 means to return the first match, 2 to return the second match, and so forth.
    
    count - number of matches to return.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: LPOS
  - lPush
```
public Long lPush(byte[] key,
                  byte[]... values)
```
    Description copied from interface: RedisListCommands
    
    Prepend values to key.
    
    Specified by:
    
    lPush in interface RedisListCommands
    
    Parameters:
    
    key - must not be null.
    
    values - must not be empty.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: LPUSH
  - lPushX
```
public Long lPushX(byte[] key,
                   byte[] value)
```
    Description copied from interface: RedisListCommands
    
    Prepend values to key only if the list exists.
    
    Specified by:
    
    lPushX in interface RedisListCommands
    
    Parameters:
    
    key - must not be null.
    
    value - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: LPUSHX
  - lRange
```
public List<byte[]> lRange(byte[] key,
                           long start,
                           long end)
```
    Description copied from interface: RedisListCommands
    
    Get elements between start and end from list at key.
    
    Specified by:
    
    lRange in interface RedisListCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    empty List if key does not exists or range does not contain values. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: LRANGE
  - lRem
```
public Long lRem(byte[] key,
                 long count,
                 byte[] value)
```
    Description copied from interface: RedisListCommands
    
    Removes the first count occurrences of value from the list stored at key.
    
    Specified by:
    
    lRem in interface RedisListCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: LREM
  - lSet
```
public void lSet(byte[] key,
                 long index,
                 byte[] value)
```
    Description copied from interface: RedisListCommands
    
    Set the value list element at index.
    
    Specified by:
    
    lSet in interface RedisListCommands
    
    Parameters:
    
    key - must not be null.
    
    See Also:
    
    Redis Documentation: LSET
  - lTrim
```
public void lTrim(byte[] key,
                  long start,
                  long end)
```
    Description copied from interface: RedisListCommands
    
    Trim list at key to elements between start and end.
    
    Specified by:
    
    lTrim in interface RedisListCommands
    
    Parameters:
    
    key - must not be null.
    
    See Also:
    
    Redis Documentation: LTRIM
  - mGet
```
public List<byte[]> mGet(byte[]... keys)
```
    Description copied from interface: RedisStringCommands
    
    Get multiple keys. Values are in the order of the requested keys Absent field values are represented using null in the resulting List.
    
    Specified by:
    
    mGet in interface RedisStringCommands
    
    Parameters:
    
    keys - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: MGET
  - mSet
```
public Boolean mSet(Map<byte[],byte[]> tuple)
```
    Description copied from interface: RedisStringCommands
    
    Set multiple keys to multiple values using key-value pairs provided in tuple.
    
    Specified by:
    
    mSet in interface RedisStringCommands
    
    Parameters:
    
    tuple - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: MSET
  - mSetNX
```
public Boolean mSetNX(Map<byte[],byte[]> tuple)
```
    Description copied from interface: RedisStringCommands
    
    Set multiple keys to multiple values using key-value pairs provided in tuple only if the provided key does not exist.
    
    Specified by:
    
    mSetNX in interface RedisStringCommands
    
    Parameters:
    
    tuple - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: MSETNX
  - multi
```
public void multi()
```
    Description copied from interface: RedisTxCommands
    
    Mark the start of a transaction block.
    Commands will be queued and can then be executed by calling RedisTxCommands.exec() or rolled back using RedisTxCommands.discard()
    
    Specified by:
    
    multi in interface RedisTxCommands
    
    See Also:
    
    Redis Documentation: MULTI
  - persist
```
public Boolean persist(byte[] key)
```
    Description copied from interface: RedisKeyCommands
    
    Remove the expiration from given key.
    
    Specified by:
    
    persist in interface RedisKeyCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: PERSIST
  - move
```
public Boolean move(byte[] key,
                    int dbIndex)
```
    Description copied from interface: RedisKeyCommands
    
    Move given key to database with index.
    
    Specified by:
    
    move in interface RedisKeyCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: MOVE
  - ping
```
public String ping()
```
    Description copied from interface: RedisConnectionCommands
    
    Test connection.
    
    Specified by:
    
    ping in interface RedisConnectionCommands
    
    Returns:
    
    Server response message - usually PONG. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: PING
  - pSubscribe
```
public void pSubscribe(MessageListener listener,
                       byte[]... patterns)
```
    Description copied from interface: RedisPubSubCommands
    
    Subscribes the connection to all channels matching the given patterns. Once subscribed, a connection enters listening mode and can only subscribe to other channels or unsubscribe. No other commands are accepted until the connection is unsubscribed.
    Note that this operation is blocking and the current thread starts waiting for new messages immediately.
    
    Specified by:
    
    pSubscribe in interface RedisPubSubCommands
    
    Parameters:
    
    listener - message listener, must not be null.
    
    patterns - channel name patterns, must not be null.
    
    See Also:
    
    Redis Documentation: PSUBSCRIBE
  - publish
```
public Long publish(byte[] channel,
                    byte[] message)
```
    Description copied from interface: RedisPubSubCommands
    
    Publishes the given message to the given channel.
    
    Specified by:
    
    publish in interface RedisPubSubCommands
    
    Parameters:
    
    channel - the channel to publish to. Must not be null.
    
    message - message to publish. Must not be null.
    
    Returns:
    
    the number of clients that received the message or null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: PUBLISH
  - randomKey
```
public byte[] randomKey()
```
    Description copied from interface: RedisKeyCommands
    
    Return a random key from the keyspace.
    
    Specified by:
    
    randomKey in interface RedisKeyCommands
    
    Returns:
    
    null if no keys available or when used in pipeline or transaction.
    
    See Also:
    
    Redis Documentation: RANDOMKEY
  - rename
```
public void rename(byte[] oldKey,
                   byte[] newKey)
```
    Description copied from interface: RedisKeyCommands
    
    Rename key oldKey to newKey.
    
    Specified by:
    
    rename in interface RedisKeyCommands
    
    Parameters:
    
    oldKey - must not be null.
    
    newKey - must not be null.
    
    See Also:
    
    Redis Documentation: RENAME
  - renameNX
```
public Boolean renameNX(byte[] oldKey,
                        byte[] newKey)
```
    Description copied from interface: RedisKeyCommands
    
    Rename key oldKey to newKey only if newKey does not exist.
    
    Specified by:
    
    renameNX in interface RedisKeyCommands
    
    Parameters:
    
    oldKey - must not be null.
    
    newKey - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: RENAMENX
  - resetConfigStats
```
public void resetConfigStats()
```
    Description copied from interface: RedisServerCommands
    
    Reset statistic counters on server.
    Counters can be retrieved using RedisServerCommands.info().
    
    Specified by:
    
    resetConfigStats in interface RedisServerCommands
    
    See Also:
    
    Redis Documentation: CONFIG RESETSTAT
  - rewriteConfig
```
public void rewriteConfig()
```
    Description copied from interface: RedisServerCommands
    
    Rewrites the redis.conf file.
    
    Specified by:
    
    rewriteConfig in interface RedisServerCommands
    
    See Also:
    
    Redis Documentation: CONFIG REWRITE
  - rPop
```
public byte[] rPop(byte[] key)
```
    Description copied from interface: RedisListCommands
    
    Removes and returns last element in list stored at key.
    
    Specified by:
    
    rPop in interface RedisListCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when key does not exist or used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: RPOP
  - rPop
```
public List<byte[]> rPop(byte[] key,
                         long count)
```
    Description copied from interface: RedisListCommands
    
    Removes and returns last elements in list stored at key.
    
    Specified by:
    
    rPop in interface RedisListCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when key does not exist or used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: RPOP
  - rPopLPush
```
public byte[] rPopLPush(byte[] srcKey,
                        byte[] dstKey)
```
    Description copied from interface: RedisListCommands
    
    Remove the last element from list at srcKey, append it to dstKey and return its value.
    
    Specified by:
    
    rPopLPush in interface RedisListCommands
    
    Parameters:
    
    srcKey - must not be null.
    
    dstKey - must not be null.
    
    Returns:
    
    can be null.
    
    See Also:
    
    Redis Documentation: RPOPLPUSH
  - rPush
```
public Long rPush(byte[] key,
                  byte[]... values)
```
    Description copied from interface: RedisListCommands
    
    Append values to key.
    
    Specified by:
    
    rPush in interface RedisListCommands
    
    Parameters:
    
    key - must not be null.
    
    values - must not be empty.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: RPUSH
  - rPushX
```
public Long rPushX(byte[] key,
                   byte[] value)
```
    Description copied from interface: RedisListCommands
    
    Append values to key only if the list exists.
    
    Specified by:
    
    rPushX in interface RedisListCommands
    
    Parameters:
    
    key - must not be null.
    
    value - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: RPUSHX
  - sAdd
```
public Long sAdd(byte[] key,
                 byte[]... values)
```
    Description copied from interface: RedisSetCommands
    
    Add given values to set at key.
    
    Specified by:
    
    sAdd in interface RedisSetCommands
    
    Parameters:
    
    key - must not be null.
    
    values - must not be empty.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: SADD
  - save
```
public void save()
```
    Description copied from interface: RedisServerCommands
    
    Synchronous save current db snapshot on server.
    
    Specified by:
    
    save in interface RedisServerCommands
    
    See Also:
    
    Redis Documentation: SAVE
  - sCard
```
public Long sCard(byte[] key)
```
    Description copied from interface: RedisSetCommands
    
    Get size of set at key.
    
    Specified by:
    
    sCard in interface RedisSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: SCARD
  - sDiff
```
public Set<byte[]> sDiff(byte[]... keys)
```
    Description copied from interface: RedisSetCommands
    
    Diff all sets for given keys.
    
    Specified by:
    
    sDiff in interface RedisSetCommands
    
    Parameters:
    
    keys - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: SDIFF
  - sDiffStore
```
public Long sDiffStore(byte[] destKey,
                       byte[]... keys)
```
    Description copied from interface: RedisSetCommands
    
    Diff all sets for given keys and store result in destKey.
    
    Specified by:
    
    sDiffStore in interface RedisSetCommands
    
    Parameters:
    
    destKey - must not be null.
    
    keys - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: SDIFFSTORE
  - select
```
public void select(int dbIndex)
```
    Description copied from interface: RedisConnectionCommands
    
    Select the DB with given positive dbIndex.
    
    Specified by:
    
    select in interface RedisConnectionCommands
    
    Parameters:
    
    dbIndex - the database index.
    
    See Also:
    
    Redis Documentation: SELECT
  - set
```
public Boolean set(byte[] key,
                   byte[] value)
```
    Description copied from interface: RedisStringCommands
    
    Set value for key.
    
    Specified by:
    
    set in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    value - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: SET
  - set
```
public Boolean set(byte[] key,
                   byte[] value,
                   Expiration expiration,
                   RedisStringCommands.SetOption option)
```
    Description copied from interface: RedisStringCommands
    
    Set value for key applying timeouts from expiration if set and inserting/updating values depending on option.
    
    Specified by:
    
    set in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    value - must not be null.
    
    expiration - must not be null. Use Expiration.persistent() to not set any ttl or Expiration.keepTtl() to keep the existing expiration.
    
    option - must not be null. Use RedisStringCommands.SetOption.upsert() to add non existing.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: SET
  - setBit
```
public Boolean setBit(byte[] key,
                      long offset,
                      boolean value)
```
    Description copied from interface: RedisStringCommands
    
    Sets the bit at offset in value stored at key.
    
    Specified by:
    
    setBit in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    the original bit value stored at offset or null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: SETBIT
  - setConfig
```
public void setConfig(String param,
                      String value)
```
    Description copied from interface: RedisServerCommands
    
    Set server configuration for param to value.
    
    Specified by:
    
    setConfig in interface RedisServerCommands
    
    Parameters:
    
    param - must not be null.
    
    value - must not be null.
    
    See Also:
    
    Redis Documentation: CONFIG SET
  - setEx
```
public Boolean setEx(byte[] key,
                     long seconds,
                     byte[] value)
```
    Description copied from interface: RedisStringCommands
    
    Set the value and expiration in seconds for key.
    
    Specified by:
    
    setEx in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    value - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: SETEX
  - pSetEx
```
public Boolean pSetEx(byte[] key,
                      long milliseconds,
                      byte[] value)
```
    Description copied from interface: RedisStringCommands
    
    Set the value and expiration in milliseconds for key.
    
    Specified by:
    
    pSetEx in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    value - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: PSETEX
  - setNX
```
public Boolean setNX(byte[] key,
                     byte[] value)
```
    Description copied from interface: RedisStringCommands
    
    Set value for key, only if key does not exist.
    
    Specified by:
    
    setNX in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    value - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: SETNX
  - setRange
```
public void setRange(byte[] key,
                     byte[] value,
                     long start)
```
    Description copied from interface: RedisStringCommands
    
    Overwrite parts of key starting at the specified offset with given value.
    
    Specified by:
    
    setRange in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    See Also:
    
    Redis Documentation: SETRANGE
  - shutdown
```
public void shutdown()
```
    Description copied from interface: RedisServerCommands
    
    Shutdown server.
    
    Specified by:
    
    shutdown in interface RedisServerCommands
    
    See Also:
    
    Redis Documentation: SHUTDOWN
  - shutdown
```
public void shutdown(RedisServerCommands.ShutdownOption option)
```
    Description copied from interface: RedisServerCommands
    
    Shutdown server.
    
    Specified by:
    
    shutdown in interface RedisServerCommands
    
    See Also:
    
    Redis Documentation: SHUTDOWN
  - sInter
```
public Set<byte[]> sInter(byte[]... keys)
```
    Description copied from interface: RedisSetCommands
    
    Returns the members intersecting all given sets at keys.
    
    Specified by:
    
    sInter in interface RedisSetCommands
    
    Parameters:
    
    keys - must not be null.
    
    Returns:
    
    empty Set if no intersection found. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: SINTER
  - sInterStore
```
public Long sInterStore(byte[] destKey,
                        byte[]... keys)
```
    Description copied from interface: RedisSetCommands
    
    Intersect all given sets at keys and store result in destKey.
    
    Specified by:
    
    sInterStore in interface RedisSetCommands
    
    Parameters:
    
    destKey - must not be null.
    
    keys - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: SINTERSTORE
  - sIsMember
```
public Boolean sIsMember(byte[] key,
                         byte[] value)
```
    Description copied from interface: RedisSetCommands
    
    Check if set at key contains value.
    
    Specified by:
    
    sIsMember in interface RedisSetCommands
    
    Parameters:
    
    key - must not be null.
    
    value - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: SISMEMBER
  - sMIsMember
```
public List<Boolean> sMIsMember(byte[] key,
                                byte[]... values)
```
    Description copied from interface: RedisSetCommands
    
    Check if set at key contains one or more values.
    
    Specified by:
    
    sMIsMember in interface RedisSetCommands
    
    Parameters:
    
    key - must not be null.
    
    values - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: SMISMEMBER
  - sMembers
```
public Set<byte[]> sMembers(byte[] key)
```
    Description copied from interface: RedisSetCommands
    
    Get all elements of set at key.
    
    Specified by:
    
    sMembers in interface RedisSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    empty Set when key does not exist. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: SMEMBERS
  - sMove
```
public Boolean sMove(byte[] srcKey,
                     byte[] destKey,
                     byte[] value)
```
    Description copied from interface: RedisSetCommands
    
    Move value from srcKey to destKey
    
    Specified by:
    
    sMove in interface RedisSetCommands
    
    Parameters:
    
    srcKey - must not be null.
    
    destKey - must not be null.
    
    value - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: SMOVE
  - sort
```
public Long sort(byte[] key,
                 SortParameters params,
                 byte[] storeKey)
```
    Description copied from interface: RedisKeyCommands
    
    Sort the elements for key and store result in storeKey.
    
    Specified by:
    
    sort in interface RedisKeyCommands
    
    Parameters:
    
    key - must not be null.
    
    params - must not be null.
    
    storeKey - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: SORT
  - sort
```
public List<byte[]> sort(byte[] key,
                         SortParameters params)
```
    Description copied from interface: RedisKeyCommands
    
    Sort the elements for key.
    
    Specified by:
    
    sort in interface RedisKeyCommands
    
    Parameters:
    
    key - must not be null.
    
    params - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: SORT
  - encodingOf
```
public ValueEncoding encodingOf(byte[] key)
```
    Description copied from interface: RedisKeyCommands
    
    Get the type of internal representation used for storing the value at the given key.
    
    Specified by:
    
    encodingOf in interface RedisKeyCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    ValueEncoding.RedisValueEncoding.VACANT if key does not exist or null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: OBJECT ENCODING
  - idletime
```
public Duration idletime(byte[] key)
```
    Description copied from interface: RedisKeyCommands
    
    Get the Duration since the object stored at the given key is idle.
    
    Specified by:
    
    idletime in interface RedisKeyCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null if key does not exist or when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: OBJECT IDLETIME
  - refcount
```
public Long refcount(byte[] key)
```
    Description copied from interface: RedisKeyCommands
    
    Get the number of references of the value associated with the specified key.
    
    Specified by:
    
    refcount in interface RedisKeyCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null if key does not exist or when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: OBJECT REFCOUNT
  - sPop
```
public byte[] sPop(byte[] key)
```
    Description copied from interface: RedisSetCommands
    
    Remove and return a random member from set at key.
    
    Specified by:
    
    sPop in interface RedisSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when key does not exist or used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: SPOP
  - sPop
```
public List<byte[]> sPop(byte[] key,
                         long count)
```
    Description copied from interface: RedisSetCommands
    
    Remove and return count random members from set at key.
    
    Specified by:
    
    sPop in interface RedisSetCommands
    
    Parameters:
    
    key - must not be null.
    
    count - number of random members to pop from the set.
    
    Returns:
    
    empty List if set does not exist. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: SPOP
  - sRandMember
```
public byte[] sRandMember(byte[] key)
```
    Description copied from interface: RedisSetCommands
    
    Get random element from set at key.
    
    Specified by:
    
    sRandMember in interface RedisSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    can be null.
    
    See Also:
    
    Redis Documentation: SRANDMEMBER
  - sRandMember
```
public List<byte[]> sRandMember(byte[] key,
                                long count)
```
    Description copied from interface: RedisSetCommands
    
    Get count random elements from set at key.
    
    Specified by:
    
    sRandMember in interface RedisSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: SRANDMEMBER
  - sRem
```
public Long sRem(byte[] key,
                 byte[]... values)
```
    Description copied from interface: RedisSetCommands
    
    Remove given values from set at key and return the number of removed elements.
    
    Specified by:
    
    sRem in interface RedisSetCommands
    
    Parameters:
    
    key - must not be null.
    
    values - must not be empty.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: SREM
  - strLen
```
public Long strLen(byte[] key)
```
    Description copied from interface: RedisStringCommands
    
    Get the length of the value stored at key.
    
    Specified by:
    
    strLen in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: STRLEN
  - bitCount
```
public Long bitCount(byte[] key)
```
    Description copied from interface: RedisStringCommands
    
    Count the number of set bits (population counting) in value stored at key.
    
    Specified by:
    
    bitCount in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: BITCOUNT
  - bitCount
```
public Long bitCount(byte[] key,
                     long start,
                     long end)
```
    Description copied from interface: RedisStringCommands
    
    Count the number of set bits (population counting) of value stored at key between start and end.
    
    Specified by:
    
    bitCount in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: BITCOUNT
  - bitOp
```
public Long bitOp(RedisStringCommands.BitOperation op,
                  byte[] destination,
                  byte[]... keys)
```
    Description copied from interface: RedisStringCommands
    
    Perform bitwise operations between strings.
    
    Specified by:
    
    bitOp in interface RedisStringCommands
    
    Parameters:
    
    op - must not be null.
    
    destination - must not be null.
    
    keys - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: BITOP
  - bitPos
```
@Nullable
public Long bitPos(byte[] key,
                             boolean bit,
                             Range<Long> range)
```
    Description copied from interface: RedisStringCommands
    
    Return the position of the first bit set to given bit in a string. Range start and end can contain negative values in order to index bytes starting from the end of the string, where -1 is the last byte, -2 is the penultimate.
    
    Specified by:
    
    bitPos in interface RedisStringCommands
    
    Parameters:
    
    key - the key holding the actual String.
    
    bit - the bit value to look for.
    
    range - must not be null. Use Range.unbounded() to not limit search.
    
    Returns:
    
    null when used in pipeline / transaction. The position of the first bit set to 1 or 0 according to the request.
    
    See Also:
    
    Redis Documentation: BITPOS
  - subscribe
```
public void subscribe(MessageListener listener,
                      byte[]... channels)
```
    Description copied from interface: RedisPubSubCommands
    
    Subscribes the connection to the given channels. Once subscribed, a connection enters listening mode and can only subscribe to other channels or unsubscribe. No other commands are accepted until the connection is unsubscribed.
    Note that this operation is blocking and the current thread starts waiting for new messages immediately.
    
    Specified by:
    
    subscribe in interface RedisPubSubCommands
    
    Parameters:
    
    listener - message listener, must not be null.
    
    channels - channel names, must not be null.
    
    See Also:
    
    Redis Documentation: SUBSCRIBE
  - sUnion
```
public Set<byte[]> sUnion(byte[]... keys)
```
    Description copied from interface: RedisSetCommands
    
    Union all sets at given keys.
    
    Specified by:
    
    sUnion in interface RedisSetCommands
    
    Parameters:
    
    keys - must not be null.
    
    Returns:
    
    empty Set if keys do not exist. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: SUNION
  - sUnionStore
```
public Long sUnionStore(byte[] destKey,
                        byte[]... keys)
```
    Description copied from interface: RedisSetCommands
    
    Union all sets at given keys and store result in destKey.
    
    Specified by:
    
    sUnionStore in interface RedisSetCommands
    
    Parameters:
    
    destKey - must not be null.
    
    keys - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: SUNIONSTORE
  - ttl
```
public Long ttl(byte[] key)
```
    Description copied from interface: RedisKeyCommands
    
    Get the time to live for key in seconds.
    
    Specified by:
    
    ttl in interface RedisKeyCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: TTL
  - ttl
```
public Long ttl(byte[] key,
                TimeUnit timeUnit)
```
    Description copied from interface: RedisKeyCommands
    
    Get the time to live for key in and convert it to the given TimeUnit.
    
    Specified by:
    
    ttl in interface RedisKeyCommands
    
    Parameters:
    
    key - must not be null.
    
    timeUnit - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: TTL
  - type
```
public DataType type(byte[] key)
```
    Description copied from interface: RedisKeyCommands
    
    Determine the type stored at key.
    
    Specified by:
    
    type in interface RedisKeyCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: TYPE
  - touch
```
public Long touch(byte[]... keys)
```
    Description copied from interface: RedisKeyCommands
    
    Alter the last access time of given key(s).
    
    Specified by:
    
    touch in interface RedisKeyCommands
    
    Parameters:
    
    keys - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: TOUCH
  - unwatch
```
public void unwatch()
```
    Description copied from interface: RedisTxCommands
    
    Flushes all the previously #watch(byte[]...) keys.
    
    Specified by:
    
    unwatch in interface RedisTxCommands
    
    See Also:
    
    Redis Documentation: UNWATCH
  - watch
```
public void watch(byte[]... keys)
```
    Description copied from interface: RedisTxCommands
    
    Watch given keys for modifications during transaction started with RedisTxCommands.multi().
    
    Specified by:
    
    watch in interface RedisTxCommands
    
    Parameters:
    
    keys - must not be null.
    
    See Also:
    
    Redis Documentation: WATCH
  - zAdd
```
public Boolean zAdd(byte[] key,
                    double score,
                    byte[] value,
                    RedisZSetCommands.ZAddArgs args)
```
    Description copied from interface: RedisZSetCommands
    
    Add value to a sorted set at key, or update its score depending on the given args.
    
    Specified by:
    
    zAdd in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    score - the score.
    
    value - the value.
    
    args - must not be null use RedisZSetCommands.ZAddArgs.empty() instead.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZADD
  - zAdd
```
public Long zAdd(byte[] key,
                 Set<RedisZSetCommands.Tuple> tuples,
                 RedisZSetCommands.ZAddArgs args)
```
    Description copied from interface: RedisZSetCommands
    
    Add tuples to a sorted set at key, or update its score depending on the given args.
    
    Specified by:
    
    zAdd in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    tuples - must not be null.
    
    args - must not be null use RedisZSetCommands.ZAddArgs.empty() instead.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZADD
  - zCard
```
public Long zCard(byte[] key)
```
    Description copied from interface: RedisZSetCommands
    
    Get the size of sorted set with key.
    
    Specified by:
    
    zCard in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZCARD
  - zCount
```
public Long zCount(byte[] key,
                   double min,
                   double max)
```
    Description copied from interface: RedisZSetCommands
    
    Count number of elements within sorted set with scores between min and max.
    
    Specified by:
    
    zCount in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZCOUNT
  - zCount
```
public Long zCount(byte[] key,
                   RedisZSetCommands.Range range)
```
    Description copied from interface: RedisZSetCommands
    
    Count number of elements within sorted set with scores between Range#min and Range#max.
    
    Specified by:
    
    zCount in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    range - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZCOUNT
  - zIncrBy
```
public Double zIncrBy(byte[] key,
                      double increment,
                      byte[] value)
```
    Description copied from interface: RedisZSetCommands
    
    Increment the score of element with value in sorted set by increment.
    
    Specified by:
    
    zIncrBy in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    value - the value.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZINCRBY
  - zDiff
```
@Nullable
public Set<byte[]> zDiff(byte[]... sets)
```
    Description copied from interface: RedisZSetCommands
    
    Diff sorted sets.
    
    Specified by:
    
    zDiff in interface RedisZSetCommands
    
    Parameters:
    
    sets - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZDIFF
  - zDiffWithScores
```
@Nullable
public Set<RedisZSetCommands.Tuple> zDiffWithScores(byte[]... sets)
```
    Description copied from interface: RedisZSetCommands
    
    Diff sorted sets.
    
    Specified by:
    
    zDiffWithScores in interface RedisZSetCommands
    
    Parameters:
    
    sets - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZDIFF
  - zDiffStore
```
@Nullable
public Long zDiffStore(byte[] destKey,
                                 byte[]... sets)
```
    Description copied from interface: RedisZSetCommands
    
    Diff sorted sets and store result in destination destKey.
    
    Specified by:
    
    zDiffStore in interface RedisZSetCommands
    
    Parameters:
    
    destKey - must not be null.
    
    sets - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZDIFFSTORE
  - zDiff
```
@Nullable
public Set<String> zDiff(String... sets)
```
    Description copied from interface: StringRedisConnection
    
    Diff sorted sets.
    
    Specified by:
    
    zDiff in interface StringRedisConnection
    
    Parameters:
    
    sets - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZDIFF
  - zDiffWithScores
```
@Nullable
public Set<StringRedisConnection.StringTuple> zDiffWithScores(String... sets)
```
    Description copied from interface: StringRedisConnection
    
    Diff sorted sets.
    
    Specified by:
    
    zDiffWithScores in interface StringRedisConnection
    
    Parameters:
    
    sets - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZDIFF
  - zDiffStore
```
@Nullable
public Long zDiffStore(String destKey,
                                 String... sets)
```
    Description copied from interface: StringRedisConnection
    
    Diff sorted sets and store result in destination destKey.
    
    Specified by:
    
    zDiffStore in interface StringRedisConnection
    
    Parameters:
    
    destKey - must not be null.
    
    sets - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZDIFFSTORE
  - zInter
```
@Nullable
public Set<byte[]> zInter(byte[]... sets)
```
    Description copied from interface: RedisZSetCommands
    
    Intersect sorted sets.
    
    Specified by:
    
    zInter in interface RedisZSetCommands
    
    Parameters:
    
    sets - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZINTER
  - zInterWithScores
```
@Nullable
public Set<RedisZSetCommands.Tuple> zInterWithScores(byte[]... sets)
```
    Description copied from interface: RedisZSetCommands
    
    Intersect sorted sets.
    
    Specified by:
    
    zInterWithScores in interface RedisZSetCommands
    
    Parameters:
    
    sets - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZINTER
  - zInterWithScores
```
@Nullable
public Set<RedisZSetCommands.Tuple> zInterWithScores(RedisZSetCommands.Aggregate aggregate,
                                                               RedisZSetCommands.Weights weights,
                                                               byte[]... sets)
```
    Description copied from interface: RedisZSetCommands
    
    Intersect sorted sets.
    
    Specified by:
    
    zInterWithScores in interface RedisZSetCommands
    
    Parameters:
    
    aggregate - must not be null.
    
    weights - must not be null.
    
    sets - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZINTER
  - zInter
```
@Nullable
public Set<String> zInter(String... sets)
```
    Description copied from interface: StringRedisConnection
    
    Intersect sorted sets.
    
    Specified by:
    
    zInter in interface StringRedisConnection
    
    Parameters:
    
    sets - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZINTER
  - zInterWithScores
```
@Nullable
public Set<StringRedisConnection.StringTuple> zInterWithScores(String... sets)
```
    Description copied from interface: StringRedisConnection
    
    Intersect sorted sets.
    
    Specified by:
    
    zInterWithScores in interface StringRedisConnection
    
    Parameters:
    
    sets - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZINTER
  - zInterWithScores
```
@Nullable
public Set<StringRedisConnection.StringTuple> zInterWithScores(RedisZSetCommands.Aggregate aggregate,
                                                                         RedisZSetCommands.Weights weights,
                                                                         String... sets)
```
    Description copied from interface: StringRedisConnection
    
    Intersect sorted sets.
    
    Specified by:
    
    zInterWithScores in interface StringRedisConnection
    
    Parameters:
    
    aggregate - must not be null.
    
    weights - must not be null.
    
    sets - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZINTER
  - zInterStore
```
public Long zInterStore(byte[] destKey,
                        RedisZSetCommands.Aggregate aggregate,
                        RedisZSetCommands.Weights weights,
                        byte[]... sets)
```
    Description copied from interface: RedisZSetCommands
    
    Intersect sorted sets and store result in destination destKey.
    
    Specified by:
    
    zInterStore in interface RedisZSetCommands
    
    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: ZINTERSTORE
  - zInterStore
```
public Long zInterStore(byte[] destKey,
                        byte[]... sets)
```
    Description copied from interface: RedisZSetCommands
    
    Intersect sorted sets and store result in destination destKey.
    
    Specified by:
    
    zInterStore in interface RedisZSetCommands
    
    Parameters:
    
    destKey - must not be null.
    
    sets - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZINTERSTORE
  - zRange
```
public Set<byte[]> zRange(byte[] key,
                          long start,
                          long end)
```
    Description copied from interface: RedisZSetCommands
    
    Get elements between start and end from sorted set.
    
    Specified by:
    
    zRange in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    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
```
public Set<byte[]> zRangeByScore(byte[] key,
                                 double min,
                                 double max,
                                 long offset,
                                 long count)
```
    Description copied from interface: RedisZSetCommands
    
    Get elements in range from start to end where score is between min and max from sorted set.
    
    Specified by:
    
    zRangeByScore in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    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
```
public Set<byte[]> zRangeByScore(byte[] key,
                                 RedisZSetCommands.Range range)
```
    Description copied from interface: RedisZSetCommands
    
    Get elements where score is between Range#min and Range#max from sorted set.
    
    Specified by:
    
    zRangeByScore in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    range - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZRANGEBYSCORE
  - zRangeByScore
```
public Set<byte[]> zRangeByScore(byte[] key,
                                 RedisZSetCommands.Range range,
                                 RedisZSetCommands.Limit limit)
```
    Description copied from interface: RedisZSetCommands
    
    Get elements in range from Limit#count to Limit#offset where score is between Range#min and Range#max from sorted set.
    
    Specified by:
    
    zRangeByScore in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    range - must not be null.
    
    limit - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZRANGEBYSCORE
  - zRangeByScoreWithScores
```
public Set<RedisZSetCommands.Tuple> zRangeByScoreWithScores(byte[] key,
                                                            RedisZSetCommands.Range range)
```
    Description copied from interface: RedisZSetCommands
    
    Get set of RedisZSetCommands.Tuples where score is between Range#min and Range#max from sorted set.
    
    Specified by:
    
    zRangeByScoreWithScores in interface RedisZSetCommands
    
    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.
    
    See Also:
    
    Redis Documentation: ZRANGEBYSCORE
  - zRangeByScore
```
public Set<byte[]> zRangeByScore(byte[] key,
                                 double min,
                                 double max)
```
    Description copied from interface: RedisZSetCommands
    
    Get elements where score is between min and max from sorted set.
    
    Specified by:
    
    zRangeByScore in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    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
```
public Set<RedisZSetCommands.Tuple> zRangeByScoreWithScores(byte[] key,
                                                            double min,
                                                            double max,
                                                            long offset,
                                                            long count)
```
    Description copied from interface: RedisZSetCommands
    
    Get set of RedisZSetCommands.Tuples in range from start to end where score is between min and max from sorted set.
    
    Specified by:
    
    zRangeByScoreWithScores in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    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
```
public Set<RedisZSetCommands.Tuple> zRangeByScoreWithScores(byte[] key,
                                                            RedisZSetCommands.Range range,
                                                            RedisZSetCommands.Limit limit)
```
    Description copied from interface: RedisZSetCommands
    
    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.
    
    Specified by:
    
    zRangeByScoreWithScores in interface RedisZSetCommands
    
    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.
    
    See Also:
    
    Redis Documentation: ZRANGEBYSCORE
  - zRangeByScoreWithScores
```
public Set<RedisZSetCommands.Tuple> zRangeByScoreWithScores(byte[] key,
                                                            double min,
                                                            double max)
```
    Description copied from interface: RedisZSetCommands
    
    Get set of RedisZSetCommands.Tuples where score is between min and max from sorted set.
    
    Specified by:
    
    zRangeByScoreWithScores in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    empty Set when key does not exists or no members in range. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZRANGEBYSCORE
  - zRangeWithScores
```
public Set<RedisZSetCommands.Tuple> zRangeWithScores(byte[] key,
                                                     long start,
                                                     long end)
```
    Description copied from interface: RedisZSetCommands
    
    Get set of RedisZSetCommands.Tuples between start and end from sorted set.
    
    Specified by:
    
    zRangeWithScores in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    empty Set when key does not exists or no members in range. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZRANGE
  - zRevRangeByScore
```
public Set<byte[]> zRevRangeByScore(byte[] key,
                                    double min,
                                    double max,
                                    long offset,
                                    long count)
```
    Description copied from interface: RedisZSetCommands
    
    Get elements in range from start to end where score is between min and max from sorted set ordered high -> low.
    
    Specified by:
    
    zRevRangeByScore in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZREVRANGEBYSCORE
  - zRevRangeByScore
```
public Set<byte[]> zRevRangeByScore(byte[] key,
                                    RedisZSetCommands.Range range)
```
    Description copied from interface: RedisZSetCommands
    
    Get elements where score is between Range#min and Range#max from sorted set ordered from high to low.
    
    Specified by:
    
    zRevRangeByScore in interface RedisZSetCommands
    
    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.
    
    See Also:
    
    Redis Documentation: ZREVRANGEBYSCORE
  - zRevRangeByScore
```
public Set<byte[]> zRevRangeByScore(byte[] key,
                                    double min,
                                    double max)
```
    Description copied from interface: RedisZSetCommands
    
    Get elements where score is between min and max from sorted set ordered from high to low.
    
    Specified by:
    
    zRevRangeByScore in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    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
```
public Set<byte[]> zRevRangeByScore(byte[] key,
                                    RedisZSetCommands.Range range,
                                    RedisZSetCommands.Limit limit)
```
    Description copied from interface: RedisZSetCommands
    
    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.
    
    Specified by:
    
    zRevRangeByScore in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    range - must not be null.
    
    limit - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZREVRANGEBYSCORE
  - zRevRangeByScoreWithScores
```
public Set<RedisZSetCommands.Tuple> zRevRangeByScoreWithScores(byte[] key,
                                                               double min,
                                                               double max,
                                                               long offset,
                                                               long count)
```
    Description copied from interface: RedisZSetCommands
    
    Get set of RedisZSetCommands.Tuple in range from start to end where score is between min and max from sorted set ordered high -> low.
    
    Specified by:
    
    zRevRangeByScoreWithScores in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZREVRANGEBYSCORE
  - zRevRangeByScoreWithScores
```
public Set<RedisZSetCommands.Tuple> zRevRangeByScoreWithScores(byte[] key,
                                                               RedisZSetCommands.Range range)
```
    Description copied from interface: RedisZSetCommands
    
    Get set of RedisZSetCommands.Tuple where score is between Range#min and Range#max from sorted set ordered from high to low.
    
    Specified by:
    
    zRevRangeByScoreWithScores in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    range - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZREVRANGEBYSCORE
  - zRevRangeByScoreWithScores
```
public Set<RedisZSetCommands.Tuple> zRevRangeByScoreWithScores(byte[] key,
                                                               RedisZSetCommands.Range range,
                                                               RedisZSetCommands.Limit limit)
```
    Description copied from interface: RedisZSetCommands
    
    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.
    
    Specified by:
    
    zRevRangeByScoreWithScores in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    range - must not be null.
    
    limit - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZREVRANGEBYSCORE
  - zRevRangeByScoreWithScores
```
public Set<RedisZSetCommands.Tuple> zRevRangeByScoreWithScores(byte[] key,
                                                               double min,
                                                               double max)
```
    Description copied from interface: RedisZSetCommands
    
    Get set of RedisZSetCommands.Tuple where score is between min and max from sorted set ordered from high to low.
    
    Specified by:
    
    zRevRangeByScoreWithScores in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    empty Set when key does not exists or no members in range. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZREVRANGEBYSCORE
  - zRank
```
public Long zRank(byte[] key,
                  byte[] value)
```
    Description copied from interface: RedisZSetCommands
    
    Determine the index of element with value in a sorted set.
    
    Specified by:
    
    zRank in interface RedisZSetCommands
    
    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
  - zRem
```
public Long zRem(byte[] key,
                 byte[]... values)
```
    Description copied from interface: RedisZSetCommands
    
    Remove values from sorted set. Return number of removed elements.
    
    Specified by:
    
    zRem in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    values - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZREM
  - zRemRange
```
public Long zRemRange(byte[] key,
                      long start,
                      long end)
```
    Description copied from interface: RedisZSetCommands
    
    Remove elements in range between start and end from sorted set with key.
    
    Specified by:
    
    zRemRange in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZREMRANGEBYRANK
  - zRemRangeByLex
```
public Long zRemRangeByLex(byte[] key,
                           RedisZSetCommands.Range range)
```
    Description copied from interface: RedisZSetCommands
    
    Remove all elements between the lexicographical RedisZSetCommands.Range.
    
    Specified by:
    
    zRemRangeByLex in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    range - must not be null.
    
    Returns:
    
    the number of elements removed, or null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZREMRANGEBYLEX
  - zRemRangeByScore
```
public Long zRemRangeByScore(byte[] key,
                             double min,
                             double max)
```
    Description copied from interface: RedisZSetCommands
    
    Remove elements with scores between min and max from sorted set with key.
    
    Specified by:
    
    zRemRangeByScore in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZREMRANGEBYSCORE
  - zRemRangeByScore
```
public Long zRemRangeByScore(byte[] key,
                             RedisZSetCommands.Range range)
```
    Description copied from interface: RedisZSetCommands
    
    Remove elements with scores between Range#min and Range#max from sorted set with key.
    
    Specified by:
    
    zRemRangeByScore in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    range - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZREMRANGEBYSCORE
  - zRevRange
```
public Set<byte[]> zRevRange(byte[] key,
                             long start,
                             long end)
```
    Description copied from interface: RedisZSetCommands
    
    Get elements in range from start to end from sorted set ordered from high to low.
    
    Specified by:
    
    zRevRange in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    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
```
public Set<RedisZSetCommands.Tuple> zRevRangeWithScores(byte[] key,
                                                        long start,
                                                        long end)
```
    Description copied from interface: RedisZSetCommands
    
    Get set of RedisZSetCommands.Tuples in range from start to end from sorted set ordered from high to low.
    
    Specified by:
    
    zRevRangeWithScores in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    empty Set when key does not exists or no members in range. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZREVRANGE
  - zRevRank
```
public Long zRevRank(byte[] key,
                     byte[] value)
```
    Description copied from interface: RedisZSetCommands
    
    Determine the index of element with value in a sorted set when scored high to low.
    
    Specified by:
    
    zRevRank in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    value - the value.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZREVRANK
  - zScore
```
public Double zScore(byte[] key,
                     byte[] value)
```
    Description copied from interface: RedisZSetCommands
    
    Get the score of element with value from sorted set with key key.
    
    Specified by:
    
    zScore in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    value - the value.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZSCORE
  - zMScore
```
public List<Double> zMScore(byte[] key,
                            byte[]... values)
```
    Description copied from interface: RedisZSetCommands
    
    Get the scores of elements with values from sorted set with key key.
    
    Specified by:
    
    zMScore in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    values - the values.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZMSCORE
  - zUnion
```
@Nullable
public Set<byte[]> zUnion(byte[]... sets)
```
    Description copied from interface: RedisZSetCommands
    
    Union sorted sets.
    
    Specified by:
    
    zUnion in interface RedisZSetCommands
    
    Parameters:
    
    sets - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZUNION
  - zUnionWithScores
```
@Nullable
public Set<RedisZSetCommands.Tuple> zUnionWithScores(byte[]... sets)
```
    Description copied from interface: RedisZSetCommands
    
    Union sorted sets.
    
    Specified by:
    
    zUnionWithScores in interface RedisZSetCommands
    
    Parameters:
    
    sets - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZUNION
  - zUnionWithScores
```
@Nullable
public Set<RedisZSetCommands.Tuple> zUnionWithScores(RedisZSetCommands.Aggregate aggregate,
                                                               RedisZSetCommands.Weights weights,
                                                               byte[]... sets)
```
    Description copied from interface: RedisZSetCommands
    
    Union sorted sets.
    
    Specified by:
    
    zUnionWithScores in interface RedisZSetCommands
    
    Parameters:
    
    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: ZUNION
  - zUnion
```
@Nullable
public Set<String> zUnion(String... sets)
```
    Description copied from interface: StringRedisConnection
    
    Union sorted sets.
    
    Specified by:
    
    zUnion in interface StringRedisConnection
    
    Parameters:
    
    sets - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZUNION
  - zUnionWithScores
```
@Nullable
public Set<StringRedisConnection.StringTuple> zUnionWithScores(String... sets)
```
    Description copied from interface: StringRedisConnection
    
    Union sorted sets.
    
    Specified by:
    
    zUnionWithScores in interface StringRedisConnection
    
    Parameters:
    
    sets - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZUNION
  - zUnionWithScores
```
@Nullable
public Set<StringRedisConnection.StringTuple> zUnionWithScores(RedisZSetCommands.Aggregate aggregate,
                                                                         RedisZSetCommands.Weights weights,
                                                                         String... sets)
```
    Description copied from interface: StringRedisConnection
    
    Union sorted sets.
    
    Specified by:
    
    zUnionWithScores in interface StringRedisConnection
    
    Parameters:
    
    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: ZUNION
  - zUnionStore
```
public Long zUnionStore(byte[] destKey,
                        RedisZSetCommands.Aggregate aggregate,
                        RedisZSetCommands.Weights weights,
                        byte[]... sets)
```
    Description copied from interface: RedisZSetCommands
    
    Union sorted sets and store result in destination destKey.
    
    Specified by:
    
    zUnionStore in interface RedisZSetCommands
    
    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
```
public Long zUnionStore(byte[] destKey,
                        byte[]... sets)
```
    Description copied from interface: RedisZSetCommands
    
    Union sorted sets.
    
    Specified by:
    
    zUnionStore in interface RedisZSetCommands
    
    sets - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZUNIONSTORE
  - zLexCount
```
public Long zLexCount(String key,
                      RedisZSetCommands.Range range)
```
    Description copied from interface: StringRedisConnection
    
    Count number of elements within sorted set with value between Range#min and Range#max applying lexicographical ordering.
    
    Specified by:
    
    zLexCount in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    range - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZLEXCOUNT, RedisZSetCommands.zLexCount(byte[], Range)
  - pExpire
```
public Boolean pExpire(byte[] key,
                       long millis)
```
    Description copied from interface: RedisKeyCommands
    
    Set time to live for given key in milliseconds.
    
    Specified by:
    
    pExpire in interface RedisKeyCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: PEXPIRE
  - pExpireAt
```
public Boolean pExpireAt(byte[] key,
                         long unixTimeInMillis)
```
    Description copied from interface: RedisKeyCommands
    
    Set the expiration for given key as a UNIX timestamp in milliseconds.
    
    Specified by:
    
    pExpireAt in interface RedisKeyCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: PEXPIREAT
  - pTtl
```
public Long pTtl(byte[] key)
```
    Description copied from interface: RedisKeyCommands
    
    Get the precise time to live for key in milliseconds.
    
    Specified by:
    
    pTtl in interface RedisKeyCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: PTTL
  - pTtl
```
public Long pTtl(byte[] key,
                 TimeUnit timeUnit)
```
    Description copied from interface: RedisKeyCommands
    
    Get the precise time to live for key in and convert it to the given TimeUnit.
    
    Specified by:
    
    pTtl in interface RedisKeyCommands
    
    Parameters:
    
    key - must not be null.
    
    timeUnit - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: PTTL
  - dump
```
public byte[] dump(byte[] key)
```
    Description copied from interface: RedisKeyCommands
    
    Retrieve serialized version of the value stored at key.
    
    Specified by:
    
    dump in interface RedisKeyCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null if key does not exist or when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: DUMP
  - restore
```
public void restore(byte[] key,
                    long ttlInMillis,
                    byte[] serializedValue,
                    boolean replace)
```
    Description copied from interface: RedisKeyCommands
    
    Create key using the serializedValue, previously obtained using RedisKeyCommands.dump(byte[]).
    
    Specified by:
    
    restore in interface RedisKeyCommands
    
    Parameters:
    
    key - must not be null.
    
    serializedValue - must not be null.
    
    replace - use true to replace a potentially existing value instead of erroring.
    
    See Also:
    
    Redis Documentation: RESTORE
  - scriptFlush
```
public void scriptFlush()
```
    Description copied from interface: RedisScriptingCommands
    
    Flush lua script cache.
    
    Specified by:
    
    scriptFlush in interface RedisScriptingCommands
    
    See Also:
    
    Redis Documentation: SCRIPT FLUSH
  - scriptKill
```
public void scriptKill()
```
    Description copied from interface: RedisScriptingCommands
    
    Kill current lua script execution.
    
    Specified by:
    
    scriptKill in interface RedisScriptingCommands
    
    See Also:
    
    Redis Documentation: SCRIPT KILL
  - scriptLoad
```
public String scriptLoad(byte[] script)
```
    Description copied from interface: RedisScriptingCommands
    
    Load lua script into scripts cache, without executing it.
    Execute the script by calling #evalSha(byte[], ReturnType, int, byte[]...).
    
    Specified by:
    
    scriptLoad in interface RedisScriptingCommands
    
    Parameters:
    
    script - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: SCRIPT LOAD
  - scriptExists
```
public List<Boolean> scriptExists(String... scriptSha1)
```
    Description copied from interface: RedisScriptingCommands
    
    Check if given scriptShas exist in script cache.
    
    Specified by:
    
    scriptExists in interface RedisScriptingCommands
    
    Returns:
    
    one entry per given scriptSha in returned List or null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: SCRIPT EXISTS
  - eval
```
public <T> T eval(byte[] script,
                  ReturnType returnType,
                  int numKeys,
                  byte[]... keysAndArgs)
```
    Description copied from interface: RedisScriptingCommands
    
    Evaluate given script.
    
    Specified by:
    
    eval in interface RedisScriptingCommands
    
    Parameters:
    
    script - must not be null.
    
    returnType - must not be null.
    
    keysAndArgs - must not be null.
    
    Returns:
    
    script result. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: EVAL
  - evalSha
```
public <T> T evalSha(String scriptSha1,
                     ReturnType returnType,
                     int numKeys,
                     byte[]... keysAndArgs)
```
    Description copied from interface: RedisScriptingCommands
    
    Evaluate given scriptSha.
    
    Specified by:
    
    evalSha in interface RedisScriptingCommands
    
    Parameters:
    
    scriptSha1 - must not be null.
    
    returnType - must not be null.
    
    keysAndArgs - must not be null.
    
    Returns:
    
    script result. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: EVALSHA
  - evalSha
```
public <T> T evalSha(byte[] scriptSha1,
                     ReturnType returnType,
                     int numKeys,
                     byte[]... keysAndArgs)
```
    Description copied from interface: RedisScriptingCommands
    
    Evaluate given scriptSha.
    
    Specified by:
    
    evalSha in interface RedisScriptingCommands
    
    Parameters:
    
    scriptSha1 - must not be null.
    
    returnType - must not be null.
    
    keysAndArgs - must not be null.
    
    Returns:
    
    script result. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: EVALSHA
  - append
```
public Long append(String key,
                   String value)
```
    Description copied from interface: StringRedisConnection
    
    Append a value to key.
    
    Specified by:
    
    append in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: APPEND, RedisStringCommands.append(byte[], byte[])
  - bLPop
```
public List<String> bLPop(int timeout,
                          String... keys)
```
    Description copied from interface: StringRedisConnection
    
    Removes and returns first element from lists stored at keys (see: RedisListCommands.lPop(byte[])).
    Blocks connection until element available or timeout reached.
    
    Specified by:
    
    bLPop in interface StringRedisConnection
    
    keys - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: BLPOP, RedisListCommands#bLPop(int, byte[]...)
  - bRPop
```
public List<String> bRPop(int timeout,
                          String... keys)
```
    Description copied from interface: StringRedisConnection
    
    Removes and returns last element from lists stored at keys (see: RedisListCommands.rPop(byte[])).
    Blocks connection until element available or timeout reached.
    
    Specified by:
    
    bRPop in interface StringRedisConnection
    
    keys - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: BRPOP, RedisListCommands#bRPop(int, byte[]...)
  - bRPopLPush
```
public String bRPopLPush(int timeout,
                         String srcKey,
                         String dstKey)
```
    Description copied from interface: StringRedisConnection
    
    Remove the last element from list at srcKey, append it to dstKey and return its value (see RedisListCommands.rPopLPush(byte[], byte[])).
    Blocks connection until element available or timeout reached.
    
    Specified by:
    
    bRPopLPush in interface StringRedisConnection
    
    srcKey - must not be null.
    
    dstKey - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: BRPOPLPUSH, RedisListCommands.bRPopLPush(int, byte[], byte[])
  - copy
```
public Boolean copy(String sourceKey,
                    String targetKey,
                    boolean replace)
```
    Description copied from interface: StringRedisConnection
    
    Copy given sourceKey to targetKey.
    
    Specified by:
    
    copy in interface StringRedisConnection
    
    Parameters:
    
    sourceKey - must not be null.
    
    targetKey - must not be null.
    
    replace - whether to replace existing keys.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: COPY, RedisKeyCommands.copy(byte[], byte[], boolean)
  - decr
```
public Long decr(String key)
```
    Description copied from interface: StringRedisConnection
    
    Decrement an integer value stored as string value of key by 1.
    
    Specified by:
    
    decr in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: DECR, RedisStringCommands.decr(byte[])
  - decrBy
```
public Long decrBy(String key,
                   long value)
```
    Description copied from interface: StringRedisConnection
    
    Decrement an integer value stored as string value of key by value.
    
    Specified by:
    
    decrBy in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: DECRBY, RedisStringCommands.decrBy(byte[], long)
  - del
```
public Long del(String... keys)
```
    Description copied from interface: StringRedisConnection
    
    Delete given keys.
    
    Specified by:
    
    del in interface StringRedisConnection
    
    Parameters:
    
    keys - must not be null.
    
    Returns:
    
    The number of keys that were removed.
    
    See Also:
    
    Redis Documentation: DEL, RedisKeyCommands#del(byte[]...)
  - unlink
```
public Long unlink(String... keys)
```
    Description copied from interface: StringRedisConnection
    
    Unlink the keys from the keyspace. Unlike with StringRedisConnection.del(String...) the actual memory reclaiming here happens asynchronously.
    
    Specified by:
    
    unlink in interface StringRedisConnection
    
    Parameters:
    
    keys - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: UNLINK
  - echo
```
public String echo(String message)
```
    Description copied from interface: StringRedisConnection
    
    Returns message via server roundtrip.
    
    Specified by:
    
    echo in interface StringRedisConnection
    
    Parameters:
    
    message - the message to echo.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ECHO, RedisConnectionCommands.echo(byte[])
  - exists
```
public Boolean exists(String key)
```
    Description copied from interface: StringRedisConnection
    
    Determine if given key exists.
    
    Specified by:
    
    exists in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: EXISTS, RedisKeyCommands.exists(byte[])
  - expire
```
public Boolean expire(String key,
                      long seconds)
```
    Description copied from interface: StringRedisConnection
    
    Set time to live for given key in seconds.
    
    Specified by:
    
    expire in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: EXPIRE, RedisKeyCommands.expire(byte[], long)
  - expireAt
```
public Boolean expireAt(String key,
                        long unixTime)
```
    Description copied from interface: StringRedisConnection
    
    Set the expiration for given key as a UNIX timestamp.
    
    Specified by:
    
    expireAt in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: EXPIREAT, RedisKeyCommands.expireAt(byte[], long)
  - get
```
public String get(String key)
```
    Description copied from interface: StringRedisConnection
    
    Get the value of key.
    
    Specified by:
    
    get in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: GET, RedisStringCommands.get(byte[])
  - getBit
```
public Boolean getBit(String key,
                      long offset)
```
    Description copied from interface: StringRedisConnection
    
    Get the bit value at offset of value at key.
    
    Specified by:
    
    getBit in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: GETBIT, RedisStringCommands.getBit(byte[], long)
  - getRange
```
public String getRange(String key,
                       long start,
                       long end)
```
    Description copied from interface: StringRedisConnection
    
    Get a substring of value of key between start and end.
    
    Specified by:
    
    getRange in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: GETRANGE, RedisStringCommands.getRange(byte[], long, long)
  - getSet
```
public String getSet(String key,
                     String value)
```
    Description copied from interface: StringRedisConnection
    
    Set value of key and return its old value.
    
    Specified by:
    
    getSet in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: GETSET, RedisStringCommands.getSet(byte[], byte[])
  - hDel
```
public Long hDel(String key,
                 String... fields)
```
    Description copied from interface: StringRedisConnection
    
    Delete given hash fields.
    
    Specified by:
    
    hDel in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    fields - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: HDEL, RedisHashCommands#hDel(byte[], byte[]...)
  - hExists
```
public Boolean hExists(String key,
                       String field)
```
    Description copied from interface: StringRedisConnection
    
    Determine if given hash field exists.
    
    Specified by:
    
    hExists in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    field - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: HEXISTS, RedisHashCommands.hExists(byte[], byte[])
  - hGet
```
public String hGet(String key,
                   String field)
```
    Description copied from interface: StringRedisConnection
    
    Get value for given field from hash at key.
    
    Specified by:
    
    hGet in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    field - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: HGET, RedisHashCommands.hGet(byte[], byte[])
  - hGetAll
```
public Map<String,String> hGetAll(String key)
```
    Description copied from interface: StringRedisConnection
    
    Get entire hash stored at key.
    
    Specified by:
    
    hGetAll in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: HGETALL, RedisHashCommands.hGetAll(byte[])
  - hIncrBy
```
public Long hIncrBy(String key,
                    String field,
                    long delta)
```
    Description copied from interface: StringRedisConnection
    
    Increment value of a hash field by the given delta.
    
    Specified by:
    
    hIncrBy in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    field - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: HINCRBY, RedisHashCommands.hIncrBy(byte[], byte[], long)
  - hIncrBy
```
public Double hIncrBy(String key,
                      String field,
                      double delta)
```
    Description copied from interface: StringRedisConnection
    
    Increment value of a hash field by the given delta.
    
    Specified by:
    
    hIncrBy in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: HINCRBYFLOAT, RedisHashCommands.hIncrBy(byte[], byte[], double)
  - hRandField
```
@Nullable
public byte[] hRandField(byte[] key)
```
    Description copied from interface: RedisHashCommands
    
    Return a random field from the hash stored at key.
    
    Specified by:
    
    hRandField in interface RedisHashCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null if key does not exist or when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: HRANDFIELD
  - hRandFieldWithValues
```
@Nullable
public Map.Entry<byte[],byte[]> hRandFieldWithValues(byte[] key)
```
    Description copied from interface: RedisHashCommands
    
    Return a random field from the hash along with its value stored at key.
    
    Specified by:
    
    hRandFieldWithValues in interface RedisHashCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null if key does not exist or when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: HRANDFIELD
  - hRandField
```
@Nullable
public List<byte[]> hRandField(byte[] key,
                                         long count)
```
    Description copied from interface: RedisHashCommands
    
    Return a random field from the hash stored at key. If the provided count argument is positive, return a list of distinct fields, capped either at count or the hash size. If count is negative, the behavior changes and the command is allowed to return the same field multiple times. In this case, the number of returned fields is the absolute value of the specified count.
    
    Specified by:
    
    hRandField in interface RedisHashCommands
    
    Parameters:
    
    key - must not be null.
    
    count - number of fields to return.
    
    Returns:
    
    null if key does not exist or when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: HRANDFIELD
  - hRandFieldWithValues
```
@Nullable
public List<Map.Entry<byte[],byte[]>> hRandFieldWithValues(byte[] key,
                                                                     long count)
```
    Description copied from interface: RedisHashCommands
    
    Return a random field from the hash along with its value stored at key. If the provided count argument is positive, return a list of distinct fields, capped either at count or the hash size. If count is negative, the behavior changes and the command is allowed to return the same field multiple times. In this case, the number of returned fields is the absolute value of the specified count.
    
    Specified by:
    
    hRandFieldWithValues in interface RedisHashCommands
    
    Parameters:
    
    key - must not be null.
    
    count - number of fields to return.
    
    Returns:
    
    null if key does not exist or when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: HRANDFIELD
  - hRandField
```
@Nullable
public String hRandField(String key)
```
    Description copied from interface: StringRedisConnection
    
    Return a random field from the hash stored at key.
    
    Specified by:
    
    hRandField in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null if key does not exist or when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: HRANDFIELD
  - hRandFieldWithValues
```
@Nullable
public Map.Entry<String,String> hRandFieldWithValues(String key)
```
    Description copied from interface: StringRedisConnection
    
    Return a random field from the hash along with its value stored at key.
    
    Specified by:
    
    hRandFieldWithValues in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null if key does not exist or when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: HRANDFIELD
  - hRandField
```
@Nullable
public List<String> hRandField(String key,
                                         long count)
```
    Description copied from interface: StringRedisConnection
    
    Return a random field from the hash stored at key. If the provided count argument is positive, return a list of distinct fields, capped either at count or the hash size. If count is negative, the behavior changes and the command is allowed to return the same field multiple times. In this case, the number of returned fields is the absolute value of the specified count.
    
    Specified by:
    
    hRandField in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    count - number of fields to return.
    
    Returns:
    
    null if key does not exist or when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: HRANDFIELD
  - hRandFieldWithValues
```
@Nullable
public List<Map.Entry<String,String>> hRandFieldWithValues(String key,
                                                                     long count)
```
    Description copied from interface: StringRedisConnection
    
    Return a random field from the hash along with its value stored at key. If the provided count argument is positive, return a list of distinct fields, capped either at count or the hash size. If count is negative, the behavior changes and the command is allowed to return the same field multiple times. In this case, the number of returned fields is the absolute value of the specified count.
    
    Specified by:
    
    hRandFieldWithValues in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    count - number of fields to return.
    
    Returns:
    
    null if key does not exist or when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: HRANDFIELD
  - hKeys
```
public Set<String> hKeys(String key)
```
    Description copied from interface: StringRedisConnection
    
    Get key set (fields) of hash at key.
    
    Specified by:
    
    hKeys in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: HKEYS?, RedisHashCommands.hKeys(byte[])
  - hLen
```
public Long hLen(String key)
```
    Description copied from interface: StringRedisConnection
    
    Get size of hash at key.
    
    Specified by:
    
    hLen in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: HLEN, RedisHashCommands.hLen(byte[])
  - hMGet
```
public List<String> hMGet(String key,
                          String... fields)
```
    Description copied from interface: StringRedisConnection
    
    Get values for given fields from hash at key.
    
    Specified by:
    
    hMGet in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    fields - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: HMGET, RedisHashCommands#hMGet(byte[], byte[]...)
  - hMSet
```
public void hMSet(String key,
                  Map<String,String> hashes)
```
    Description copied from interface: StringRedisConnection
    
    Set multiple hash fields to multiple values using data provided in hashes
    
    Specified by:
    
    hMSet in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    hashes - must not be null.
    
    See Also:
    
    Redis Documentation: HMSET, RedisHashCommands#hMGet(byte[], byte[]...)
  - hSet
```
public Boolean hSet(String key,
                    String field,
                    String value)
```
    Description copied from interface: StringRedisConnection
    
    Set the value of a hash field.
    
    Specified by:
    
    hSet in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    field - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: HSET, RedisHashCommands.hSet(byte[], byte[], byte[])
  - hSetNX
```
public Boolean hSetNX(String key,
                      String field,
                      String value)
```
    Description copied from interface: StringRedisConnection
    
    Set the value of a hash field only if field does not exist.
    
    Specified by:
    
    hSetNX in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    field - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: HSETNX, RedisHashCommands.hSetNX(byte[], byte[], byte[])
  - hVals
```
public List<String> hVals(String key)
```
    Description copied from interface: StringRedisConnection
    
    Get entry set (values) of hash at field.
    
    Specified by:
    
    hVals in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: HVALS, RedisHashCommands.hVals(byte[])
  - incr
```
public Long incr(String key)
```
    Description copied from interface: StringRedisConnection
    
    Increment an integer value stored as string value of key by 1.
    
    Specified by:
    
    incr in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: INCR, RedisStringCommands.incr(byte[])
  - incrBy
```
public Long incrBy(String key,
                   long value)
```
    Description copied from interface: StringRedisConnection
    
    Increment an integer value stored of key by delta.
    
    Specified by:
    
    incrBy in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: INCRBY, RedisStringCommands.incrBy(byte[], long)
  - incrBy
```
public Double incrBy(String key,
                     double value)
```
    Description copied from interface: StringRedisConnection
    
    Increment a floating point number value of key by delta.
    
    Specified by:
    
    incrBy in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: INCRBYFLOAT, RedisStringCommands.incrBy(byte[], double)
  - keys
```
public Collection<String> keys(String pattern)
```
    Description copied from interface: StringRedisConnection
    
    Find all keys matching the given pattern.
    
    Specified by:
    
    keys in interface StringRedisConnection
    
    Parameters:
    
    pattern - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: KEYS, RedisKeyCommands.keys(byte[])
  - lIndex
```
public String lIndex(String key,
                     long index)
```
    Description copied from interface: StringRedisConnection
    
    Get element at index form list at key.
    
    Specified by:
    
    lIndex in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: LINDEX, RedisListCommands.lIndex(byte[], long)
  - lInsert
```
public Long lInsert(String key,
                    RedisListCommands.Position where,
                    String pivot,
                    String value)
```
    Description copied from interface: StringRedisConnection
    
    Insert value Position#BEFORE or Position#AFTER existing pivot for key.
    
    Specified by:
    
    lInsert in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    where - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: LINSERT, RedisListCommands.lIndex(byte[], long)
  - lLen
```
public Long lLen(String key)
```
    Description copied from interface: StringRedisConnection
    
    Get the size of list stored at key.
    
    Specified by:
    
    lLen in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: LLEN, RedisListCommands.lLen(byte[])
  - lPop
```
public String lPop(String key)
```
    Description copied from interface: StringRedisConnection
    
    Removes and returns first element in list stored at key.
    
    Specified by:
    
    lPop in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: LPOP, RedisListCommands.lPop(byte[])
  - lPop
```
public List<String> lPop(String key,
                         long count)
```
    Description copied from interface: StringRedisConnection
    
    Removes and returns first elements in list stored at key.
    
    Specified by:
    
    lPop in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: LPOP, RedisListCommands.lPop(byte[], long)
  - lPos
```
public List<Long> lPos(String key,
                       String element,
                       @Nullable
                       Integer rank,
                       @Nullable
                       Integer count)
```
    Description copied from interface: StringRedisConnection
    
    Returns the index of matching elements inside the list stored at given key.
    Requires Redis 6.0.6 or newer.
    
    Specified by:
    
    lPos in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    element - must not be null.
    
    rank - specifies the "rank" of the first element to return, in case there are multiple matches. A rank of 1 means to return the first match, 2 to return the second match, and so forth.
    
    count - number of matches to return.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: LPOS
  - lPush
```
public Long lPush(String key,
                  String... values)
```
    Description copied from interface: StringRedisConnection
    
    Prepend values to key.
    
    Specified by:
    
    lPush in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: LPUSH, RedisListCommands#lPush(byte[], byte[]...)
  - lPushX
```
public Long lPushX(String key,
                   String value)
```
    Description copied from interface: StringRedisConnection
    
    Prepend values to key only if the list exists.
    
    Specified by:
    
    lPushX in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: LPUSHX, RedisListCommands.lPushX(byte[], byte[])
  - lRange
```
public List<String> lRange(String key,
                           long start,
                           long end)
```
    Description copied from interface: StringRedisConnection
    
    Get elements between start and end from list at key.
    
    Specified by:
    
    lRange in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: LRANGE, RedisListCommands.lRange(byte[], long, long)
  - lRem
```
public Long lRem(String key,
                 long count,
                 String value)
```
    Description copied from interface: StringRedisConnection
    
    Removes the first count occurrences of value from the list stored at key.
    
    Specified by:
    
    lRem in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: LREM, RedisListCommands.lRem(byte[], long, byte[])
  - lSet
```
public void lSet(String key,
                 long index,
                 String value)
```
    Description copied from interface: StringRedisConnection
    
    Set the value list element at index.
    
    Specified by:
    
    lSet in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    See Also:
    
    Redis Documentation: LSET, RedisListCommands.lSet(byte[], long, byte[])
  - lTrim
```
public void lTrim(String key,
                  long start,
                  long end)
```
    Description copied from interface: StringRedisConnection
    
    Trim list at key to elements between start and end.
    
    Specified by:
    
    lTrim in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    See Also:
    
    Redis Documentation: LTRIM, RedisListCommands.lTrim(byte[], long, long)
  - mGet
```
public List<String> mGet(String... keys)
```
    Description copied from interface: StringRedisConnection
    
    Get multiple keys. Values are in the order of the requested keys.
    
    Specified by:
    
    mGet in interface StringRedisConnection
    
    Parameters:
    
    keys - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: MGET, RedisStringCommands#mGet(byte[]...)
  - mSetNXString
```
public Boolean mSetNXString(Map<String,String> tuple)
```
    Description copied from interface: StringRedisConnection
    
    Set multiple keys to multiple values using key-value pairs provided in tuple only if the provided key does not exist.
    
    Specified by:
    
    mSetNXString in interface StringRedisConnection
    
    Parameters:
    
    tuple - must not be null.
    
    See Also:
    
    Redis Documentation: MSETNX, RedisStringCommands.mSetNX(Map)
  - mSetString
```
public Boolean mSetString(Map<String,String> tuple)
```
    Description copied from interface: StringRedisConnection
    
    Set multiple keys to multiple values using key-value pairs provided in tuple.
    
    Specified by:
    
    mSetString in interface StringRedisConnection
    
    Parameters:
    
    tuple - must not be null.
    
    See Also:
    
    Redis Documentation: MSET, RedisStringCommands.mSet(Map)
  - persist
```
public Boolean persist(String key)
```
    Description copied from interface: StringRedisConnection
    
    Remove the expiration from given key.
    
    Specified by:
    
    persist in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: PERSIST, RedisKeyCommands.persist(byte[])
  - move
```
public Boolean move(String key,
                    int dbIndex)
```
    Description copied from interface: StringRedisConnection
    
    Move given key to database with index.
    
    Specified by:
    
    move in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: MOVE, RedisKeyCommands.move(byte[], int)
  - pSubscribe
```
public void pSubscribe(MessageListener listener,
                       String... patterns)
```
    Description copied from interface: StringRedisConnection
    
    Subscribes the connection to all channels matching the given patterns. Once subscribed, a connection enters listening mode and can only subscribe to other channels or unsubscribe. No other commands are accepted until the connection is unsubscribed.
    Note that this operation is blocking and the current thread starts waiting for new messages immediately.
    
    Specified by:
    
    pSubscribe in interface StringRedisConnection
    
    Parameters:
    
    listener - message listener, must not be null.
    
    patterns - channel name patterns, must not be null.
    
    See Also:
    
    Redis Documentation: PSUBSCRIBE, RedisPubSubCommands#pSubscribe(MessageListener, byte[]...)
  - publish
```
public Long publish(String channel,
                    String message)
```
    Description copied from interface: StringRedisConnection
    
    Publishes the given message to the given channel.
    
    Specified by:
    
    publish in interface StringRedisConnection
    
    Parameters:
    
    channel - the channel to publish to, must not be null.
    
    message - message to publish
    
    Returns:
    
    the number of clients that received the message
    
    See Also:
    
    Redis Documentation: PUBLISH, RedisPubSubCommands.publish(byte[], byte[])
  - rename
```
public void rename(String oldKey,
                   String newKey)
```
    Description copied from interface: StringRedisConnection
    
    Rename key oldKey to newKey.
    
    Specified by:
    
    rename in interface StringRedisConnection
    
    Parameters:
    
    oldKey - must not be null.
    
    newKey - must not be null.
    
    See Also:
    
    Redis Documentation: RENAME, RedisKeyCommands.rename(byte[], byte[])
  - renameNX
```
public Boolean renameNX(String oldKey,
                        String newKey)
```
    Description copied from interface: StringRedisConnection
    
    Rename key oldKey to newKey only if newKey does not exist.
    
    Specified by:
    
    renameNX in interface StringRedisConnection
    
    newKey - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: RENAMENX, RedisKeyCommands.renameNX(byte[], byte[])
  - rPop
```
public String rPop(String key)
```
    Description copied from interface: StringRedisConnection
    
    Removes and returns last element in list stored at key.
    
    Specified by:
    
    rPop in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: RPOP, RedisListCommands.rPop(byte[])
  - rPop
```
public List<String> rPop(String key,
                         long count)
```
    Description copied from interface: StringRedisConnection
    
    Removes and returns last elements in list stored at key.
    
    Specified by:
    
    rPop in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: RPOP, RedisListCommands.rPop(byte[], long)
  - rPopLPush
```
public String rPopLPush(String srcKey,
                        String dstKey)
```
    Description copied from interface: StringRedisConnection
    
    Remove the last element from list at srcKey, append it to dstKey and return its value.
    
    Specified by:
    
    rPopLPush in interface StringRedisConnection
    
    Parameters:
    
    srcKey - must not be null.
    
    dstKey - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: RPOPLPUSH, RedisListCommands.rPopLPush(byte[], byte[])
  - rPush
```
public Long rPush(String key,
                  String... values)
```
    Description copied from interface: StringRedisConnection
    
    Append values to key.
    
    Specified by:
    
    rPush in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: RPUSH, RedisListCommands#rPush(byte[], byte[]...)
  - rPushX
```
public Long rPushX(String key,
                   String value)
```
    Description copied from interface: StringRedisConnection
    
    Append values to key only if the list exists.
    
    Specified by:
    
    rPushX in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: RPUSHX, RedisListCommands.rPushX(byte[], byte[])
  - sAdd
```
public Long sAdd(String key,
                 String... values)
```
    Description copied from interface: StringRedisConnection
    
    Add given values to set at key.
    
    Specified by:
    
    sAdd in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SADD, RedisSetCommands#sAdd(byte[], byte[]...)
  - sCard
```
public Long sCard(String key)
```
    Description copied from interface: StringRedisConnection
    
    Get size of set at key.
    
    Specified by:
    
    sCard in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SCARD, RedisSetCommands.sCard(byte[])
  - sDiff
```
public Set<String> sDiff(String... keys)
```
    Description copied from interface: StringRedisConnection
    
    Diff all sets for given keys.
    
    Specified by:
    
    sDiff in interface StringRedisConnection
    
    Parameters:
    
    keys - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SDIFF, RedisSetCommands#sDiff(byte[]...)
  - sDiffStore
```
public Long sDiffStore(String destKey,
                       String... keys)
```
    Description copied from interface: StringRedisConnection
    
    Diff all sets for given keys and store result in destKey.
    
    Specified by:
    
    sDiffStore in interface StringRedisConnection
    
    Parameters:
    
    destKey - must not be null.
    
    keys - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SDIFFSTORE, RedisSetCommands#sDiffStore(byte[], byte[]...)
  - set
```
public Boolean set(String key,
                   String value)
```
    Description copied from interface: StringRedisConnection
    
    Set value for key.
    
    Specified by:
    
    set in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    value - must not be null.
    
    See Also:
    
    Redis Documentation: SET, RedisStringCommands.set(byte[], byte[])
  - set
```
public Boolean set(String key,
                   String value,
                   Expiration expiration,
                   RedisStringCommands.SetOption option)
```
    Description copied from interface: StringRedisConnection
    
    Set value for key applying timeouts from expiration if set and inserting/updating values depending on option.
    
    Specified by:
    
    set in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    value - must not be null.
    
    expiration - can be null. Defaulted to Expiration.persistent(). Use Expiration.keepTtl() to keep the existing expiration.
    
    option - can be null. Defaulted to SetOption#UPSERT.
    
    See Also:
    
    Redis Documentation: SET, RedisStringCommands.set(byte[], byte[], Expiration, SetOption)
  - setBit
```
public Boolean setBit(String key,
                      long offset,
                      boolean value)
```
    Description copied from interface: StringRedisConnection
    
    Sets the bit at offset in value stored at key.
    
    Specified by:
    
    setBit in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    the original bit value stored at offset.
    
    See Also:
    
    Redis Documentation: SETBIT, RedisStringCommands.setBit(byte[], long, boolean)
  - setEx
```
public Boolean setEx(String key,
                     long seconds,
                     String value)
```
    Description copied from interface: StringRedisConnection
    
    Set the value and expiration in seconds for key.
    
    Specified by:
    
    setEx in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    value - must not be null.
    
    See Also:
    
    Redis Documentation: SETEX, RedisStringCommands.setEx(byte[], long, byte[])
  - pSetEx
```
public Boolean pSetEx(String key,
                      long seconds,
                      String value)
```
    Description copied from interface: StringRedisConnection
    
    Set the value and expiration in milliseconds for key.
    
    Specified by:
    
    pSetEx in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    value - must not be null.
    
    See Also:
    
    Redis Documentation: PSETEX, RedisStringCommands.pSetEx(byte[], long, byte[])
  - setNX
```
public Boolean setNX(String key,
                     String value)
```
    Description copied from interface: StringRedisConnection
    
    Set value for key, only if key does not exist.
    
    Specified by:
    
    setNX in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    value - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SETNX, RedisStringCommands.setNX(byte[], byte[])
  - setRange
```
public void setRange(String key,
                     String value,
                     long start)
```
    Description copied from interface: StringRedisConnection
    
    Overwrite parts of key starting at the specified offset with given value.
    
    Specified by:
    
    setRange in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    See Also:
    
    Redis Documentation: SETRANGE, RedisStringCommands.setRange(byte[], byte[], long)
  - sInter
```
public Set<String> sInter(String... keys)
```
    Description copied from interface: StringRedisConnection
    
    Returns the members intersecting all given sets at keys.
    
    Specified by:
    
    sInter in interface StringRedisConnection
    
    Parameters:
    
    keys - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SINTER, RedisSetCommands#sInter(byte[]...)
  - sInterStore
```
public Long sInterStore(String destKey,
                        String... keys)
```
    Description copied from interface: StringRedisConnection
    
    Intersect all given sets at keys and store result in destKey.
    
    Specified by:
    
    sInterStore in interface StringRedisConnection
    
    Parameters:
    
    destKey - must not be null.
    
    keys - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SINTERSTORE, RedisSetCommands#sInterStore(byte[], byte[]...)
  - sIsMember
```
public Boolean sIsMember(String key,
                         String value)
```
    Description copied from interface: StringRedisConnection
    
    Check if set at key contains value.
    
    Specified by:
    
    sIsMember in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SISMEMBER, RedisSetCommands.sIsMember(byte[], byte[])
  - sMIsMember
```
public List<Boolean> sMIsMember(String key,
                                String... values)
```
    Description copied from interface: StringRedisConnection
    
    Check if set at key contains one or more values.
    
    Specified by:
    
    sMIsMember in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    values - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: SMISMEMBER, RedisSetCommands#sMIsMember(byte[], byte[]...)
  - sMembers
```
public Set<String> sMembers(String key)
```
    Description copied from interface: StringRedisConnection
    
    Get all elements of set at key.
    
    Specified by:
    
    sMembers in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SMEMBERS, RedisSetCommands.sMembers(byte[])
  - sMove
```
public Boolean sMove(String srcKey,
                     String destKey,
                     String value)
```
    Description copied from interface: StringRedisConnection
    
    Move value from srcKey to destKey
    
    Specified by:
    
    sMove in interface StringRedisConnection
    
    Parameters:
    
    srcKey - must not be null.
    
    destKey - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SMOVE, RedisSetCommands.sMove(byte[], byte[], byte[])
  - sort
```
public Long sort(String key,
                 SortParameters params,
                 String storeKey)
```
    Description copied from interface: StringRedisConnection
    
    Sort the elements for key and store result in storeKey.
    
    Specified by:
    
    sort in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    params - must not be null.
    
    storeKey - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SORT
  - sort
```
public List<String> sort(String key,
                         SortParameters params)
```
    Description copied from interface: StringRedisConnection
    
    Sort the elements for key.
    
    Specified by:
    
    sort in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    params - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SORT
  - encodingOf
```
public ValueEncoding encodingOf(String key)
```
    Description copied from interface: StringRedisConnection
    
    Get the type of internal representation used for storing the value at the given key.
    
    Specified by:
    
    encodingOf in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null if key does not exist or when used in pipeline / transaction.
  - idletime
```
public Duration idletime(String key)
```
    Description copied from interface: StringRedisConnection
    
    Get the Duration since the object stored at the given key is idle.
    
    Specified by:
    
    idletime in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null if key does not exist or when used in pipeline / transaction.
  - refcount
```
public Long refcount(String key)
```
    Description copied from interface: StringRedisConnection
    
    Get the number of references of the value associated with the specified key.
    
    Specified by:
    
    refcount in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null if key does not exist or when used in pipeline / transaction.
  - sPop
```
public String sPop(String key)
```
    Description copied from interface: StringRedisConnection
    
    Remove and return a random member from set at key.
    
    Specified by:
    
    sPop in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SPOP, RedisSetCommands.sPop(byte[])
  - sPop
```
public List<String> sPop(String key,
                         long count)
```
    Description copied from interface: StringRedisConnection
    
    Remove and return count random members from set at key.
    
    Specified by:
    
    sPop in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    count - the number of random members to return.
    
    Returns:
    
    empty List if key does not exist.
    
    See Also:
    
    Redis Documentation: SPOP, RedisSetCommands.sPop(byte[], long)
  - sRandMember
```
public String sRandMember(String key)
```
    Description copied from interface: StringRedisConnection
    
    Get random element from set at key.
    
    Specified by:
    
    sRandMember in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SRANDMEMBER, RedisSetCommands.sRandMember(byte[])
  - sRandMember
```
public List<String> sRandMember(String key,
                                long count)
```
    Description copied from interface: StringRedisConnection
    
    Get count random elements from set at key.
    
    Specified by:
    
    sRandMember in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SRANDMEMBER, RedisSetCommands#sRem(byte[], byte[]...)
  - sRem
```
public Long sRem(String key,
                 String... values)
```
    Description copied from interface: StringRedisConnection
    
    Remove given values from set at key and return the number of removed elements.
    
    Specified by:
    
    sRem in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SREM, RedisSetCommands#sRem(byte[], byte[]...)
  - strLen
```
public Long strLen(String key)
```
    Description copied from interface: StringRedisConnection
    
    Get the length of the value stored at key.
    
    Specified by:
    
    strLen in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: STRLEN, RedisStringCommands.strLen(byte[])
  - bitCount
```
public Long bitCount(String key)
```
    Description copied from interface: StringRedisConnection
    
    Count the number of set bits (population counting) in value stored at key.
    
    Specified by:
    
    bitCount in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: BITCOUNT, RedisStringCommands.bitCount(byte[])
  - bitCount
```
public Long bitCount(String key,
                     long start,
                     long end)
```
    Description copied from interface: StringRedisConnection
    
    Count the number of set bits (population counting) of value stored at key between start and end.
    
    Specified by:
    
    bitCount in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: BITCOUNT, RedisStringCommands.bitCount(byte[], long, long)
  - bitOp
```
public Long bitOp(RedisStringCommands.BitOperation op,
                  String destination,
                  String... keys)
```
    Description copied from interface: StringRedisConnection
    
    Perform bitwise operations between strings.
    
    Specified by:
    
    bitOp in interface StringRedisConnection
    
    Parameters:
    
    op - must not be null.
    
    destination - must not be null.
    
    keys - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: BITOP, RedisStringCommands#bitOp(BitOperation, byte[], byte[]...)
  - bitPos
```
@Nullable
public Long bitPos(String key,
                             boolean bit,
                             Range<Long> range)
```
    Description copied from interface: StringRedisConnection
    
    Return the position of the first bit set to given bit in a string. Range start and end can contain negative values in order to index bytes starting from the end of the string, where -1 is the last byte, -2 is the penultimate.
    
    Specified by:
    
    bitPos in interface StringRedisConnection
    
    Parameters:
    
    key - the key holding the actual String.
    
    bit - the bit value to look for.
    
    range - must not be null. Use Range#unbounded() to not limit search.
    
    Returns:
    
    null when used in pipeline / transaction. The position of the first bit set to 1 or 0 according to the request.
    
    See Also:
    
    Redis Documentation: BITPOS
  - subscribe
```
public void subscribe(MessageListener listener,
                      String... channels)
```
    Description copied from interface: StringRedisConnection
    
    Subscribes the connection to the given channels. Once subscribed, a connection enters listening mode and can only subscribe to other channels or unsubscribe. No other commands are accepted until the connection is unsubscribed.
    Note that this operation is blocking and the current thread starts waiting for new messages immediately.
    
    Specified by:
    
    subscribe in interface StringRedisConnection
    
    Parameters:
    
    listener - message listener, must not be null.
    
    channels - channel names, must not be null.
    
    See Also:
    
    Redis Documentation: SUBSCRIBE, RedisPubSubCommands#subscribe(MessageListener, byte[]...)
  - sUnion
```
public Set<String> sUnion(String... keys)
```
    Description copied from interface: StringRedisConnection
    
    Union all sets at given keys.
    
    Specified by:
    
    sUnion in interface StringRedisConnection
    
    Parameters:
    
    keys - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SUNION, RedisSetCommands#sUnion(byte[]...)
  - sUnionStore
```
public Long sUnionStore(String destKey,
                        String... keys)
```
    Description copied from interface: StringRedisConnection
    
    Union all sets at given keys and store result in destKey.
    
    Specified by:
    
    sUnionStore in interface StringRedisConnection
    
    Parameters:
    
    destKey - must not be null.
    
    keys - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SUNIONSTORE, RedisSetCommands#sUnionStore(byte[], byte[]...)
  - ttl
```
public Long ttl(String key)
```
    Description copied from interface: StringRedisConnection
    
    Get the time to live for key in seconds.
    
    Specified by:
    
    ttl in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: TTL, RedisKeyCommands.ttl(byte[])
  - ttl
```
public Long ttl(String key,
                TimeUnit timeUnit)
```
    Description copied from interface: StringRedisConnection
    
    Get the time to live for key in and convert it to the given TimeUnit.
    
    Specified by:
    
    ttl in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    timeUnit - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: TTL, RedisKeyCommands.ttl(byte[], TimeUnit)
  - type
```
public DataType type(String key)
```
    Description copied from interface: StringRedisConnection
    
    Determine the type stored at key.
    
    Specified by:
    
    type in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: TYPE, RedisKeyCommands.type(byte[])
  - touch
```
@Nullable
public Long touch(String... keys)
```
    Description copied from interface: StringRedisConnection
    
    Alter the last access time of given key(s).
    
    Specified by:
    
    touch in interface StringRedisConnection
    
    Parameters:
    
    keys - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: TOUCH
  - zAdd
```
public Boolean zAdd(String key,
                    double score,
                    String value)
```
    Description copied from interface: StringRedisConnection
    
    Add value to a sorted set at key, or update its score if it already exists.
    
    Specified by:
    
    zAdd in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    score - the score.
    
    value - the value.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZADD, RedisZSetCommands.zAdd(byte[], double, byte[])
  - zAdd
```
public Boolean zAdd(String key,
                    double score,
                    String value,
                    RedisZSetCommands.ZAddArgs args)
```
    Description copied from interface: StringRedisConnection
    
    Add the value to a sorted set at key, or update its score depending on the given args.
    
    Specified by:
    
    zAdd in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    score - must not be null.
    
    value - must not be null.
    
    args - must not be null use ZAddArgs#empty() instead.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZADD, RedisZSetCommands.zAdd(byte[], double, byte[], ZAddArgs)
  - zAdd
```
public Long zAdd(String key,
                 Set<StringRedisConnection.StringTuple> tuples)
```
    Description copied from interface: StringRedisConnection
    
    Add tuples to a sorted set at key, or update its score if it already exists.
    
    Specified by:
    
    zAdd in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    tuples - the tuples.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZADD, RedisZSetCommands.zAdd(byte[], Set)
  - zAdd
```
public Long zAdd(String key,
                 Set<StringRedisConnection.StringTuple> tuples,
                 RedisZSetCommands.ZAddArgs args)
```
    Description copied from interface: StringRedisConnection
    
    Add tuples to a sorted set at key, or update its score depending on the given args.
    
    Specified by:
    
    zAdd in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    tuples - must not be null.
    
    args - must not be null use ZAddArgs#empty() instead.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZADD, RedisZSetCommands.zAdd(byte[], Set, ZAddArgs)
  - zCard
```
public Long zCard(String key)
```
    Description copied from interface: StringRedisConnection
    
    Get the size of sorted set with key.
    
    Specified by:
    
    zCard in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZCARD, RedisZSetCommands.zCard(byte[])
  - zCount
```
public Long zCount(String key,
                   double min,
                   double max)
```
    Description copied from interface: StringRedisConnection
    
    Count number of elements within sorted set with scores between min and max.
    
    Specified by:
    
    zCount in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZCOUNT, RedisZSetCommands.zCount(byte[], double, double)
  - zLexCount
```
public Long zLexCount(byte[] key,
                      RedisZSetCommands.Range range)
```
    Description copied from interface: RedisZSetCommands
    
    Count number of elements within sorted set with value between Range#min and Range#max applying lexicographical ordering.
    
    Specified by:
    
    zLexCount in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    range - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZLEXCOUNT
  - zPopMin
```
@Nullable
public RedisZSetCommands.Tuple zPopMin(byte[] key)
```
    Description copied from interface: RedisZSetCommands
    
    Remove and return the value with its score having the lowest score from sorted set at key.
    
    Specified by:
    
    zPopMin in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when the sorted set is empty or used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZPOPMIN
  - zPopMin
```
@Nullable
public StringRedisConnection.StringTuple zPopMin(String key)
```
    Description copied from interface: StringRedisConnection
    
    Remove and return the value with its score having the lowest score from sorted set at key.
    
    Specified by:
    
    zPopMin in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when the sorted set is empty or used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZPOPMIN
  - zPopMin
```
@Nullable
public Set<RedisZSetCommands.Tuple> zPopMin(byte[] key,
                                                      long count)
```
    Description copied from interface: RedisZSetCommands
    
    Remove and return count values with their score having the lowest score from sorted set at key.
    
    Specified by:
    
    zPopMin in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    count - number of elements to pop.
    
    Returns:
    
    null when the sorted set is empty or used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZPOPMIN
  - zPopMin
```
@Nullable
public Set<StringRedisConnection.StringTuple> zPopMin(String key,
                                                                long count)
```
    Description copied from interface: StringRedisConnection
    
    Remove and return count values with their score having the lowest score from sorted set at key.
    
    Specified by:
    
    zPopMin in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    count - number of elements to pop.
    
    Returns:
    
    null when the sorted set is empty or used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZPOPMIN
  - bZPopMin
```
@Nullable
public RedisZSetCommands.Tuple bZPopMin(byte[] key,
                                                  long timeout,
                                                  TimeUnit unit)
```
    Description copied from interface: RedisZSetCommands
    
    Remove and return the value with its score having the lowest score from sorted set at key.
    Blocks connection until element available or timeout reached.
    
    Specified by:
    
    bZPopMin in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    unit - must not be null.
    
    Returns:
    
    can be null.
    
    See Also:
    
    Redis Documentation: BZPOPMIN
  - bZPopMin
```
@Nullable
public StringRedisConnection.StringTuple bZPopMin(String key,
                                                            long timeout,
                                                            TimeUnit unit)
```
    Description copied from interface: StringRedisConnection
    
    Remove and return the value with its score having the lowest score from sorted set at key. Blocks connection until element available or timeout reached.
    
    Specified by:
    
    bZPopMin in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    unit - must not be null.
    
    Returns:
    
    can be null.
    
    See Also:
    
    Redis Documentation: BZPOPMIN
  - zPopMax
```
@Nullable
public RedisZSetCommands.Tuple zPopMax(byte[] key)
```
    Description copied from interface: RedisZSetCommands
    
    Remove and return the value with its score having the highest score from sorted set at key.
    
    Specified by:
    
    zPopMax in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when the sorted set is empty or used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZPOPMAX
  - zPopMax
```
@Nullable
public StringRedisConnection.StringTuple zPopMax(String key)
```
    Description copied from interface: StringRedisConnection
    
    Remove and return the value with its score having the highest score from sorted set at key.
    
    Specified by:
    
    zPopMax in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when the sorted set is empty or used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZPOPMAX
  - zPopMax
```
@Nullable
public Set<RedisZSetCommands.Tuple> zPopMax(byte[] key,
                                                      long count)
```
    Description copied from interface: RedisZSetCommands
    
    Remove and return count values with their score having the highest score from sorted set at key.
    
    Specified by:
    
    zPopMax in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    count - number of elements to pop.
    
    Returns:
    
    null when the sorted set is empty or used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZPOPMAX
  - zPopMax
```
@Nullable
public Set<StringRedisConnection.StringTuple> zPopMax(String key,
                                                                long count)
```
    Description copied from interface: StringRedisConnection
    
    Remove and return count values with their score having the highest score from sorted set at key.
    
    Specified by:
    
    zPopMax in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    count - number of elements to pop.
    
    Returns:
    
    null when the sorted set is empty or used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZPOPMAX
  - bZPopMax
```
@Nullable
public RedisZSetCommands.Tuple bZPopMax(byte[] key,
                                                  long timeout,
                                                  TimeUnit unit)
```
    Description copied from interface: RedisZSetCommands
    
    Remove and return the value with its score having the highest score from sorted set at key.
    Blocks connection until element available or timeout reached.
    
    Specified by:
    
    bZPopMax in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    unit - must not be null.
    
    Returns:
    
    can be null.
    
    See Also:
    
    Redis Documentation: BZPOPMAX
  - bZPopMax
```
@Nullable
public StringRedisConnection.StringTuple bZPopMax(String key,
                                                            long timeout,
                                                            TimeUnit unit)
```
    Description copied from interface: StringRedisConnection
    
    Remove and return the value with its score having the highest score from sorted set at key. Blocks connection until element available or timeout reached.
    
    Specified by:
    
    bZPopMax in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    unit - must not be null.
    
    Returns:
    
    can be null.
    
    See Also:
    
    Redis Documentation: BZPOPMAX
  - zIncrBy
```
public Double zIncrBy(String key,
                      double increment,
                      String value)
```
    Description copied from interface: StringRedisConnection
    
    Increment the score of element with value in sorted set by increment.
    
    Specified by:
    
    zIncrBy in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    value - the value.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZINCRBY, RedisZSetCommands.zIncrBy(byte[], double, byte[])
  - zInterStore
```
public Long zInterStore(String destKey,
                        RedisZSetCommands.Aggregate aggregate,
                        int[] weights,
                        String... sets)
```
    Description copied from interface: StringRedisConnection
    
    Intersect sorted sets and store result in destination key.
    
    Specified by:
    
    zInterStore in interface StringRedisConnection
    
    Parameters:
    
    destKey - must not be null.
    
    aggregate - must not be null.
    
    sets - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZINTERSTORE, RedisZSetCommands#zInterStore(byte[], Aggregate, int[], byte[]...)
  - zInterStore
```
public Long zInterStore(String destKey,
                        String... sets)
```
    Description copied from interface: StringRedisConnection
    
    Intersect sorted sets and store result in destination key.
    
    Specified by:
    
    zInterStore in interface StringRedisConnection
    
    Parameters:
    
    destKey - must not be null.
    
    sets - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZINTERSTORE, RedisZSetCommands#zInterStore(byte[], byte[]...)
  - zRandMember
```
public byte[] zRandMember(byte[] key)
```
    Description copied from interface: RedisZSetCommands
    
    Get random element from sorted set at key.
    
    Specified by:
    
    zRandMember in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    can be null.
    
    See Also:
    
    Redis Documentation: ZRANDMEMBER
  - zRandMember
```
public List<byte[]> zRandMember(byte[] key,
                                long count)
```
    Description copied from interface: RedisZSetCommands
    
    Get count random elements from sorted set at key.
    
    Specified by:
    
    zRandMember in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    count - if the provided count argument is positive, return a list of distinct fields, capped either at count or the set size. If count is negative, the behavior changes and the command is allowed to return the same value multiple times. In this case, the number of returned values is the absolute value of the specified count.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZRANDMEMBER
  - zRandMemberWithScore
```
public RedisZSetCommands.Tuple zRandMemberWithScore(byte[] key)
```
    Description copied from interface: RedisZSetCommands
    
    Get random element from sorted set at key.
    
    Specified by:
    
    zRandMemberWithScore in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    can be null.
    
    See Also:
    
    Redis Documentation: ZRANDMEMBER
  - zRandMemberWithScore
```
public List<RedisZSetCommands.Tuple> zRandMemberWithScore(byte[] key,
                                                          long count)
```
    Description copied from interface: RedisZSetCommands
    
    Get count random elements from sorted set at key.
    
    Specified by:
    
    zRandMemberWithScore in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    count - if the provided count argument is positive, return a list of distinct fields, capped either at count or the set size. If count is negative, the behavior changes and the command is allowed to return the same value multiple times. In this case, the number of returned values is the absolute value of the specified count.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZRANDMEMBER
  - zRandMember
```
public String zRandMember(String key)
```
    Description copied from interface: StringRedisConnection
    
    Get random element from sorted set at key.
    
    Specified by:
    
    zRandMember in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    can be null.
    
    See Also:
    
    Redis Documentation: ZRANDMEMBER
  - zRandMember
```
public List<String> zRandMember(String key,
                                long count)
```
    Description copied from interface: StringRedisConnection
    
    Get count random elements from sorted set at key.
    
    Specified by:
    
    zRandMember in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    count - if the provided count argument is positive, return a list of distinct fields, capped either at count or the set size. If count is negative, the behavior changes and the command is allowed to return the same value multiple times. In this case, the number of returned values is the absolute value of the specified count.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZRANDMEMBER
  - zRandMemberWithScore
```
public StringRedisConnection.StringTuple zRandMemberWithScore(String key)
```
    Description copied from interface: StringRedisConnection
    
    Get random element from sorted set at key.
    
    Specified by:
    
    zRandMemberWithScore in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    can be null.
    
    See Also:
    
    Redis Documentation: ZRANDMEMBER
  - zRandMemberWithScores
```
public List<StringRedisConnection.StringTuple> zRandMemberWithScores(String key,
                                                                     long count)
```
    Description copied from interface: StringRedisConnection
    
    Get count random elements from sorted set at key.
    
    Specified by:
    
    zRandMemberWithScores in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    count - if the provided count argument is positive, return a list of distinct fields, capped either at count or the set size. If count is negative, the behavior changes and the command is allowed to return the same value multiple times. In this case, the number of returned values is the absolute value of the specified count.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZRANDMEMBER
  - zRange
```
public Set<String> zRange(String key,
                          long start,
                          long end)
```
    Description copied from interface: StringRedisConnection
    
    Get elements between start and end from sorted set.
    
    Specified by:
    
    zRange in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZRANGE, RedisZSetCommands.zRange(byte[], long, long)
  - zRangeByScore
```
public Set<String> zRangeByScore(String key,
                                 double min,
                                 double max,
                                 long offset,
                                 long count)
```
    Description copied from interface: StringRedisConnection
    
    Get elements in range from start to end where score is between min and max from sorted set.
    
    Specified by:
    
    zRangeByScore in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZRANGEBYSCORE, RedisZSetCommands.zRangeByScore(byte[], double, double, long, long)
  - zRangeByScore
```
public Set<String> zRangeByScore(String key,
                                 double min,
                                 double max)
```
    Description copied from interface: StringRedisConnection
    
    Get elements where score is between min and max from sorted set.
    
    Specified by:
    
    zRangeByScore in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZRANGEBYSCORE, RedisZSetCommands.zRangeByScore(byte[], double, double)
  - zRangeByScoreWithScores
```
public Set<StringRedisConnection.StringTuple> zRangeByScoreWithScores(String key,
                                                                      double min,
                                                                      double max,
                                                                      long offset,
                                                                      long count)
```
    Description copied from interface: StringRedisConnection
    
    Get set of Tuples in range from start to end where score is between min and max from sorted set.
    
    Specified by:
    
    zRangeByScoreWithScores in interface StringRedisConnection
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZRANGEBYSCORE, RedisZSetCommands.zRangeByScoreWithScores(byte[], double, double, long, long)
  - zRangeByScoreWithScores
```
public Set<StringRedisConnection.StringTuple> zRangeByScoreWithScores(String key,
                                                                      double min,
                                                                      double max)
```
    Description copied from interface: StringRedisConnection
    
    Get set of Tuples where score is between min and max from sorted set.
    
    Specified by:
    
    zRangeByScoreWithScores in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZRANGEBYSCORE, RedisZSetCommands.zRangeByScoreWithScores(byte[], double, double)
  - zRangeWithScores
```
public Set<StringRedisConnection.StringTuple> zRangeWithScores(String key,
                                                               long start,
                                                               long end)
```
    Description copied from interface: StringRedisConnection
    
    Get set of Tuples between start and end from sorted set.
    
    Specified by:
    
    zRangeWithScores in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZRANGE, RedisZSetCommands.zRangeWithScores(byte[], long, long)
  - zRank
```
public Long zRank(String key,
                  String value)
```
    Description copied from interface: StringRedisConnection
    
    Determine the index of element with value in a sorted set.
    
    Specified by:
    
    zRank in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    value - the value.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZRANK, RedisZSetCommands.zRank(byte[], byte[])
  - zRem
```
public Long zRem(String key,
                 String... values)
```
    Description copied from interface: StringRedisConnection
    
    Remove values from sorted set. Return number of removed elements.
    
    Specified by:
    
    zRem in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    values - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZREM, RedisZSetCommands#zRem(byte[], byte[]...)
  - zRemRange
```
public Long zRemRange(String key,
                      long start,
                      long end)
```
    Description copied from interface: StringRedisConnection
    
    Remove elements in range between start and end from sorted set with key.
    
    Specified by:
    
    zRemRange in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZREMRANGEBYRANK, RedisZSetCommands.zRemRange(byte[], long, long)
  - zRemRangeByLex
```
public Long zRemRangeByLex(String key,
                           RedisZSetCommands.Range range)
```
    Description copied from interface: StringRedisConnection
    
    Remove all elements between the lexicographical Range.
    
    Specified by:
    
    zRemRangeByLex in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    range - must not be null.
    
    Returns:
    
    the number of elements removed, or null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZREMRANGEBYLEX
  - zRemRangeByScore
```
public Long zRemRangeByScore(String key,
                             double min,
                             double max)
```
    Description copied from interface: StringRedisConnection
    
    Remove elements with scores between min and max from sorted set with key.
    
    Specified by:
    
    zRemRangeByScore in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZREMRANGEBYSCORE, RedisZSetCommands.zRemRangeByScore(byte[], double, double)
  - zRevRange
```
public Set<String> zRevRange(String key,
                             long start,
                             long end)
```
    Description copied from interface: StringRedisConnection
    
    Get elements in range from start to end from sorted set ordered from high to low.
    
    Specified by:
    
    zRevRange in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZREVRANGE, RedisZSetCommands.zRevRange(byte[], long, long)
  - zRevRangeWithScores
```
public Set<StringRedisConnection.StringTuple> zRevRangeWithScores(String key,
                                                                  long start,
                                                                  long end)
```
    Description copied from interface: StringRedisConnection
    
    Get set of Tuples in range from start to end from sorted set ordered from high to low.
    
    Specified by:
    
    zRevRangeWithScores in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZREVRANGE, RedisZSetCommands.zRevRangeWithScores(byte[], long, long)
  - zRevRangeByScore
```
public Set<String> zRevRangeByScore(String key,
                                    double min,
                                    double max)
```
    Description copied from interface: StringRedisConnection
    
    Get elements where score is between min and max from sorted set ordered from high to low.
    
    Specified by:
    
    zRevRangeByScore in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZREVRANGE, RedisZSetCommands.zRevRangeByScore(byte[], double, double)
  - zRevRangeByScoreWithScores
```
public Set<StringRedisConnection.StringTuple> zRevRangeByScoreWithScores(String key,
                                                                         double min,
                                                                         double max)
```
    Description copied from interface: StringRedisConnection
    
    Get set of Tuple where score is between min and max from sorted set ordered from high to low.
    
    Specified by:
    
    zRevRangeByScoreWithScores in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZREVRANGEBYSCORE, RedisZSetCommands.zRevRangeByScoreWithScores(byte[], double, double)
  - zRevRangeByScore
```
public Set<String> zRevRangeByScore(String key,
                                    double min,
                                    double max,
                                    long offset,
                                    long count)
```
    Description copied from interface: StringRedisConnection
    
    Get elements in range from start to end where score is between min and max from sorted set ordered high -> low.
    
    Specified by:
    
    zRevRangeByScore in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZREVRANGEBYSCORE, RedisZSetCommands.zRevRangeByScore(byte[], double, double, long, long)
  - zRevRangeByScoreWithScores
```
public Set<StringRedisConnection.StringTuple> zRevRangeByScoreWithScores(String key,
                                                                         double min,
                                                                         double max,
                                                                         long offset,
                                                                         long count)
```
    Description copied from interface: StringRedisConnection
    
    Get set of Tuple in range from start to end where score is between min and max from sorted set ordered high -> low.
    
    Specified by:
    
    zRevRangeByScoreWithScores in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZREVRANGEBYSCORE, RedisZSetCommands.zRevRangeByScoreWithScores(byte[], double, double, long, long)
  - zRevRank
```
public Long zRevRank(String key,
                     String value)
```
    Description copied from interface: StringRedisConnection
    
    Determine the index of element with value in a sorted set when scored high to low.
    
    Specified by:
    
    zRevRank in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    value - the value.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZREVRANK, RedisZSetCommands.zRevRank(byte[], byte[])
  - zScore
```
public Double zScore(String key,
                     String value)
```
    Description copied from interface: StringRedisConnection
    
    Get the score of element with value from sorted set with key key.
    
    Specified by:
    
    zScore in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    value - the value.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZSCORE, RedisZSetCommands.zScore(byte[], byte[])
  - zMScore
```
public List<Double> zMScore(String key,
                            String... values)
```
    Description copied from interface: StringRedisConnection
    
    Get the scores of elements with values from sorted set with key key.
    
    Specified by:
    
    zMScore in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    values - the values.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZMSCORE, RedisZSetCommands.zMScore(byte[], byte[][])
  - zUnionStore
```
public Long zUnionStore(String destKey,
                        RedisZSetCommands.Aggregate aggregate,
                        int[] weights,
                        String... sets)
```
    Description copied from interface: StringRedisConnection
    
    Union sorted sets and store result in destination key.
    
    Specified by:
    
    zUnionStore in interface StringRedisConnection
    
    Parameters:
    
    destKey - must not be null.
    
    aggregate - must not be null.
    
    sets - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZUNIONSTORE, RedisZSetCommands#zUnionStore(byte[], Aggregate, int[], byte[]...)
  - zUnionStore
```
public Long zUnionStore(String destKey,
                        String... sets)
```
    Description copied from interface: StringRedisConnection
    
    Union sorted sets and store result in destination key.
    
    Specified by:
    
    zUnionStore in interface StringRedisConnection
    
    Parameters:
    
    destKey - must not be null.
    
    sets - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZUNIONSTORE, RedisZSetCommands#zUnionStore(byte[], byte[]...)
  - geoAdd
```
public Long geoAdd(byte[] key,
                   Point point,
                   byte[] member)
```
    Description copied from interface: RedisGeoCommands
    
    Add Point with given member name to key.
    
    Specified by:
    
    geoAdd in interface RedisGeoCommands
    
    Parameters:
    
    key - must not be null.
    
    point - must not be null.
    
    member - must not be null.
    
    Returns:
    
    Number of elements added. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: GEOADD
  - geoAdd
```
public Long geoAdd(byte[] key,
                   RedisGeoCommands.GeoLocation<byte[]> location)
```
    Description copied from interface: RedisGeoCommands
    
    Add RedisGeoCommands.GeoLocation to key.
    
    Specified by:
    
    geoAdd in interface RedisGeoCommands
    
    Parameters:
    
    key - must not be null.
    
    location - must not be null.
    
    Returns:
    
    Number of elements added. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: GEOADD
  - geoAdd
```
public Long geoAdd(String key,
                   Point point,
                   String member)
```
    Description copied from interface: StringRedisConnection
    
    Add Point with given member name to key.
    
    Specified by:
    
    geoAdd in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    point - must not be null.
    
    member - must not be null.
    
    Returns:
    
    Number of elements added.
    
    See Also:
    
    Redis Documentation: GEOADD, RedisGeoCommands.geoAdd(byte[], Point, byte[])
  - geoAdd
```
public Long geoAdd(String key,
                   RedisGeoCommands.GeoLocation<String> location)
```
    Description copied from interface: StringRedisConnection
    
    Add GeoLocation to key.
    
    Specified by:
    
    geoAdd in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    location - must not be null.
    
    Returns:
    
    Number of elements added.
    
    See Also:
    
    Redis Documentation: GEOADD, RedisGeoCommands.geoAdd(byte[], GeoLocation)
  - geoAdd
```
public Long geoAdd(byte[] key,
                   Map<byte[],Point> memberCoordinateMap)
```
    Description copied from interface: RedisGeoCommands
    
    Add Map of member / Point pairs to key.
    
    Specified by:
    
    geoAdd in interface RedisGeoCommands
    
    Parameters:
    
    key - must not be null.
    
    memberCoordinateMap - must not be null.
    
    Returns:
    
    Number of elements added. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: GEOADD
  - geoAdd
```
public Long geoAdd(byte[] key,
                   Iterable<RedisGeoCommands.GeoLocation<byte[]>> locations)
```
    Description copied from interface: RedisGeoCommands
    
    Add RedisGeoCommands.GeoLocations to key
    
    Specified by:
    
    geoAdd in interface RedisGeoCommands
    
    Parameters:
    
    key - must not be null.
    
    locations - must not be null.
    
    Returns:
    
    Number of elements added. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: GEOADD
  - geoAdd
```
public Long geoAdd(String key,
                   Map<String,Point> memberCoordinateMap)
```
    Description copied from interface: StringRedisConnection
    
    Add Map of member / Point pairs to key.
    
    Specified by:
    
    geoAdd in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    memberCoordinateMap - must not be null.
    
    Returns:
    
    Number of elements added.
    
    See Also:
    
    Redis Documentation: GEOADD, RedisGeoCommands.geoAdd(byte[], Map)
  - geoAdd
```
public Long geoAdd(String key,
                   Iterable<RedisGeoCommands.GeoLocation<String>> locations)
```
    Description copied from interface: StringRedisConnection
    
    Add GeoLocations to key
    
    Specified by:
    
    geoAdd in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    locations - must not be null.
    
    Returns:
    
    Number of elements added.
    
    See Also:
    
    Redis Documentation: GEOADD, RedisGeoCommands.geoAdd(byte[], Iterable)
  - geoDist
```
public Distance geoDist(byte[] key,
                        byte[] member1,
                        byte[] member2)
```
    Description copied from interface: RedisGeoCommands
    
    Get the Distance between member1 and member2.
    
    Specified by:
    
    geoDist in interface RedisGeoCommands
    
    Parameters:
    
    key - must not be null.
    
    member1 - must not be null.
    
    member2 - must not be null.
    
    Returns:
    
    can be null. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: GEODIST
  - geoDist
```
public Distance geoDist(String key,
                        String member1,
                        String member2)
```
    Description copied from interface: StringRedisConnection
    
    Get the Distance between member1 and member2.
    
    Specified by:
    
    geoDist in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    member1 - must not be null.
    
    member2 - must not be null.
    
    Returns:
    
    can be null.
    
    See Also:
    
    Redis Documentation: GEODIST, RedisGeoCommands.geoDist(byte[], byte[], byte[])
  - geoDist
```
public Distance geoDist(byte[] key,
                        byte[] member1,
                        byte[] member2,
                        Metric metric)
```
    Description copied from interface: RedisGeoCommands
    
    Get the Distance between member1 and member2 in the given Metric.
    
    Specified by:
    
    geoDist in interface RedisGeoCommands
    
    Parameters:
    
    key - must not be null.
    
    member1 - must not be null.
    
    member2 - must not be null.
    
    metric - must not be null.
    
    Returns:
    
    can be null. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: GEODIST
  - geoDist
```
public Distance geoDist(String key,
                        String member1,
                        String member2,
                        Metric metric)
```
    Description copied from interface: StringRedisConnection
    
    Get the Distance between member1 and member2 in the given Metric.
    
    Specified by:
    
    geoDist in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    member1 - must not be null.
    
    member2 - must not be null.
    
    metric - must not be null.
    
    Returns:
    
    can be null.
    
    See Also:
    
    Redis Documentation: GEODIST, RedisGeoCommands.geoDist(byte[], byte[], byte[], Metric)
  - geoHash
```
public List<String> geoHash(byte[] key,
                            byte[]... members)
```
    Description copied from interface: RedisGeoCommands
    
    Get Geohash representation of the position for one or more members.
    
    Specified by:
    
    geoHash in interface RedisGeoCommands
    
    Parameters:
    
    key - must not be null.
    
    members - must not be null.
    
    Returns:
    
    empty list when key or members do not exists. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: GEOHASH
  - geoHash
```
public List<String> geoHash(String key,
                            String... members)
```
    Description copied from interface: StringRedisConnection
    
    Get geohash representation of the position for one or more members.
    
    Specified by:
    
    geoHash in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    members - must not be null.
    
    Returns:
    
    never null.
    
    See Also:
    
    Redis Documentation: GEOHASH, RedisGeoCommands#geoHash(byte[], byte[]...)
  - geoPos
```
public List<Point> geoPos(byte[] key,
                          byte[]... members)
```
    Description copied from interface: RedisGeoCommands
    
    Get the Point representation of positions for one or more members.
    
    Specified by:
    
    geoPos in interface RedisGeoCommands
    
    Parameters:
    
    key - must not be null.
    
    members - must not be null.
    
    Returns:
    
    empty List when key of members do not exist. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: GEOPOS
  - geoPos
```
public List<Point> geoPos(String key,
                          String... members)
```
    Description copied from interface: StringRedisConnection
    
    Get the Point representation of positions for one or more members.
    
    Specified by:
    
    geoPos in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    members - must not be null.
    
    Returns:
    
    never null.
    
    See Also:
    
    Redis Documentation: GEOPOS, RedisGeoCommands#geoPos(byte[], byte[]...)
  - geoRadius
```
public GeoResults<RedisGeoCommands.GeoLocation<String>> geoRadius(String key,
                                                                  Circle within)
```
    Description copied from interface: StringRedisConnection
    
    Get the members within the boundaries of a given Circle.
    
    Specified by:
    
    geoRadius in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    within - must not be null.
    
    Returns:
    
    never null.
    
    See Also:
    
    Redis Documentation: GEORADIUS, RedisGeoCommands.geoRadius(byte[], Circle)
  - geoRadius
```
public GeoResults<RedisGeoCommands.GeoLocation<String>> geoRadius(String key,
                                                                  Circle within,
                                                                  RedisGeoCommands.GeoRadiusCommandArgs args)
```
    Description copied from interface: StringRedisConnection
    
    Get the members within the boundaries of a given Circle applying GeoRadiusCommandArgs.
    
    Specified by:
    
    geoRadius in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    within - must not be null.
    
    args - must not be null.
    
    Returns:
    
    never null.
    
    See Also:
    
    Redis Documentation: GEORADIUS, RedisGeoCommands.geoRadius(byte[], Circle, GeoRadiusCommandArgs)
  - geoRadiusByMember
```
public GeoResults<RedisGeoCommands.GeoLocation<String>> geoRadiusByMember(String key,
                                                                          String member,
                                                                          double radius)
```
    Description copied from interface: StringRedisConnection
    
    Get the members within the circle defined by the members coordinates and given radius.
    
    Specified by:
    
    geoRadiusByMember in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    member - must not be null.
    
    Returns:
    
    never null.
    
    See Also:
    
    Redis Documentation: GEORADIUSBYMEMBER, RedisGeoCommands.geoRadiusByMember(byte[], byte[], double)
  - geoRadiusByMember
```
public GeoResults<RedisGeoCommands.GeoLocation<String>> geoRadiusByMember(String key,
                                                                          String member,
                                                                          Distance radius)
```
    Description copied from interface: StringRedisConnection
    
    Get the members within the circle defined by the members coordinates and given Distance.
    
    Specified by:
    
    geoRadiusByMember in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    member - must not be null.
    
    radius - must not be null.
    
    Returns:
    
    never null.
    
    See Also:
    
    Redis Documentation: GEORADIUSBYMEMBER, RedisGeoCommands.geoRadiusByMember(byte[], byte[], Distance)
  - geoRadiusByMember
```
public GeoResults<RedisGeoCommands.GeoLocation<String>> geoRadiusByMember(String key,
                                                                          String member,
                                                                          Distance radius,
                                                                          RedisGeoCommands.GeoRadiusCommandArgs args)
```
    Description copied from interface: StringRedisConnection
    
    Get the members within the circle defined by the members coordinates and given Distance and GeoRadiusCommandArgs.
    
    Specified by:
    
    geoRadiusByMember in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    member - must not be null.
    
    radius - must not be null.
    
    args - must not be null.
    
    Returns:
    
    never null.
    
    See Also:
    
    Redis Documentation: GEORADIUSBYMEMBER, RedisGeoCommands.geoRadiusByMember(byte[], byte[], Distance, GeoRadiusCommandArgs)
  - geoRadius
```
public GeoResults<RedisGeoCommands.GeoLocation<byte[]>> geoRadius(byte[] key,
                                                                  Circle within)
```
    Description copied from interface: RedisGeoCommands
    
    Get the members within the boundaries of a given Circle.
    
    Specified by:
    
    geoRadius in interface RedisGeoCommands
    
    Parameters:
    
    key - must not be null.
    
    within - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: GEORADIUS
  - geoRadius
```
public GeoResults<RedisGeoCommands.GeoLocation<byte[]>> geoRadius(byte[] key,
                                                                  Circle within,
                                                                  RedisGeoCommands.GeoRadiusCommandArgs args)
```
    Description copied from interface: RedisGeoCommands
    
    Get the members within the boundaries of a given Circle applying RedisGeoCommands.GeoRadiusCommandArgs.
    
    Specified by:
    
    geoRadius in interface RedisGeoCommands
    
    Parameters:
    
    key - must not be null.
    
    within - must not be null.
    
    args - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: GEORADIUS
  - geoRadiusByMember
```
public GeoResults<RedisGeoCommands.GeoLocation<byte[]>> geoRadiusByMember(byte[] key,
                                                                          byte[] member,
                                                                          double radius)
```
    Description copied from interface: RedisGeoCommands
    
    Get the members within the circle defined by the members coordinates and given radius.
    
    Specified by:
    
    geoRadiusByMember in interface RedisGeoCommands
    
    Parameters:
    
    key - must not be null.
    
    member - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: GEORADIUSBYMEMBER
  - geoRadiusByMember
```
public GeoResults<RedisGeoCommands.GeoLocation<byte[]>> geoRadiusByMember(byte[] key,
                                                                          byte[] member,
                                                                          Distance radius)
```
    Description copied from interface: RedisGeoCommands
    
    Get the members within the circle defined by the members coordinates and given Distance.
    
    Specified by:
    
    geoRadiusByMember in interface RedisGeoCommands
    
    Parameters:
    
    key - must not be null.
    
    member - must not be null.
    
    radius - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction..
    
    See Also:
    
    Redis Documentation: GEORADIUSBYMEMBER
  - geoRadiusByMember
```
public GeoResults<RedisGeoCommands.GeoLocation<byte[]>> geoRadiusByMember(byte[] key,
                                                                          byte[] member,
                                                                          Distance radius,
                                                                          RedisGeoCommands.GeoRadiusCommandArgs args)
```
    Description copied from interface: RedisGeoCommands
    
    Get the members within the circle defined by the members coordinates, given Distance and RedisGeoCommands.GeoRadiusCommandArgs.
    
    Specified by:
    
    geoRadiusByMember in interface RedisGeoCommands
    
    Parameters:
    
    key - must not be null.
    
    member - must not be null.
    
    radius - must not be null.
    
    args - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: GEORADIUSBYMEMBER
  - geoRemove
```
public Long geoRemove(byte[] key,
                      byte[]... members)
```
    Description copied from interface: RedisGeoCommands
    
    Remove the members.
    
    Specified by:
    
    geoRemove in interface RedisGeoCommands
    
    Parameters:
    
    key - must not be null.
    
    members - must not be null.
    
    Returns:
    
    Number of elements removed. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZREM
  - geoRemove
```
public Long geoRemove(String key,
                      String... members)
```
    Description copied from interface: StringRedisConnection
    
    Remove the members.
    
    Specified by:
    
    geoRemove in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    members - must not be null.
    
    Returns:
    
    Number of members elements removed.
    
    See Also:
    
    Redis Documentation: ZREM, RedisGeoCommands#geoRemove(byte[], byte[]...)
  - geoSearch
```
public GeoResults<RedisGeoCommands.GeoLocation<byte[]>> geoSearch(byte[] key,
                                                                  GeoReference<byte[]> reference,
                                                                  GeoShape predicate,
                                                                  RedisGeoCommands.GeoSearchCommandArgs args)
```
    Description copied from interface: RedisGeoCommands
    
    Return the members of a geo set which are within the borders of the area specified by a given shape. The query's center point is provided by GeoReference.
    
    Specified by:
    
    geoSearch in interface RedisGeoCommands
    
    Parameters:
    
    key - must not be null.
    
    reference - must not be null.
    
    predicate - must not be null.
    
    args - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: GEOSEARCH
  - geoSearchStore
```
public Long geoSearchStore(byte[] destKey,
                           byte[] key,
                           GeoReference<byte[]> reference,
                           GeoShape predicate,
                           RedisGeoCommands.GeoSearchStoreCommandArgs args)
```
    Description copied from interface: RedisGeoCommands
    
    Query the members of a geo set which are within the borders of the area specified by a given shape and store the result at destKey. The query's center point is provided by GeoReference.
    
    Specified by:
    
    geoSearchStore in interface RedisGeoCommands
    
    key - must not be null.
    
    reference - must not be null.
    
    predicate - must not be null.
    
    args - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: GEOSEARCH
  - geoSearch
```
public GeoResults<RedisGeoCommands.GeoLocation<String>> geoSearch(String key,
                                                                  GeoReference<String> reference,
                                                                  GeoShape predicate,
                                                                  RedisGeoCommands.GeoSearchCommandArgs args)
```
    Description copied from interface: StringRedisConnection
    
    Return the members of a geo set which are within the borders of the area specified by a given shape. The query's center point is provided by GeoReference.
    
    Specified by:
    
    geoSearch in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    reference - must not be null.
    
    predicate - must not be null.
    
    args - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: GEOSEARCH
  - geoSearchStore
```
public Long geoSearchStore(String destKey,
                           String key,
                           GeoReference<String> reference,
                           GeoShape predicate,
                           RedisGeoCommands.GeoSearchStoreCommandArgs args)
```
    Description copied from interface: StringRedisConnection
    
    Query the members of a geo set which are within the borders of the area specified by a given shape and store the result at destKey. The query's center point is provided by GeoReference.
    
    Specified by:
    
    geoSearchStore in interface StringRedisConnection
    
    key - must not be null.
    
    reference - must not be null.
    
    predicate - must not be null.
    
    args - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: GEOSEARCH
  - closePipeline
```
public List<Object> closePipeline()
```
    Description copied from interface: RedisConnection
    
    Executes the commands in the pipeline and returns their result. If the connection is not pipelined, an empty collection is returned.
    
    Specified by:
    
    closePipeline in interface RedisConnection
    
    Returns:
    
    the result of the executed commands.
  - isPipelined
```
public boolean isPipelined()
```
    Description copied from interface: RedisConnection
    
    Indicates whether the connection is currently pipelined or not.
    
    Specified by:
    
    isPipelined in interface RedisConnection
    
    Returns:
    
    true if the connection is pipelined, false otherwise
    
    See Also:
    
    RedisConnection.openPipeline(), RedisConnection.isQueueing()
  - openPipeline
```
public void openPipeline()
```
    Description copied from interface: RedisConnection
    
    Activates the pipeline mode for this connection. When pipelined, all commands return null (the reply is read at the end through RedisConnection.closePipeline(). Calling this method when the connection is already pipelined has no effect. Pipelining is used for issuing commands without requesting the response right away but rather at the end of the batch. While somewhat similar to MULTI, pipelining does not guarantee atomicity - it only tries to improve performance when issuing a lot of commands (such as in batching scenarios).
    Note:
    Consider doing some performance testing before using this feature since in many cases the performance benefits are minimal yet the impact on usage are not.
    
    Specified by:
    
    openPipeline in interface RedisConnection
    
    See Also:
    
    RedisTxCommands.multi()
  - execute
```
public Object execute(String command)
```
    Description copied from interface: StringRedisConnection
    
    'Native' or 'raw' execution of the given command along-side the given arguments. The command is executed as is, with as little 'interpretation' as possible - it is up to the caller to take care of any processing of arguments or the result.
    
    Specified by:
    
    execute in interface StringRedisConnection
    
    Parameters:
    
    command - Command to execute
    
    Returns:
    
    execution result.
    
    See Also:
    
    RedisCommands#execute(String, byte[]...)
  - execute
```
public Object execute(String command,
                      byte[]... args)
```
    Description copied from interface: RedisCommands
    
    'Native' or 'raw' execution of the given command along-side the given arguments. The command is executed as is, with as little 'interpretation' as possible - it is up to the caller to take care of any processing of arguments or the result.
    
    Specified by:
    
    execute in interface RedisCommands
    
    Parameters:
    
    command - Command to execute. must not be null.
    
    args - Possible command arguments (may be empty).
    
    Returns:
    
    execution result. Can be null.
  - execute
```
public Object execute(String command,
                      String... args)
```
    Description copied from interface: StringRedisConnection
    
    'Native' or 'raw' execution of the given command along-side the given arguments. The command is executed as is, with as little 'interpretation' as possible - it is up to the caller to take care of any processing of arguments or the result.
    
    Specified by:
    
    execute in interface StringRedisConnection
    
    Parameters:
    
    command - Command to execute
    
    args - Possible command arguments (may be null)
    
    Returns:
    
    execution result.
    
    See Also:
    
    RedisCommands#execute(String, byte[]...)
  - pExpire
```
public Boolean pExpire(String key,
                       long millis)
```
    Description copied from interface: StringRedisConnection
    
    Set time to live for given key in milliseconds.
    
    Specified by:
    
    pExpire in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: PEXPIRE, RedisKeyCommands.pExpire(byte[], long)
  - pExpireAt
```
public Boolean pExpireAt(String key,
                         long unixTimeInMillis)
```
    Description copied from interface: StringRedisConnection
    
    Set the expiration for given key as a UNIX timestamp in milliseconds.
    
    Specified by:
    
    pExpireAt in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: PEXPIREAT, RedisKeyCommands.pExpireAt(byte[], long)
  - pTtl
```
public Long pTtl(String key)
```
    Description copied from interface: StringRedisConnection
    
    Get the precise time to live for key in milliseconds.
    
    Specified by:
    
    pTtl in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: PTTL, RedisKeyCommands.pTtl(byte[])
  - pTtl
```
public Long pTtl(String key,
                 TimeUnit timeUnit)
```
    Description copied from interface: StringRedisConnection
    
    Get the precise time to live for key in and convert it to the given TimeUnit.
    
    Specified by:
    
    pTtl in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    timeUnit - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: PTTL, RedisKeyCommands.pTtl(byte[], TimeUnit)
  - scriptLoad
```
public String scriptLoad(String script)
```
    Description copied from interface: StringRedisConnection
    
    Load lua script into scripts cache, without executing it.
    Execute the script by calling #evalSha(byte[], ReturnType, int, byte[]...).
    
    Specified by:
    
    scriptLoad in interface StringRedisConnection
    
    Parameters:
    
    script - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SCRIPT LOAD, RedisScriptingCommands.scriptLoad(byte[])
  - eval
```
public <T> T eval(String script,
                  ReturnType returnType,
                  int numKeys,
                  String... keysAndArgs)
```
    NOTE: This method will not deserialize Strings returned by Lua scripts, as they may not be encoded with the same serializer used here. They will be returned as byte[]s
    
    Specified by:
    
    eval in interface StringRedisConnection
    
    Parameters:
    
    script - must not be null.
    
    returnType - must not be null.
    
    keysAndArgs - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: EVAL, RedisScriptingCommands#eval(byte[], ReturnType, int, byte[]...)
  - evalSha
```
public <T> T evalSha(String scriptSha1,
                     ReturnType returnType,
                     int numKeys,
                     String... keysAndArgs)
```
    NOTE: This method will not deserialize Strings returned by Lua scripts, as they may not be encoded with the same serializer used here. They will be returned as byte[]s
    
    Specified by:
    
    evalSha in interface StringRedisConnection
    
    Parameters:
    
    scriptSha1 - must not be null.
    
    returnType - must not be null.
    
    keysAndArgs - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: EVALSHA, RedisScriptingCommands#evalSha(String, ReturnType, int, byte[]...)
  - time
```
public Long time()
```
    Description copied from interface: RedisServerCommands
    
    Request server timestamp using TIME command in TimeUnit.MILLISECONDS.
    
    Specified by:
    
    time in interface RedisServerCommands
    
    Returns:
    
    current server time in milliseconds or null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: TIME
  - time
```
public Long time(TimeUnit timeUnit)
```
    Description copied from interface: RedisServerCommands
    
    Request server timestamp using TIME command.
    
    Specified by:
    
    time in interface RedisServerCommands
    
    Parameters:
    
    timeUnit - target unit.
    
    Returns:
    
    current server time in TimeUnit or null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: TIME
  - getClientList
```
public List<RedisClientInfo> getClientList()
```
    Description copied from interface: StringRedisConnection
    
    Request information and statistics about connected clients.
    
    Specified by:
    
    getClientList in interface RedisServerCommands
    
    Specified by:
    
    getClientList in interface StringRedisConnection
    
    Returns:
    
    List of RedisClientInfo objects.
    
    See Also:
    
    Redis Documentation: CLIENT LIST, RedisServerCommands.getClientList()
  - slaveOf
```
public void slaveOf(String host,
                    int port)
```
    Description copied from interface: RedisServerCommands
    
    Change redis replication setting to new master.
    
    Specified by:
    
    slaveOf in interface RedisServerCommands
    
    Parameters:
    
    host - must not be null.
    
    See Also:
    
    Redis Documentation: SLAVEOF
  - slaveOfNoOne
```
public void slaveOfNoOne()
```
    Description copied from interface: RedisServerCommands
    
    Change server into master.
    
    Specified by:
    
    slaveOfNoOne in interface RedisServerCommands
    
    See Also:
    
    Redis Documentation: SLAVEOF
  - scan
```
public Cursor<byte[]> scan(ScanOptions options)
```
    Description copied from interface: RedisKeyCommands
    
    Use a Cursor to iterate over keys.
    
    Specified by:
    
    scan in interface RedisKeyCommands
    
    Parameters:
    
    options - must not be null.
    
    Returns:
    
    never null.
    
    See Also:
    
    Redis Documentation: SCAN
  - zScan
```
public Cursor<RedisZSetCommands.Tuple> zScan(byte[] key,
                                             ScanOptions options)
```
    Description copied from interface: RedisZSetCommands
    
    Use a Cursor to iterate over elements in sorted set at key.
    
    Specified by:
    
    zScan in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    options - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZSCAN
  - sScan
```
public Cursor<byte[]> sScan(byte[] key,
                            ScanOptions options)
```
    Description copied from interface: RedisSetCommands
    
    Use a Cursor to iterate over elements in set at key.
    
    Specified by:
    
    sScan in interface RedisSetCommands
    
    Parameters:
    
    key - must not be null.
    
    options - must not be null.
    
    Returns:
    
    never null.
    
    See Also:
    
    Redis Documentation: SCAN
  - hScan
```
public Cursor<Map.Entry<byte[],byte[]>> hScan(byte[] key,
                                              ScanOptions options)
```
    Description copied from interface: RedisHashCommands
    
    Use a Cursor to iterate over entries in hash at key.
    
    Specified by:
    
    hScan in interface RedisHashCommands
    
    Parameters:
    
    key - must not be null.
    
    options - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: HSCAN
  - hStrLen
```
@Nullable
public Long hStrLen(byte[] key,
                              byte[] field)
```
    Description copied from interface: RedisHashCommands
    
    Returns the length of the value associated with field in the hash stored at key. If the key or the field do not exist, 0 is returned.
    
    Specified by:
    
    hStrLen in interface RedisHashCommands
    
    Parameters:
    
    key - must not be null.
    
    field - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: HSTRLEN
  - setClientName
```
public void setClientName(byte[] name)
```
    Description copied from interface: RedisServerCommands
    
    Assign given name to current connection.
    
    Specified by:
    
    setClientName in interface RedisServerCommands
    
    See Also:
    
    Redis Documentation: CLIENT SETNAME
  - setClientName
```
public void setClientName(String name)
```
    Description copied from interface: StringRedisConnection
    
    Assign given name to current connection.
    
    Specified by:
    
    setClientName in interface StringRedisConnection
    
    See Also:
    
    Redis Documentation: CLIENT SETNAME, RedisServerCommands.setClientName(byte[])
  - killClient
```
public void killClient(String host,
                       int port)
```
    Description copied from interface: RedisServerCommands
    
    Closes a given client connection identified by host:port.
    
    Specified by:
    
    killClient in interface RedisServerCommands
    
    Parameters:
    
    host - of connection to close.
    
    port - of connection to close
    
    See Also:
    
    Redis Documentation: CLIENT KILL
  - getClientName
```
public String getClientName()
```
    Description copied from interface: RedisServerCommands
    
    Returns the name of the current connection.
    
    Specified by:
    
    getClientName in interface RedisServerCommands
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: CLIENT GETNAME
  - hScan
```
public Cursor<Map.Entry<String,String>> hScan(String key,
                                              ScanOptions options)
```
    Description copied from interface: StringRedisConnection
    
    Use a Cursor to iterate over entries in hash at key.
    
    Specified by:
    
    hScan in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    options - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: HSCAN, RedisHashCommands.hScan(byte[], ScanOptions)
  - hStrLen
```
public Long hStrLen(String key,
                    String field)
```
    Description copied from interface: StringRedisConnection
    
    Returns the length of the value associated with field in the hash stored at key. If the key or the field do not exist, 0 is returned.
    
    Specified by:
    
    hStrLen in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    field - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
  - sScan
```
public Cursor<String> sScan(String key,
                            ScanOptions options)
```
    Description copied from interface: StringRedisConnection
    
    Use a Cursor to iterate over elements in set at key.
    
    Specified by:
    
    sScan in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    options - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SCAN, RedisSetCommands.sScan(byte[], ScanOptions)
  - zScan
```
public Cursor<StringRedisConnection.StringTuple> zScan(String key,
                                                       ScanOptions options)
```
    Description copied from interface: StringRedisConnection
    
    Use a Cursor to iterate over elements in sorted set at key.
    
    Specified by:
    
    zScan in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    options - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZSCAN, RedisZSetCommands.zScan(byte[], ScanOptions)
  - getSentinelConnection
```
public RedisSentinelConnection getSentinelConnection()
```
    Specified by:
    
    getSentinelConnection in interface RedisConnection
    
    Returns:
  - zRangeByScore
```
public Set<String> zRangeByScore(String key,
                                 String min,
                                 String max)
```
    Description copied from interface: StringRedisConnection
    
    Get elements where score is between min and max from sorted set.
    
    Specified by:
    
    zRangeByScore in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    min - must not be null.
    
    max - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZRANGEBYSCORE, RedisZSetCommands.zRangeByScore(byte[], String, String)
  - zRangeByScore
```
public Set<String> zRangeByScore(String key,
                                 String min,
                                 String max,
                                 long offset,
                                 long count)
```
    Description copied from interface: StringRedisConnection
    
    Get elements in range from start to end where score is between min and max from sorted set.
    
    Specified by:
    
    zRangeByScore in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    min - must not be null.
    
    max - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZRANGEBYSCORE, RedisZSetCommands.zRangeByScore(byte[], double, double, long, long)
  - zRangeByScore
```
public Set<byte[]> zRangeByScore(byte[] key,
                                 String min,
                                 String max)
```
    Description copied from interface: RedisZSetCommands
    
    Get elements where score is between min and max from sorted set.
    
    Specified by:
    
    zRangeByScore in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZRANGEBYSCORE
  - zRangeByScore
```
public Set<byte[]> zRangeByScore(byte[] key,
                                 String min,
                                 String max,
                                 long offset,
                                 long count)
```
    Description copied from interface: RedisZSetCommands
    
    Get elements in range from start to end where score is between min and max from sorted set.
    
    Specified by:
    
    zRangeByScore in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    min - must not be null.
    
    max - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZRANGEBYSCORE
  - pfAdd
```
public Long pfAdd(byte[] key,
                  byte[]... values)
```
    Description copied from interface: RedisHyperLogLogCommands
    
    Adds given values to the HyperLogLog stored at given key.
    
    Specified by:
    
    pfAdd in interface RedisHyperLogLogCommands
    
    Parameters:
    
    key - must not be null.
    
    values - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: PFADD
  - pfAdd
```
public Long pfAdd(String key,
                  String... values)
```
    Description copied from interface: StringRedisConnection
    
    Adds given values to the HyperLogLog stored at given key.
    
    Specified by:
    
    pfAdd in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    values - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: PFADD, RedisHyperLogLogCommands#pfAdd(byte[], byte[]...)
  - pfCount
```
public Long pfCount(byte[]... keys)
```
    Description copied from interface: RedisHyperLogLogCommands
    
    Return the approximated cardinality of the structures observed by the HyperLogLog at key(s).
    
    Specified by:
    
    pfCount in interface RedisHyperLogLogCommands
    
    Parameters:
    
    keys - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: PFCOUNT
  - pfCount
```
public Long pfCount(String... keys)
```
    Description copied from interface: StringRedisConnection
    
    Return the approximated cardinality of the structures observed by the HyperLogLog at key(s).
    
    Specified by:
    
    pfCount in interface StringRedisConnection
    
    Parameters:
    
    keys - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: PFCOUNT, RedisHyperLogLogCommands#pfCount(byte[]...)
  - pfMerge
```
public void pfMerge(byte[] destinationKey,
                    byte[]... sourceKeys)
```
    Description copied from interface: RedisHyperLogLogCommands
    
    Merge N different HyperLogLogs at sourceKeys into a single destinationKey.
    
    Specified by:
    
    pfMerge in interface RedisHyperLogLogCommands
    
    Parameters:
    
    destinationKey - must not be null.
    
    sourceKeys - must not be null.
    
    See Also:
    
    Redis Documentation: PFMERGE
  - pfMerge
```
public void pfMerge(String destinationKey,
                    String... sourceKeys)
```
    Description copied from interface: StringRedisConnection
    
    Merge N different HyperLogLogs at sourceKeys into a single destinationKey.
    
    Specified by:
    
    pfMerge in interface StringRedisConnection
    
    Parameters:
    
    destinationKey - must not be null.
    
    sourceKeys - must not be null.
    
    See Also:
    
    Redis Documentation: PFMERGE, RedisHyperLogLogCommands#pfMerge(byte[], byte[]...)
  - zRangeByLex
```
public Set<byte[]> zRangeByLex(byte[] key)
```
    Description copied from interface: RedisZSetCommands
    
    Get all the elements in the sorted set at key in lexicographical ordering.
    
    Specified by:
    
    zRangeByLex in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZRANGEBYLEX
  - zRangeByLex
```
public Set<byte[]> zRangeByLex(byte[] key,
                               RedisZSetCommands.Range range)
```
    Description copied from interface: RedisZSetCommands
    
    Get all the elements in RedisZSetCommands.Range from the sorted set at key in lexicographical ordering.
    
    Specified by:
    
    zRangeByLex in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    range - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZRANGEBYLEX
  - zRangeByLex
```
public Set<byte[]> zRangeByLex(byte[] key,
                               RedisZSetCommands.Range range,
                               RedisZSetCommands.Limit limit)
```
    Description copied from interface: RedisZSetCommands
    
    Get all the elements in RedisZSetCommands.Range from the sorted set at key in lexicographical ordering. Result is limited via RedisZSetCommands.Limit.
    
    Specified by:
    
    zRangeByLex in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    range - must not be null.
    
    limit - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZRANGEBYLEX
  - zRangeByLex
```
public Set<String> zRangeByLex(String key)
```
    Description copied from interface: StringRedisConnection
    
    Get all the elements in the sorted set at key in lexicographical ordering.
    
    Specified by:
    
    zRangeByLex in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZRANGEBYLEX, RedisZSetCommands.zRangeByLex(byte[])
  - zRangeByLex
```
public Set<String> zRangeByLex(String key,
                               RedisZSetCommands.Range range)
```
    Description copied from interface: StringRedisConnection
    
    Get all the elements in Range from the sorted set at key in lexicographical ordering.
    
    Specified by:
    
    zRangeByLex in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    range - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZRANGEBYLEX, RedisZSetCommands.zRangeByLex(byte[], Range)
  - zRangeByLex
```
public Set<String> zRangeByLex(String key,
                               RedisZSetCommands.Range range,
                               RedisZSetCommands.Limit limit)
```
    Description copied from interface: StringRedisConnection
    
    Get all the elements in Range from the sorted set at key in lexicographical ordering. Result is limited via Limit.
    
    Specified by:
    
    zRangeByLex in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    range - must not be null.
    
    limit - can be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZRANGEBYLEX, RedisZSetCommands.zRangeByLex(byte[], Range, Limit)
  - zRevRangeByLex
```
public Set<byte[]> zRevRangeByLex(byte[] key,
                                  RedisZSetCommands.Range range,
                                  RedisZSetCommands.Limit limit)
```
    Description copied from interface: RedisZSetCommands
    
    Get all the elements in RedisZSetCommands.Range from the sorted set at key in reversed lexicographical ordering. Result is limited via RedisZSetCommands.Limit.
    
    Specified by:
    
    zRevRangeByLex in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    range - must not be null.
    
    limit - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: ZREVRANGEBYLEX
  - zRevRangeByLex
```
public Set<String> zRevRangeByLex(String key,
                                  RedisZSetCommands.Range range,
                                  RedisZSetCommands.Limit limit)
```
    Description copied from interface: StringRedisConnection
    
    Get all the elements in Range from the sorted set at key in reversed lexicographical ordering. Result is limited via Limit.
    
    Specified by:
    
    zRevRangeByLex in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    range - must not be null.
    
    limit - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZREVRANGEBYLEX, RedisZSetCommands.zRevRangeByLex(byte[], Range, Limit)
  - migrate
```
public void migrate(byte[] key,
                    RedisNode target,
                    int dbIndex,
                    @Nullable
                    RedisServerCommands.MigrateOption option)
```
    Description copied from interface: RedisServerCommands
    
    Atomically transfer a key from a source Redis instance to a destination Redis instance. On success the key is deleted from the original instance and is guaranteed to exist in the target instance.
    
    Specified by:
    
    migrate in interface RedisServerCommands
    
    Parameters:
    
    key - must not be null.
    
    target - must not be null.
    
    option - can be null. Defaulted to RedisServerCommands.MigrateOption.COPY.
    
    See Also:
    
    Redis Documentation: MIGRATE
  - migrate
```
public void migrate(byte[] key,
                    RedisNode target,
                    int dbIndex,
                    @Nullable
                    RedisServerCommands.MigrateOption option,
                    long timeout)
```
    Description copied from interface: RedisServerCommands
    
    Atomically transfer a key from a source Redis instance to a destination Redis instance. On success the key is deleted from the original instance and is guaranteed to exist in the target instance.
    
    Specified by:
    
    migrate in interface RedisServerCommands
    
    Parameters:
    
    key - must not be null.
    
    target - must not be null.
    
    option - can be null. Defaulted to RedisServerCommands.MigrateOption.COPY.
    
    See Also:
    
    Redis Documentation: MIGRATE
  - xAck
```
public Long xAck(String key,
                 String group,
                 RecordId... recordIds)
```
    Specified by:
    
    xAck in interface StringRedisConnection
  - xAdd
```
public RecordId xAdd(StringRecord record,
                     RedisStreamCommands.XAddOptions options)
```
    Description copied from interface: StringRedisConnection
    
    Append the given StringRecord to the stream stored at Record.getStream().
    
    Specified by:
    
    xAdd in interface StringRedisConnection
    
    Parameters:
    
    record - must not be null.
    
    options - must not be null, use XAddOptions#none() instead.
    
    Returns:
    
    the record Id. null when used in pipeline / transaction.
  - xClaimJustId
```
public List<RecordId> xClaimJustId(String key,
                                   String group,
                                   String consumer,
                                   RedisStreamCommands.XClaimOptions options)
```
    Description copied from interface: StringRedisConnection
    
    Change the ownership of a pending message to the given new consumer without increasing the delivered count.
    
    Specified by:
    
    xClaimJustId in interface StringRedisConnection
    
    Parameters:
    
    key - the key the stream is stored at.
    
    group - the name of the consumer group.
    
    consumer - the name of the new consumer.
    
    options - must not be null.
    
    Returns:
    
    list of ids that changed user.
    
    See Also:
    
    Redis Documentation: XCLAIM
  - xClaim
```
public List<StringRecord> xClaim(String key,
                                 String group,
                                 String consumer,
                                 RedisStreamCommands.XClaimOptions options)
```
    Description copied from interface: StringRedisConnection
    
    Change the ownership of a pending message to the given new consumer.
    
    Specified by:
    
    xClaim in interface StringRedisConnection
    
    Parameters:
    
    key - the key the stream is stored at.
    
    group - the name of the consumer group.
    
    consumer - the name of the new consumer.
    
    options - must not be null.
    
    Returns:
    
    list of StringRecord that changed user.
    
    See Also:
    
    Redis Documentation: XCLAIM
  - xDel
```
public Long xDel(String key,
                 RecordId... recordIds)
```
    Specified by:
    
    xDel in interface StringRedisConnection
  - xGroupCreate
```
public String xGroupCreate(String key,
                           ReadOffset readOffset,
                           String group)
```
    Description copied from interface: StringRedisConnection
    
    Create a consumer group.
    
    Specified by:
    
    xGroupCreate in interface StringRedisConnection
    
    Parameters:
    
    key - the stream key.
    
    group - name of the consumer group.
    
    Returns:
    
    true if successful. null when used in pipeline / transaction.
  - xGroupCreate
```
public String xGroupCreate(String key,
                           ReadOffset readOffset,
                           String group,
                           boolean mkStream)
```
    Description copied from interface: StringRedisConnection
    
    Create a consumer group.
    
    Specified by:
    
    xGroupCreate in interface StringRedisConnection
    
    Parameters:
    
    key - the stream key.
    
    group - name of the consumer group.
    
    mkStream - if true the group will create the stream if needed (MKSTREAM)
    
    Returns:
    
    true if successful. null when used in pipeline / transaction.
  - xGroupDelConsumer
```
public Boolean xGroupDelConsumer(String key,
                                 Consumer consumer)
```
    Description copied from interface: StringRedisConnection
    
    Delete a consumer from a consumer group.
    
    Specified by:
    
    xGroupDelConsumer in interface StringRedisConnection
    
    Parameters:
    
    key - the stream key.
    
    consumer - consumer identified by group name and consumer key.
    
    Returns:
    
    true if successful. null when used in pipeline / transaction.
  - xGroupDestroy
```
public Boolean xGroupDestroy(String key,
                             String group)
```
    Description copied from interface: StringRedisConnection
    
    Destroy a consumer group.
    
    Specified by:
    
    xGroupDestroy in interface StringRedisConnection
    
    Parameters:
    
    key - the stream key.
    
    group - name of the consumer group.
    
    Returns:
    
    true if successful. null when used in pipeline / transaction.
  - xInfo
```
public StreamInfo.XInfoStream xInfo(String key)
```
    Description copied from interface: StringRedisConnection
    
    Obtain general information about the stream stored at the specified key.
    
    Specified by:
    
    xInfo in interface StringRedisConnection
    
    Parameters:
    
    key - the key the stream is stored at.
    
    Returns:
    
    null when used in pipeline / transaction.
  - xInfoGroups
```
public StreamInfo.XInfoGroups xInfoGroups(String key)
```
    Description copied from interface: StringRedisConnection
    
    Obtain information about consumer groups associated with the stream stored at the specified key.
    
    Specified by:
    
    xInfoGroups in interface StringRedisConnection
    
    Parameters:
    
    key - the key the stream is stored at.
    
    Returns:
    
    null when used in pipeline / transaction.
  - xInfoConsumers
```
public StreamInfo.XInfoConsumers xInfoConsumers(String key,
                                                String groupName)
```
    Description copied from interface: StringRedisConnection
    
    Obtain information about every consumer in a specific consumer group for the stream stored at the specified key.
    
    Specified by:
    
    xInfoConsumers in interface StringRedisConnection
    
    Parameters:
    
    key - the key the stream is stored at.
    
    groupName - name of the consumer group.
    
    Returns:
    
    null when used in pipeline / transaction.
  - xLen
```
public Long xLen(String key)
```
    Description copied from interface: StringRedisConnection
    
    Get the length of a stream.
    
    Specified by:
    
    xLen in interface StringRedisConnection
    
    Parameters:
    
    key - the stream key.
    
    Returns:
    
    length of the stream. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: XLEN
  - xPending
```
public PendingMessagesSummary xPending(String key,
                                       String groupName)
```
    Description copied from interface: StringRedisConnection
    
    Obtain the PendingMessagesSummary for a given consumer group.
    
    Specified by:
    
    xPending in interface StringRedisConnection
    
    Parameters:
    
    key - the key the stream is stored at. Must not be null.
    
    groupName - the name of the consumer group. Must not be null.
    
    Returns:
    
    a summary of pending messages within the given consumer group or null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: xpending
  - xPending
```
public PendingMessages xPending(String key,
                                String groupName,
                                String consumer,
                                Range<String> range,
                                Long count)
```
    Description copied from interface: StringRedisConnection
    
    Obtain detailed information about pending messages for a given Range within a consumer group.
    
    Specified by:
    
    xPending in interface StringRedisConnection
    
    Parameters:
    
    key - the key the stream is stored at. Must not be null.
    
    groupName - the name of the consumer group. Must not be null.
    
    consumer - the name of the consumer. Must not be null.
    
    range - the range of messages ids to search within. Must not be null.
    
    count - limit the number of results. Must not be null.
    
    Returns:
    
    pending messages for the given consumer group or null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: xpending
  - xPending
```
public PendingMessages xPending(String key,
                                String groupName,
                                Range<String> range,
                                Long count)
```
    Description copied from interface: StringRedisConnection
    
    Obtain detailed information about pending messages for a given Range within a consumer group.
    
    Specified by:
    
    xPending in interface StringRedisConnection
    
    Parameters:
    
    key - the key the stream is stored at. Must not be null.
    
    groupName - the name of the consumer group. Must not be null.
    
    range - the range of messages ids to search within. Must not be null.
    
    count - limit the number of results. Must not be null.
    
    Returns:
    
    pending messages for the given consumer group or null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: xpending
  - xPending
```
public PendingMessages xPending(String key,
                                String groupName,
                                RedisStreamCommands.XPendingOptions options)
```
    Description copied from interface: StringRedisConnection
    
    Obtain detailed information about pending messages applying given options.
    
    Specified by:
    
    xPending in interface StringRedisConnection
    
    Parameters:
    
    key - the key the stream is stored at. Must not be null.
    
    groupName - the name of the consumer group. Must not be null.
    
    options - the options containing range, consumer and count. Must not be null.
    
    Returns:
    
    pending messages matching given criteria or null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: xpending
  - xRange
```
public List<StringRecord> xRange(String key,
                                 Range<String> range,
                                 RedisZSetCommands.Limit limit)
```
    Description copied from interface: StringRedisConnection
    
    Read records from a stream within a specific Range applying a Limit.
    
    Specified by:
    
    xRange in interface StringRedisConnection
    
    Parameters:
    
    key - the stream key.
    
    range - must not be null.
    
    limit - must not be null.
    
    Returns:
    
    list with members of the resulting stream. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: XRANGE
  - xReadAsString
```
public List<StringRecord> xReadAsString(StreamReadOptions readOptions,
                                        StreamOffset<String>... streams)
```
    Description copied from interface: StringRedisConnection
    
    Read records from one or more StreamOffsets.
    
    Specified by:
    
    xReadAsString in interface StringRedisConnection
    
    Parameters:
    
    readOptions - read arguments.
    
    streams - the streams to read from.
    
    Returns:
    
    list with members of the resulting stream. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: XREAD
  - xReadGroupAsString
```
public List<StringRecord> xReadGroupAsString(Consumer consumer,
                                             StreamReadOptions readOptions,
                                             StreamOffset<String>... streams)
```
    Description copied from interface: StringRedisConnection
    
    Read records from one or more StreamOffsets using a consumer group.
    
    Specified by:
    
    xReadGroupAsString in interface StringRedisConnection
    
    Parameters:
    
    consumer - consumer/group.
    
    readOptions - read arguments.
    
    streams - the streams to read from.
    
    Returns:
    
    list with members of the resulting stream. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: XREADGROUP
  - xRevRange
```
public List<StringRecord> xRevRange(String key,
                                    Range<String> range,
                                    RedisZSetCommands.Limit limit)
```
    Description copied from interface: StringRedisConnection
    
    Read records from a stream within a specific Range applying a Limit in reverse order.
    
    Specified by:
    
    xRevRange in interface StringRedisConnection
    
    Parameters:
    
    key - the stream key.
    
    range - must not be null.
    
    limit - must not be null.
    
    Returns:
    
    list with members of the resulting stream. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: XREVRANGE
  - xTrim
```
public Long xTrim(String key,
                  long count)
```
    Description copied from interface: StringRedisConnection
    
    Trims the stream to count elements.
    
    Specified by:
    
    xTrim in interface StringRedisConnection
    
    Parameters:
    
    key - the stream key.
    
    count - length of the stream.
    
    Returns:
    
    number of removed entries. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: XTRIM
  - xTrim
```
public Long xTrim(String key,
                  long count,
                  boolean approximateTrimming)
```
    Description copied from interface: StringRedisConnection
    
    Trims the stream to count elements.
    
    Specified by:
    
    xTrim in interface StringRedisConnection
    
    Parameters:
    
    key - the stream key.
    
    count - length of the stream.
    
    approximateTrimming - the trimming must be performed in a approximated way in order to maximize performances.
    
    Returns:
    
    number of removed entries. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: XTRIM
  - xAck
```
public Long xAck(byte[] key,
                 String group,
                 RecordId... recordIds)
```
    Description copied from interface: RedisStreamCommands
    
    Acknowledge one or more records, identified via their id, as processed.
    
    Specified by:
    
    xAck in interface RedisStreamCommands
    
    Parameters:
    
    key - the key the stream is stored at.
    
    group - name of the consumer group.
    
    recordIds - the id's of the records to acknowledge.
    
    Returns:
    
    length of acknowledged messages. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: XACK
  - xAdd
```
public RecordId xAdd(MapRecord<byte[],byte[],byte[]> record,
                     RedisStreamCommands.XAddOptions options)
```
    Description copied from interface: RedisStreamCommands
    
    Append the given record to the stream stored at Record#getStream. If you prefer manual id assignment over server generated ones make sure to provide an id via Record#withId.
    
    Specified by:
    
    xAdd in interface RedisStreamCommands
    
    Parameters:
    
    record - the record to append.
    
    options - additional options (eg. MAXLEN). Must not be null, use RedisStreamCommands.XAddOptions.none() instead.
    
    Returns:
    
    the id after save. null when used in pipeline / transaction.
  - xClaimJustId
```
public List<RecordId> xClaimJustId(byte[] key,
                                   String group,
                                   String newOwner,
                                   RedisStreamCommands.XClaimOptions options)
```
    Description copied from interface: RedisStreamCommands
    
    Change the ownership of a pending message to the given new consumer without increasing the delivered count.
    
    Specified by:
    
    xClaimJustId in interface RedisStreamCommands
    
    Parameters:
    
    key - the key the stream is stored at.
    
    group - the name of the consumer group.
    
    newOwner - the name of the new consumer.
    
    options - must not be null.
    
    Returns:
    
    list of ids that changed user.
    
    See Also:
    
    Redis Documentation: XCLAIM
  - xClaim
```
public List<ByteRecord> xClaim(byte[] key,
                               String group,
                               String newOwner,
                               RedisStreamCommands.XClaimOptions options)
```
    Description copied from interface: RedisStreamCommands
    
    Change the ownership of a pending message to the given new consumer.
    
    Specified by:
    
    xClaim in interface RedisStreamCommands
    
    Parameters:
    
    key - the key the stream is stored at.
    
    group - the name of the consumer group.
    
    newOwner - the name of the new consumer.
    
    options - must not be null.
    
    Returns:
    
    list of ByteRecord that changed user.
    
    See Also:
    
    Redis Documentation: XCLAIM
  - xDel
```
public Long xDel(byte[] key,
                 RecordId... recordIds)
```
    Description copied from interface: RedisStreamCommands
    
    Removes the records with the given id's from the stream. Returns the number of items deleted, that may be different from the number of id's passed in case certain id's do not exist.
    
    Specified by:
    
    xDel in interface RedisStreamCommands
    
    Parameters:
    
    key - the key the stream is stored at.
    
    recordIds - the id's of the records to remove.
    
    Returns:
    
    number of removed entries. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: XDEL
  - xGroupCreate
```
public String xGroupCreate(byte[] key,
                           String groupName,
                           ReadOffset readOffset)
```
    Description copied from interface: RedisStreamCommands
    
    Create a consumer group.
    
    Specified by:
    
    xGroupCreate in interface RedisStreamCommands
    
    Parameters:
    
    key - the key the stream is stored at.
    
    groupName - name of the consumer group to create.
    
    readOffset - the offset to start at.
    
    Returns:
    
    ok if successful. null when used in pipeline / transaction.
  - xGroupCreate
```
public String xGroupCreate(byte[] key,
                           String groupName,
                           ReadOffset readOffset,
                           boolean mkStream)
```
    Description copied from interface: RedisStreamCommands
    
    Create a consumer group.
    
    Specified by:
    
    xGroupCreate in interface RedisStreamCommands
    
    Parameters:
    
    key - the key the stream is stored at.
    
    groupName - name of the consumer group to create.
    
    readOffset - the offset to start at.
    
    mkStream - if true the group will create the stream if not already present (MKSTREAM)
    
    Returns:
    
    ok if successful. null when used in pipeline / transaction.
  - xGroupDelConsumer
```
public Boolean xGroupDelConsumer(byte[] key,
                                 Consumer consumer)
```
    Description copied from interface: RedisStreamCommands
    
    Delete a consumer from a consumer group.
    
    Specified by:
    
    xGroupDelConsumer in interface RedisStreamCommands
    
    Parameters:
    
    key - the key the stream is stored at.
    
    consumer - consumer identified by group name and consumer name.
    
    Returns:
    
    true if successful. null when used in pipeline / transaction.
  - xGroupDestroy
```
public Boolean xGroupDestroy(byte[] key,
                             String groupName)
```
    Description copied from interface: RedisStreamCommands
    
    Destroy a consumer group.
    
    Specified by:
    
    xGroupDestroy in interface RedisStreamCommands
    
    Parameters:
    
    key - the key the stream is stored at.
    
    groupName - name of the consumer group.
    
    Returns:
    
    true if successful. null when used in pipeline / transaction.
  - xInfo
```
public StreamInfo.XInfoStream xInfo(byte[] key)
```
    Description copied from interface: RedisStreamCommands
    
    Obtain general information about the stream stored at the specified key.
    
    Specified by:
    
    xInfo in interface RedisStreamCommands
    
    Parameters:
    
    key - the key the stream is stored at.
    
    Returns:
    
    null when used in pipeline / transaction.
  - xInfoGroups
```
public StreamInfo.XInfoGroups xInfoGroups(byte[] key)
```
    Description copied from interface: RedisStreamCommands
    
    Obtain information about consumer groups associated with the stream stored at the specified key.
    
    Specified by:
    
    xInfoGroups in interface RedisStreamCommands
    
    Parameters:
    
    key - the key the stream is stored at.
    
    Returns:
    
    null when used in pipeline / transaction.
  - xInfoConsumers
```
public StreamInfo.XInfoConsumers xInfoConsumers(byte[] key,
                                                String groupName)
```
    Description copied from interface: RedisStreamCommands
    
    Obtain information about every consumer in a specific consumer group for the stream stored at the specified key.
    
    Specified by:
    
    xInfoConsumers in interface RedisStreamCommands
    
    Parameters:
    
    key - the key the stream is stored at.
    
    groupName - name of the consumer group.
    
    Returns:
    
    null when used in pipeline / transaction.
  - xLen
```
public Long xLen(byte[] key)
```
    Description copied from interface: RedisStreamCommands
    
    Get the length of a stream.
    
    Specified by:
    
    xLen in interface RedisStreamCommands
    
    Parameters:
    
    key - the key the stream is stored at.
    
    Returns:
    
    length of the stream. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: XLEN
  - xPending
```
public PendingMessagesSummary xPending(byte[] key,
                                       String groupName)
```
    Description copied from interface: RedisStreamCommands
    
    Obtain the PendingMessagesSummary for a given consumer group.
    
    Specified by:
    
    xPending in interface RedisStreamCommands
    
    Parameters:
    
    key - the key the stream is stored at. Must not be null.
    
    groupName - the name of the consumer group. Must not be null.
    
    Returns:
    
    a summary of pending messages within the given consumer group or null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: xpending
  - xPending
```
public PendingMessages xPending(byte[] key,
                                String groupName,
                                RedisStreamCommands.XPendingOptions options)
```
    Description copied from interface: RedisStreamCommands
    
    Obtain detailed information about pending messages applying given options.
    
    Specified by:
    
    xPending in interface RedisStreamCommands
    
    Parameters:
    
    key - the key the stream is stored at. Must not be null.
    
    groupName - the name of the consumer group. Must not be null.
    
    options - the options containing range, consumer and count. Must not be null.
    
    Returns:
    
    pending messages matching given criteria or null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: xpending
  - xRange
```
public List<ByteRecord> xRange(byte[] key,
                               Range<String> range,
                               RedisZSetCommands.Limit limit)
```
    Description copied from interface: RedisStreamCommands
    
    Retrieve a limited number of records within a specific Range from the stream stored at key.
    Use Range.unbounded() to read from the minimum and the maximum ID possible.
    Use RedisZSetCommands.Limit.unlimited() to read all records.
    
    Specified by:
    
    xRange in interface RedisStreamCommands
    
    Parameters:
    
    key - the key the stream is stored at.
    
    range - must not be null.
    
    limit - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: XRANGE
  - xRead
```
public List<ByteRecord> xRead(StreamReadOptions readOptions,
                              StreamOffset<byte[]>... streams)
```
    Description copied from interface: RedisStreamCommands
    
    Read records from one or more StreamOffsets.
    
    Specified by:
    
    xRead in interface RedisStreamCommands
    
    Parameters:
    
    readOptions - read arguments.
    
    streams - the streams to read from.
    
    Returns:
    
    null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: XREAD
  - xReadGroup
```
public List<ByteRecord> xReadGroup(Consumer consumer,
                                   StreamReadOptions readOptions,
                                   StreamOffset<byte[]>... streams)
```
    Description copied from interface: RedisStreamCommands
    
    Read records from one or more StreamOffsets using a consumer group.
    
    Specified by:
    
    xReadGroup in interface RedisStreamCommands
    
    Parameters:
    
    consumer - consumer/group.
    
    readOptions - read arguments.
    
    streams - the streams to read from.
    
    Returns:
    
    list with members of the resulting stream. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: XREADGROUP
  - xRevRange
```
public List<ByteRecord> xRevRange(byte[] key,
                                  Range<String> range,
                                  RedisZSetCommands.Limit limit)
```
    Description copied from interface: RedisStreamCommands
    
    Read records from a stream within a specific Range applying a RedisZSetCommands.Limit in reverse order.
    
    Specified by:
    
    xRevRange in interface RedisStreamCommands
    
    Parameters:
    
    key - the stream key.
    
    range - must not be null.
    
    limit - must not be null.
    
    Returns:
    
    list with members of the resulting stream. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: XREVRANGE
  - xTrim
```
public Long xTrim(byte[] key,
                  long count)
```
    Description copied from interface: RedisStreamCommands
    
    Trims the stream to count elements.
    
    Specified by:
    
    xTrim in interface RedisStreamCommands
    
    Parameters:
    
    key - the stream key.
    
    count - length of the stream.
    
    Returns:
    
    number of removed entries. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: XTRIM
  - xTrim
```
public Long xTrim(byte[] key,
                  long count,
                  boolean approximateTrimming)
```
    Description copied from interface: RedisStreamCommands
    
    Trims the stream to count elements.
    
    Specified by:
    
    xTrim in interface RedisStreamCommands
    
    Parameters:
    
    key - the stream key.
    
    count - length of the stream.
    
    approximateTrimming - the trimming must be performed in a approximated way in order to maximize performances.
    
    Returns:
    
    number of removed entries. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: XTRIM
  - setDeserializePipelineAndTxResults
```
public void setDeserializePipelineAndTxResults(boolean deserializePipelineAndTxResults)
```
    Specifies if pipelined and tx results should be deserialized to Strings. If false, results of closePipeline() and exec() will be of the type returned by the underlying connection
    
    Parameters:
    
    deserializePipelineAndTxResults - Whether or not to deserialize pipeline and tx results
  - bitField
```
public List<Long> bitField(byte[] key,
                           BitFieldSubCommands subCommands)
```
    Description copied from interface: RedisStringCommands
    
    Get / Manipulate specific integer fields of varying bit widths and arbitrary non (necessary) aligned offset stored at a given key.
    
    Specified by:
    
    bitField in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    subCommands - must not be null.
    
    Returns:
    
    null when used in pipeline / transaction.
  - bitfield
```
public List<Long> bitfield(String key,
                           BitFieldSubCommands operation)
```
    Description copied from interface: StringRedisConnection
    
    Get / Manipulate specific integer fields of varying bit widths and arbitrary non (necessary) aligned offset stored at a given key.
    
    Specified by:
    
    bitfield in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    operation - must not be null.
    
    Returns:
  - getDelegate
```
public RedisConnection getDelegate()
```
    Description copied from interface: DecoratedRedisConnection
    
    Gets the underlying RedisConnection.
    
    Specified by:
    
    getDelegate in interface DecoratedRedisConnection
    
    Returns:
    
    never null.

Class DefaultStringRedisConnection

Nested Class Summary

Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.StringRedisConnection

Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisStringCommands

Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisListCommands

Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisZSetCommands

Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisServerCommands

Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisStreamCommands

Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisGeoCommands

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.springframework.data.redis.connection.StringRedisConnection

Methods inherited from interface org.springframework.data.redis.connection.RedisConnection

Methods inherited from interface org.springframework.data.redis.connection.RedisKeyCommands

Methods inherited from interface org.springframework.data.redis.connection.RedisStringCommands

Methods inherited from interface org.springframework.data.redis.connection.RedisListCommands

Methods inherited from interface org.springframework.data.redis.connection.RedisZSetCommands

Methods inherited from interface org.springframework.data.redis.connection.RedisStreamCommands

Constructor Detail

DefaultStringRedisConnection

DefaultStringRedisConnection

Method Detail

append

bgSave

bgReWriteAof

bgWriteAof

bLPop

bRPop

bRPopLPush

close

copy

dbSize

decr

decrBy

del

unlink

discard

echo

exec

exists

exists

exists

expire

expireAt

flushAll

flushDb

get

getDel

getDel

getEx

getEx

getBit

getConfig

getNativeConnection

getRange

getSet

getSubscription

hDel

hExists

hGet

hGetAll

hIncrBy

hIncrBy

hKeys

hLen

hMGet

hMSet

hSet

hSetNX

hVals

incr

incrBy

incrBy

info

info

isClosed

isQueueing

isSubscribed

keys