public class DefaultStringRedisConnection extends Object implements StringRedisConnection, DecoratedRedisConnection
StringRedisConnection
.StringRedisConnection.StringTuple
RedisStringCommands.BitOperation, RedisStringCommands.SetOption
RedisListCommands.Position
RedisZSetCommands.Aggregate, RedisZSetCommands.Limit, RedisZSetCommands.Range, RedisZSetCommands.Tuple, RedisZSetCommands.Weights
RedisServerCommands.MigrateOption, RedisServerCommands.ShutdownOption
RedisStreamCommands.XAddOptions, RedisStreamCommands.XClaimOptions, RedisStreamCommands.XPendingOptions
RedisGeoCommands.DistanceUnit, RedisGeoCommands.GeoLocation<T>, RedisGeoCommands.GeoRadiusCommandArgs
Constructor and Description |
---|
DefaultStringRedisConnection(RedisConnection connection)
Constructs a new
DefaultStringRedisConnection instance. |
DefaultStringRedisConnection(RedisConnection connection,
RedisSerializer<String> serializer)
Constructs a new
DefaultStringRedisConnection instance. |
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. |
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[]) ). |
void |
close()
Closes (or quits) the connection.
|
List<Object> |
closePipeline()
Executes the commands in the pipeline and returns their result.
|
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)
|
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)
|
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)
|
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)
|
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.
|
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. |
RedisConnection |
getDelegate()
Gets the underlying
RedisConnection . |
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 |
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[] |
lPop(byte[] key)
Removes and returns first element in list stored at
key . |
String |
lPop(String key)
Removes and returns first element in list stored at
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[] sourceKey,
byte[] targetKey)
Rename key
sourceKey to targetKey . |
void |
rename(String oldName,
String newName)
Rename key
oleName to newName . |
Boolean |
renameNX(byte[] sourceKey,
byte[] targetKey)
Rename key
sourceKey to targetKey only if targetKey does not exist. |
Boolean |
renameNX(String oldName,
String newName)
Rename key
oleName to newName only if newName does not exist. |
void |
resetConfigStats()
Reset statistic counters on server.
|
void |
restore(byte[] key,
long ttlInMillis,
byte[] serializedValue,
boolean replace)
|
byte[] |
rPop(byte[] key)
Removes and returns last element in list stored at
key . |
String |
rPop(String key)
Removes and returns last element 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 . |
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. |
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)
|
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)
|
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)
|
List<ByteRecord> |
xRange(byte[] key,
Range<String> range,
RedisZSetCommands.Limit limit)
|
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(String key,
long count)
Trims the stream to
count elements. |
Boolean |
zAdd(byte[] key,
double score,
byte[] value)
Add
value to a sorted set at key , or update its score if it already exists. |
Long |
zAdd(byte[] key,
Set<RedisZSetCommands.Tuple> tuples)
Add
tuples to a sorted set at key , or update its score if it already exists. |
Boolean |
zAdd(String key,
double score,
String value)
Add
value to a sorted set at key , or update its score if it already exists. |
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 |
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 . |
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 . |
Long |
zInterStore(byte[] destKey,
byte[]... sets)
Intersect sorted
sets and store result in destination key . |
Long |
zInterStore(byte[] destKey,
RedisZSetCommands.Aggregate aggregate,
RedisZSetCommands.Weights weights,
byte[]... sets)
Intersect sorted
sets and store result in destination key . |
Long |
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<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)
|
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)
|
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)
|
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 |
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[]> |
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 . |
Long |
zUnionStore(byte[] destKey,
byte[]... sets)
Union sorted
sets and store result in destination key . |
Long |
zUnionStore(byte[] destKey,
RedisZSetCommands.Aggregate aggregate,
RedisZSetCommands.Weights weights,
byte[]... sets)
Union sorted
sets and store result in destination key . |
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 . |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
bitPos, entryIds, xAck, xAdd, xAdd, xClaim, xDel, xRange, xReadAsString, xReadAsString, xReadAsString, xReadGroupAsString, xReadGroupAsString, xReadGroupAsString, xRevRange
geoCommands, hashCommands, hyperLogLogCommands, keyCommands, listCommands, scriptingCommands, serverCommands, setCommands, streamCommands, stringCommands, zSetCommands
restore
bitPos
zInterStore, zUnionStore
public DefaultStringRedisConnection(RedisConnection connection)
DefaultStringRedisConnection
instance. Uses StringRedisSerializer
as
underlying serializer.connection
- Redis connectionpublic DefaultStringRedisConnection(RedisConnection connection, RedisSerializer<String> serializer)
DefaultStringRedisConnection
instance.connection
- Redis connectionserializer
- String serializerpublic Long append(byte[] key, byte[] value)
RedisStringCommands
value
to key
.append
in interface RedisStringCommands
key
- must not be null.value
- must not be null.public void bgSave()
RedisServerCommands
bgSave
in interface RedisServerCommands
public void bgReWriteAof()
RedisServerCommands
bgReWriteAof
in interface RedisServerCommands
@Deprecated public void bgWriteAof()
bgReWriteAof()
.RedisServerCommands
bgWriteAof
in interface RedisServerCommands
public List<byte[]> bLPop(int timeout, byte[]... keys)
RedisListCommands
keys
. timeout
reached.bLPop
in interface RedisListCommands
timeout
- seconds to block.keys
- must not be null.List
when no element could be popped and the timeout was reached. null when used
in pipeline / transaction.RedisListCommands.lPop(byte[])
public List<byte[]> bRPop(int timeout, byte[]... keys)
RedisListCommands
keys
. timeout
reached.bRPop
in interface RedisListCommands
timeout
- seconds to block.keys
- must not be null.List
when no element could be popped and the timeout was reached. null when used
in pipeline / transaction.RedisListCommands.rPop(byte[])
public byte[] bRPopLPush(int timeout, byte[] srcKey, byte[] dstKey)
RedisListCommands
srcKey
, append it to dstKey
and return its value. timeout
reached.bRPopLPush
in interface RedisListCommands
timeout
- seconds to block.srcKey
- must not be null.dstKey
- must not be null.RedisListCommands.rPopLPush(byte[], byte[])
public void close() throws RedisSystemException
RedisConnection
close
in interface AutoCloseable
close
in interface RedisConnection
RedisSystemException
public Long dbSize()
RedisServerCommands
dbSize
in interface RedisServerCommands
public Long decr(byte[] key)
RedisStringCommands
key
by 1.decr
in interface RedisStringCommands
key
- must not be null.public Long decrBy(byte[] key, long value)
RedisStringCommands
key
by value
.decrBy
in interface RedisStringCommands
key
- must not be null.public Long del(byte[]... keys)
RedisKeyCommands
keys
.del
in interface RedisKeyCommands
keys
- must not be null.public Long unlink(byte[]... keys)
RedisKeyCommands
keys
from the keyspace. Unlike with #del(byte[]...)
the actual memory reclaiming here
happens asynchronously.unlink
in interface RedisKeyCommands
keys
- must not be null.public void discard()
RedisTxCommands
RedisTxCommands.multi()
.discard
in interface RedisTxCommands
public byte[] echo(byte[] message)
RedisConnectionCommands
message
via server roundtrip.echo
in interface RedisConnectionCommands
message
- the message to echo.public List<Object> exec()
RedisTxCommands
RedisTxCommands.multi()
. #watch(byte[]...)
the operation will fail if any of watched keys has been modified.exec
in interface RedisTxCommands
public Boolean exists(byte[] key)
RedisKeyCommands
key
exists.exists
in interface RedisKeyCommands
key
- must not be null.public Long exists(String... keys)
StringRedisConnection
keys
exist.exists
in interface StringRedisConnection
keys
- must not be null.RedisKeyCommands.exists(byte[][])
public Long exists(byte[]... keys)
RedisKeyCommands
keys
exist. Providing the very same key
more than once also counts
multiple times.exists
in interface RedisKeyCommands
keys
- must not be null.public Boolean expire(byte[] key, long seconds)
RedisKeyCommands
key
in seconds.expire
in interface RedisKeyCommands
key
- must not be null.public Boolean expireAt(byte[] key, long unixTime)
RedisKeyCommands
key
as a UNIX timestamp.expireAt
in interface RedisKeyCommands
key
- must not be null.public void flushAll()
RedisServerCommands
flushAll
in interface RedisServerCommands
public void flushDb()
RedisServerCommands
flushDb
in interface RedisServerCommands
public byte[] get(byte[] key)
RedisStringCommands
key
.get
in interface RedisStringCommands
key
- must not be null.public Boolean getBit(byte[] key, long offset)
RedisStringCommands
offset
of value at key
.getBit
in interface RedisStringCommands
key
- must not be null.public Properties getConfig(String pattern)
RedisServerCommands
pattern
from server.getConfig
in interface RedisServerCommands
pattern
- must not be null.public Object getNativeConnection()
RedisConnection
getNativeConnection
in interface RedisConnection
public byte[] getRange(byte[] key, long start, long end)
RedisStringCommands
key
between start
and end
.getRange
in interface RedisStringCommands
key
- must not be null.public byte[] getSet(byte[] key, byte[] value)
RedisStringCommands
value
of key
and return its old value.getSet
in interface RedisStringCommands
key
- must not be null.value
- must not be null.public Subscription getSubscription()
RedisPubSubCommands
getSubscription
in interface RedisPubSubCommands
public Long hDel(byte[] key, byte[]... fields)
RedisHashCommands
fields
.hDel
in interface RedisHashCommands
key
- must not be null.fields
- must not be empty.public Boolean hExists(byte[] key, byte[] field)
RedisHashCommands
field
exists.hExists
in interface RedisHashCommands
key
- must not be null.field
- must not be null.public byte[] hGet(byte[] key, byte[] field)
RedisHashCommands
field
from hash at key
.hGet
in interface RedisHashCommands
key
- must not be null.field
- must not be null.public Map<byte[],byte[]> hGetAll(byte[] key)
RedisHashCommands
key
.hGetAll
in interface RedisHashCommands
key
- must not be null.Map
if key does not exist or null when used in pipeline / transaction.public Long hIncrBy(byte[] key, byte[] field, long delta)
RedisHashCommands
value
of a hash field
by the given delta
.hIncrBy
in interface RedisHashCommands
key
- must not be null.field
- must not be null.public Double hIncrBy(byte[] key, byte[] field, double delta)
RedisHashCommands
value
of a hash field
by the given delta
.hIncrBy
in interface RedisHashCommands
key
- must not be null.field
- must not be null.public Set<byte[]> hKeys(byte[] key)
RedisHashCommands
key
.hKeys
in interface RedisHashCommands
key
- must not be null.public Long hLen(byte[] key)
RedisHashCommands
key
.hLen
in interface RedisHashCommands
key
- must not be null.public List<byte[]> hMGet(byte[] key, byte[]... fields)
RedisHashCommands
fields
from hash at key
.hMGet
in interface RedisHashCommands
key
- must not be null.fields
- must not be empty.List
if key or fields do not exists. null when used in pipeline / transaction.public void hMSet(byte[] key, Map<byte[],byte[]> hashes)
RedisHashCommands
hashes
hMSet
in interface RedisHashCommands
key
- must not be null.hashes
- must not be null.public Boolean hSet(byte[] key, byte[] field, byte[] value)
RedisHashCommands
value
of a hash field
.hSet
in interface RedisHashCommands
key
- must not be null.field
- must not be null.value
- must not be null.public Boolean hSetNX(byte[] key, byte[] field, byte[] value)
RedisHashCommands
value
of a hash field
only if field
does not exist.hSetNX
in interface RedisHashCommands
key
- must not be null.field
- must not be null.value
- must not be null.public List<byte[]> hVals(byte[] key)
RedisHashCommands
field
.hVals
in interface RedisHashCommands
key
- must not be null.List
if key does not exist. null when used in pipeline / transaction.public Long incr(byte[] key)
RedisStringCommands
key
by 1.incr
in interface RedisStringCommands
key
- must not be null.public Long incrBy(byte[] key, long value)
RedisStringCommands
key
by delta
.incrBy
in interface RedisStringCommands
key
- must not be null.public Double incrBy(byte[] key, double value)
RedisStringCommands
key
by delta
.incrBy
in interface RedisStringCommands
key
- must not be null.public Properties info()
RedisServerCommands
info
in interface RedisServerCommands
public Properties info(String section)
RedisServerCommands
selection
.info
in interface RedisServerCommands
public boolean isClosed()
RedisConnection
isClosed
in interface RedisConnection
public boolean isQueueing()
RedisConnection
isQueueing
in interface RedisConnection
public boolean isSubscribed()
RedisPubSubCommands
isSubscribed
in interface RedisPubSubCommands
public Set<byte[]> keys(byte[] pattern)
RedisKeyCommands
pattern
.keys
in interface RedisKeyCommands
pattern
- must not be null.Set
if no match found. null when used in pipeline / transaction.public Long lastSave()
RedisServerCommands
RedisServerCommands.bgSave()
operation in seconds.lastSave
in interface RedisServerCommands
public byte[] lIndex(byte[] key, long index)
RedisListCommands
index
form list at key
.lIndex
in interface RedisListCommands
key
- must not be null.index
- zero based index value. Use negative number to designate elements starting at the tail.public Long lInsert(byte[] key, RedisListCommands.Position where, byte[] pivot, byte[] value)
RedisListCommands
value
RedisListCommands.Position.BEFORE
or RedisListCommands.Position.AFTER
existing pivot
for key
.lInsert
in interface RedisListCommands
key
- must not be null.where
- must not be null.pivot
- must not be null.value
- must not be null.public Long lLen(byte[] key)
RedisListCommands
key
.lLen
in interface RedisListCommands
key
- must not be null.public byte[] lPop(byte[] key)
RedisListCommands
key
.lPop
in interface RedisListCommands
key
- must not be null.public Long lPush(byte[] key, byte[]... values)
RedisListCommands
values
to key
.lPush
in interface RedisListCommands
key
- must not be null.values
- must not be empty.public Long lPushX(byte[] key, byte[] value)
RedisListCommands
values
to key
only if the list exists.lPushX
in interface RedisListCommands
key
- must not be null.value
- must not be null.public List<byte[]> lRange(byte[] key, long start, long end)
RedisListCommands
start
and end
from list at key
.lRange
in interface RedisListCommands
key
- must not be null.List
if key does not exists or range does not contain values. null when used in
pipeline / transaction.public Long lRem(byte[] key, long count, byte[] value)
RedisListCommands
count
occurrences of value
from the list stored at key
.lRem
in interface RedisListCommands
key
- must not be null.public void lSet(byte[] key, long index, byte[] value)
RedisListCommands
value
list element at index
.lSet
in interface RedisListCommands
key
- must not be null.public void lTrim(byte[] key, long start, long end)
RedisListCommands
key
to elements between start
and end
.lTrim
in interface RedisListCommands
key
- must not be null.public List<byte[]> mGet(byte[]... keys)
RedisStringCommands
keys
. Values are returned in the order of the requested keys.mGet
in interface RedisStringCommands
keys
- must not be null.List
if keys do not exist or when used in pipeline / transaction.public Boolean mSet(Map<byte[],byte[]> tuple)
RedisStringCommands
tuple
.mSet
in interface RedisStringCommands
tuple
- must not be null.public Boolean mSetNX(Map<byte[],byte[]> tuple)
RedisStringCommands
tuple
only if the provided key does
not exist.mSetNX
in interface RedisStringCommands
tuple
- must not be null.public void multi()
RedisTxCommands
RedisTxCommands.exec()
or rolled back using RedisTxCommands.discard()
multi
in interface RedisTxCommands
public Boolean persist(byte[] key)
RedisKeyCommands
key
.persist
in interface RedisKeyCommands
key
- must not be null.public Boolean move(byte[] key, int dbIndex)
RedisKeyCommands
key
to database with index
.move
in interface RedisKeyCommands
key
- must not be null.public String ping()
RedisConnectionCommands
ping
in interface RedisConnectionCommands
public void pSubscribe(MessageListener listener, byte[]... patterns)
RedisPubSubCommands
Note that this operation is blocking and the current thread starts waiting for new messages immediately.
pSubscribe
in interface RedisPubSubCommands
listener
- message listener, must not be null.patterns
- channel name patterns, must not be null.public Long publish(byte[] channel, byte[] message)
RedisPubSubCommands
publish
in interface RedisPubSubCommands
channel
- the channel to publish to. Must not be null.message
- message to publish. Must not be null.public byte[] randomKey()
RedisKeyCommands
randomKey
in interface RedisKeyCommands
public void rename(byte[] sourceKey, byte[] targetKey)
RedisKeyCommands
sourceKey
to targetKey
.rename
in interface RedisKeyCommands
sourceKey
- must not be null.targetKey
- must not be null.public Boolean renameNX(byte[] sourceKey, byte[] targetKey)
RedisKeyCommands
sourceKey
to targetKey
only if targetKey
does not exist.renameNX
in interface RedisKeyCommands
sourceKey
- must not be null.targetKey
- must not be null.public void resetConfigStats()
RedisServerCommands
RedisServerCommands.info()
.resetConfigStats
in interface RedisServerCommands
public byte[] rPop(byte[] key)
RedisListCommands
key
.rPop
in interface RedisListCommands
key
- must not be null.public byte[] rPopLPush(byte[] srcKey, byte[] dstKey)
RedisListCommands
srcKey
, append it to dstKey
and return its value.rPopLPush
in interface RedisListCommands
srcKey
- must not be null.dstKey
- must not be null.public Long rPush(byte[] key, byte[]... values)
RedisListCommands
values
to key
.rPush
in interface RedisListCommands
key
- must not be null.values
- must not be empty.public Long rPushX(byte[] key, byte[] value)
RedisListCommands
values
to key
only if the list exists.rPushX
in interface RedisListCommands
key
- must not be null.value
- must not be null.public Long sAdd(byte[] key, byte[]... values)
RedisSetCommands
values
to set at key
.sAdd
in interface RedisSetCommands
key
- must not be null.values
- must not be empty.public void save()
RedisServerCommands
save
in interface RedisServerCommands
public Long sCard(byte[] key)
RedisSetCommands
key
.sCard
in interface RedisSetCommands
key
- must not be null.public Set<byte[]> sDiff(byte[]... keys)
RedisSetCommands
keys
.sDiff
in interface RedisSetCommands
keys
- must not be null.public Long sDiffStore(byte[] destKey, byte[]... keys)
RedisSetCommands
keys
and store result in destKey
.sDiffStore
in interface RedisSetCommands
destKey
- must not be null.keys
- must not be null.public void select(int dbIndex)
RedisConnectionCommands
dbIndex
.select
in interface RedisConnectionCommands
dbIndex
- the database index.public Boolean set(byte[] key, byte[] value)
RedisStringCommands
value
for key
.set
in interface RedisStringCommands
key
- must not be null.value
- must not be null.public Boolean set(byte[] key, byte[] value, Expiration expiration, RedisStringCommands.SetOption option)
RedisStringCommands
value
for key
applying timeouts from expiration
if set and inserting/updating values
depending on option
.set
in interface RedisStringCommands
key
- must not be null.value
- must not be null.expiration
- must not be null. Use Expiration.persistent()
to not set any ttl.option
- must not be null. Use RedisStringCommands.SetOption.upsert()
to add non existing.public Boolean setBit(byte[] key, long offset, boolean value)
RedisStringCommands
offset
in value stored at key
.setBit
in interface RedisStringCommands
key
- must not be null.offset
or null when used in pipeline / transaction.public void setConfig(String param, String value)
RedisServerCommands
param
to value
.setConfig
in interface RedisServerCommands
param
- must not be null.value
- must not be null.public Boolean setEx(byte[] key, long seconds, byte[] value)
RedisStringCommands
value
and expiration in seconds
for key
.setEx
in interface RedisStringCommands
key
- must not be null.value
- must not be null.public Boolean pSetEx(byte[] key, long milliseconds, byte[] value)
RedisStringCommands
value
and expiration in milliseconds
for key
.pSetEx
in interface RedisStringCommands
key
- must not be null.value
- must not be null.public Boolean setNX(byte[] key, byte[] value)
RedisStringCommands
value
for key
, only if key
does not exist.setNX
in interface RedisStringCommands
key
- must not be null.value
- must not be null.public void setRange(byte[] key, byte[] value, long start)
RedisStringCommands
key
starting at the specified offset
with given value
.setRange
in interface RedisStringCommands
key
- must not be null.public void shutdown()
RedisServerCommands
shutdown
in interface RedisServerCommands
public void shutdown(RedisServerCommands.ShutdownOption option)
RedisServerCommands
shutdown
in interface RedisServerCommands
public Set<byte[]> sInter(byte[]... keys)
RedisSetCommands
keys
.sInter
in interface RedisSetCommands
keys
- must not be null.Set
if no intersection found. null when used in pipeline / transaction.public Long sInterStore(byte[] destKey, byte[]... keys)
RedisSetCommands
keys
and store result in destKey
.sInterStore
in interface RedisSetCommands
destKey
- must not be null.keys
- must not be null.public Boolean sIsMember(byte[] key, byte[] value)
RedisSetCommands
key
contains value
.sIsMember
in interface RedisSetCommands
key
- must not be null.value
- must not be null.public Set<byte[]> sMembers(byte[] key)
RedisSetCommands
key
.sMembers
in interface RedisSetCommands
key
- must not be null.Set
when key does not exist. null when used in pipeline / transaction.public Boolean sMove(byte[] srcKey, byte[] destKey, byte[] value)
RedisSetCommands
value
from srcKey
to destKey
sMove
in interface RedisSetCommands
srcKey
- must not be null.destKey
- must not be null.value
- must not be null.public Long sort(byte[] key, SortParameters params, byte[] storeKey)
RedisKeyCommands
key
and store result in storeKey
.sort
in interface RedisKeyCommands
key
- must not be null.params
- must not be null.storeKey
- must not be null.public List<byte[]> sort(byte[] key, SortParameters params)
RedisKeyCommands
key
.sort
in interface RedisKeyCommands
key
- must not be null.params
- must not be null.public ValueEncoding encodingOf(byte[] key)
RedisKeyCommands
key
.encodingOf
in interface RedisKeyCommands
key
- must not be null.ValueEncoding.RedisValueEncoding.VACANT
if key does not
exist or null when used in pipeline / transaction.public Duration idletime(byte[] key)
RedisKeyCommands
Duration
since the object stored at the given key
is idle.idletime
in interface RedisKeyCommands
key
- must not be null.public Long refcount(byte[] key)
RedisKeyCommands
key
.refcount
in interface RedisKeyCommands
key
- must not be null.public byte[] sPop(byte[] key)
RedisSetCommands
key
.sPop
in interface RedisSetCommands
key
- must not be null.public List<byte[]> sPop(byte[] key, long count)
RedisSetCommands
count
random members from set at key
.sPop
in interface RedisSetCommands
key
- must not be null.count
- number of random members to pop from the set.List
if set does not exist. null when used in pipeline / transaction.public byte[] sRandMember(byte[] key)
RedisSetCommands
key
.sRandMember
in interface RedisSetCommands
key
- must not be null.public List<byte[]> sRandMember(byte[] key, long count)
RedisSetCommands
count
random elements from set at key
.sRandMember
in interface RedisSetCommands
key
- must not be null.public Long sRem(byte[] key, byte[]... values)
RedisSetCommands
values
from set at key
and return the number of removed elements.sRem
in interface RedisSetCommands
key
- must not be null.values
- must not be empty.public Long strLen(byte[] key)
RedisStringCommands
key
.strLen
in interface RedisStringCommands
key
- must not be null.public Long bitCount(byte[] key)
RedisStringCommands
key
.bitCount
in interface RedisStringCommands
key
- must not be null.public Long bitCount(byte[] key, long start, long end)
RedisStringCommands
key
between start
and
end
.bitCount
in interface RedisStringCommands
key
- must not be null.public Long bitOp(RedisStringCommands.BitOperation op, byte[] destination, byte[]... keys)
RedisStringCommands
bitOp
in interface RedisStringCommands
op
- must not be null.destination
- must not be null.keys
- must not be null.@Nullable public Long bitPos(byte[] key, boolean bit, Range<Long> range)
RedisStringCommands
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.bitPos
in interface RedisStringCommands
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.public void subscribe(MessageListener listener, byte[]... channels)
RedisPubSubCommands
Note that this operation is blocking and the current thread starts waiting for new messages immediately.
subscribe
in interface RedisPubSubCommands
listener
- message listener, must not be null.channels
- channel names, must not be null.public Set<byte[]> sUnion(byte[]... keys)
RedisSetCommands
keys
.sUnion
in interface RedisSetCommands
keys
- must not be null.Set
if keys do not exist. null when used in pipeline / transaction.public Long sUnionStore(byte[] destKey, byte[]... keys)
RedisSetCommands
keys
and store result in destKey
.sUnionStore
in interface RedisSetCommands
destKey
- must not be null.keys
- must not be null.public Long ttl(byte[] key)
RedisKeyCommands
key
in seconds.ttl
in interface RedisKeyCommands
key
- must not be null.public Long ttl(byte[] key, TimeUnit timeUnit)
RedisKeyCommands
key
in and convert it to the given TimeUnit
.ttl
in interface RedisKeyCommands
key
- must not be null.timeUnit
- must not be null.public DataType type(byte[] key)
RedisKeyCommands
key
.type
in interface RedisKeyCommands
key
- must not be null.public Long touch(byte[]... keys)
RedisKeyCommands
key(s)
.touch
in interface RedisKeyCommands
keys
- must not be null.public void unwatch()
RedisTxCommands
#watch(byte[]...)
keys.unwatch
in interface RedisTxCommands
public void watch(byte[]... keys)
RedisTxCommands
keys
for modifications during transaction started with RedisTxCommands.multi()
.watch
in interface RedisTxCommands
keys
- must not be null.public Boolean zAdd(byte[] key, double score, byte[] value)
RedisZSetCommands
value
to a sorted set at key
, or update its score
if it already exists.zAdd
in interface RedisZSetCommands
key
- must not be null.score
- the score.value
- the value.public Long zAdd(byte[] key, Set<RedisZSetCommands.Tuple> tuples)
RedisZSetCommands
tuples
to a sorted set at key
, or update its score
if it already exists.zAdd
in interface RedisZSetCommands
key
- must not be null.tuples
- must not be null.public Long zCard(byte[] key)
RedisZSetCommands
key
.zCard
in interface RedisZSetCommands
key
- must not be null.public Long zCount(byte[] key, double min, double max)
RedisZSetCommands
min
and max
.zCount
in interface RedisZSetCommands
key
- must not be null.public Long zCount(byte[] key, RedisZSetCommands.Range range)
RedisZSetCommands
Range#min
and Range#max
.zCount
in interface RedisZSetCommands
key
- must not be null.range
- must not be null.public Double zIncrBy(byte[] key, double increment, byte[] value)
RedisZSetCommands
value
in sorted set by increment
.zIncrBy
in interface RedisZSetCommands
key
- must not be null.value
- the value.public Long zInterStore(byte[] destKey, RedisZSetCommands.Aggregate aggregate, RedisZSetCommands.Weights weights, byte[]... sets)
RedisZSetCommands
sets
and store result in destination key
.zInterStore
in interface RedisZSetCommands
destKey
- must not be null.aggregate
- must not be null.weights
- must not be null.sets
- must not be null.public Long zInterStore(byte[] destKey, byte[]... sets)
RedisZSetCommands
sets
and store result in destination key
.zInterStore
in interface RedisZSetCommands
destKey
- must not be null.sets
- must not be null.public Set<byte[]> zRange(byte[] key, long start, long end)
RedisZSetCommands
start
and end
from sorted set.zRange
in interface RedisZSetCommands
key
- must not be null.Set
when key does not exists or no members in range. null when used in pipeline /
transaction.public Set<byte[]> zRangeByScore(byte[] key, double min, double max, long offset, long count)
RedisZSetCommands
start
to end
where score is between min
and max
from
sorted set.zRangeByScore
in interface RedisZSetCommands
key
- must not be null.Set
when key does not exists or no members in range. null when used in pipeline /
transaction.public Set<byte[]> zRangeByScore(byte[] key, RedisZSetCommands.Range range)
RedisZSetCommands
Range#min
and Range#max
from sorted set.zRangeByScore
in interface RedisZSetCommands
key
- must not be null.range
- must not be null.public Set<byte[]> zRangeByScore(byte[] key, RedisZSetCommands.Range range, RedisZSetCommands.Limit limit)
RedisZSetCommands
Limit#count
to Limit#offset
where score is between Range#min
and
Range#max
from sorted set.zRangeByScore
in interface RedisZSetCommands
key
- must not be null.range
- must not be null.limit
- must not be null.public Set<RedisZSetCommands.Tuple> zRangeByScoreWithScores(byte[] key, RedisZSetCommands.Range range)
RedisZSetCommands
zRangeByScoreWithScores
in interface RedisZSetCommands
key
- must not be null.range
- must not be null.Set
when key does not exists or no members in range. null when used in pipeline /
transaction.public Set<byte[]> zRangeByScore(byte[] key, double min, double max)
RedisZSetCommands
min
and max
from sorted set.zRangeByScore
in interface RedisZSetCommands
key
- must not be null.Set
when key does not exists or no members in range. null when used in pipeline /
transaction.public Set<RedisZSetCommands.Tuple> zRangeByScoreWithScores(byte[] key, double min, double max, long offset, long count)
RedisZSetCommands
RedisZSetCommands.Tuple
s in range from start
to end
where score is between min
and
max
from sorted set.zRangeByScoreWithScores
in interface RedisZSetCommands
key
- must not be null.Set
when key does not exists or no members in range. null when used in pipeline /
transaction.public Set<RedisZSetCommands.Tuple> zRangeByScoreWithScores(byte[] key, RedisZSetCommands.Range range, RedisZSetCommands.Limit limit)
RedisZSetCommands
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.zRangeByScoreWithScores
in interface RedisZSetCommands
key
- must not be null.range
- must not be null.limit
- must not be null.Set
when key does not exists or no members in range. null when used in pipeline /
transaction.public Set<RedisZSetCommands.Tuple> zRangeByScoreWithScores(byte[] key, double min, double max)
RedisZSetCommands
zRangeByScoreWithScores
in interface RedisZSetCommands
key
- must not be null.Set
when key does not exists or no members in range. null when used in pipeline /
transaction.public Set<RedisZSetCommands.Tuple> zRangeWithScores(byte[] key, long start, long end)
RedisZSetCommands
zRangeWithScores
in interface RedisZSetCommands
key
- must not be null.Set
when key does not exists or no members in range. null when used in pipeline /
transaction.public Set<byte[]> zRevRangeByScore(byte[] key, double min, double max, long offset, long count)
RedisZSetCommands
start
to end
where score is between min
and max
from
sorted set ordered high -> low.zRevRangeByScore
in interface RedisZSetCommands
key
- must not be null.public Set<byte[]> zRevRangeByScore(byte[] key, RedisZSetCommands.Range range)
RedisZSetCommands
Range#min
and Range#max
from sorted set ordered from high to
low.zRevRangeByScore
in interface RedisZSetCommands
key
- must not be null.range
- must not be null.Set
when key does not exists or no members in range. null when used in pipeline /
transaction.public Set<byte[]> zRevRangeByScore(byte[] key, double min, double max)
RedisZSetCommands
min
and max
from sorted set ordered from high to low.zRevRangeByScore
in interface RedisZSetCommands
key
- must not be null.Set
when key does not exists or no members in range. null when used in pipeline /
transaction.public Set<byte[]> zRevRangeByScore(byte[] key, RedisZSetCommands.Range range, RedisZSetCommands.Limit limit)
RedisZSetCommands
Limit#offset
to Limit#offset + Limit#count
where score is between
Range#min
and Range#max
from sorted set ordered high -> low.zRevRangeByScore
in interface RedisZSetCommands
key
- must not be null.range
- must not be null.limit
- must not be null.public Set<RedisZSetCommands.Tuple> zRevRangeByScoreWithScores(byte[] key, double min, double max, long offset, long count)
RedisZSetCommands
RedisZSetCommands.Tuple
in range from start
to end
where score is between min
and
max
from sorted set ordered high -> low.zRevRangeByScoreWithScores
in interface RedisZSetCommands
key
- must not be null.public Set<RedisZSetCommands.Tuple> zRevRangeByScoreWithScores(byte[] key, RedisZSetCommands.Range range)
RedisZSetCommands
RedisZSetCommands.Tuple
where score is between Range#min
and Range#max
from sorted set ordered
from high to low.zRevRangeByScoreWithScores
in interface RedisZSetCommands
key
- must not be null.range
- must not be null.public Set<RedisZSetCommands.Tuple> zRevRangeByScoreWithScores(byte[] key, RedisZSetCommands.Range range, RedisZSetCommands.Limit limit)
RedisZSetCommands
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.zRevRangeByScoreWithScores
in interface RedisZSetCommands
key
- must not be null.range
- must not be null.limit
- must not be null.public Set<RedisZSetCommands.Tuple> zRevRangeByScoreWithScores(byte[] key, double min, double max)
RedisZSetCommands
RedisZSetCommands.Tuple
where score is between min
and max
from sorted set ordered from high to
low.zRevRangeByScoreWithScores
in interface RedisZSetCommands
key
- must not be null.Set
when key does not exists or no members in range. null when used in pipeline /
transaction.public Long zRank(byte[] key, byte[] value)
RedisZSetCommands
value
in a sorted set.zRank
in interface RedisZSetCommands
key
- must not be null.value
- the value. Must not be null.public Long zRem(byte[] key, byte[]... values)
RedisZSetCommands
values
from sorted set. Return number of removed elements.zRem
in interface RedisZSetCommands
key
- must not be null.values
- must not be null.public Long zRemRange(byte[] key, long start, long end)
RedisZSetCommands
start
and end
from sorted set with key
.zRemRange
in interface RedisZSetCommands
key
- must not be null.public Long zRemRangeByScore(byte[] key, double min, double max)
RedisZSetCommands
min
and max
from sorted set with key
.zRemRangeByScore
in interface RedisZSetCommands
key
- must not be null.public Long zRemRangeByScore(byte[] key, RedisZSetCommands.Range range)
RedisZSetCommands
Range#min
and Range#max
from sorted set with key
.zRemRangeByScore
in interface RedisZSetCommands
key
- must not be null.range
- must not be null.public Set<byte[]> zRevRange(byte[] key, long start, long end)
RedisZSetCommands
start
to end
from sorted set ordered from high to low.zRevRange
in interface RedisZSetCommands
key
- must not be null.Set
when key does not exists or no members in range. null when used in pipeline /
transaction.public Set<RedisZSetCommands.Tuple> zRevRangeWithScores(byte[] key, long start, long end)
RedisZSetCommands
RedisZSetCommands.Tuple
s in range from start
to end
from sorted set ordered from high to low.zRevRangeWithScores
in interface RedisZSetCommands
key
- must not be null.Set
when key does not exists or no members in range. null when used in pipeline /
transaction.public Long zRevRank(byte[] key, byte[] value)
RedisZSetCommands
value
in a sorted set when scored high to low.zRevRank
in interface RedisZSetCommands
key
- must not be null.value
- the value.public Double zScore(byte[] key, byte[] value)
RedisZSetCommands
value
from sorted set with key key
.zScore
in interface RedisZSetCommands
key
- must not be null.value
- the value.public Long zUnionStore(byte[] destKey, RedisZSetCommands.Aggregate aggregate, RedisZSetCommands.Weights weights, byte[]... sets)
RedisZSetCommands
sets
and store result in destination key
.zUnionStore
in interface RedisZSetCommands
destKey
- must not be null.aggregate
- must not be null.weights
- must not be null.sets
- must not be null.public Long zUnionStore(byte[] destKey, byte[]... sets)
RedisZSetCommands
sets
and store result in destination key
.zUnionStore
in interface RedisZSetCommands
destKey
- must not be null.sets
- must not be null.public Boolean pExpire(byte[] key, long millis)
RedisKeyCommands
key
in milliseconds.pExpire
in interface RedisKeyCommands
key
- must not be null.public Boolean pExpireAt(byte[] key, long unixTimeInMillis)
RedisKeyCommands
key
as a UNIX timestamp in milliseconds.pExpireAt
in interface RedisKeyCommands
key
- must not be null.public Long pTtl(byte[] key)
RedisKeyCommands
key
in milliseconds.pTtl
in interface RedisKeyCommands
key
- must not be null.public Long pTtl(byte[] key, TimeUnit timeUnit)
RedisKeyCommands
key
in and convert it to the given TimeUnit
.pTtl
in interface RedisKeyCommands
key
- must not be null.timeUnit
- must not be null.public byte[] dump(byte[] key)
RedisKeyCommands
key
.dump
in interface RedisKeyCommands
key
- must not be null.public void restore(byte[] key, long ttlInMillis, byte[] serializedValue, boolean replace)
RedisKeyCommands
restore
in interface RedisKeyCommands
key
- must not be null.serializedValue
- must not be null.replace
- use true to replace a potentially existing value instead of erroring.public void scriptFlush()
RedisScriptingCommands
scriptFlush
in interface RedisScriptingCommands
public void scriptKill()
RedisScriptingCommands
scriptKill
in interface RedisScriptingCommands
public String scriptLoad(byte[] script)
RedisScriptingCommands
#evalSha(byte[], ReturnType, int, byte[]...)
.scriptLoad
in interface RedisScriptingCommands
script
- must not be null.public List<Boolean> scriptExists(String... scriptSha1)
RedisScriptingCommands
scriptShas
exist in script cache.scriptExists
in interface RedisScriptingCommands
List
or null when used in pipeline /
transaction.public <T> T eval(byte[] script, ReturnType returnType, int numKeys, byte[]... keysAndArgs)
RedisScriptingCommands
script
.eval
in interface RedisScriptingCommands
script
- must not be null.returnType
- must not be null.keysAndArgs
- must not be null.public <T> T evalSha(String scriptSha1, ReturnType returnType, int numKeys, byte[]... keysAndArgs)
RedisScriptingCommands
scriptSha
.evalSha
in interface RedisScriptingCommands
scriptSha1
- must not be null.returnType
- must not be null.keysAndArgs
- must not be null.public <T> T evalSha(byte[] scriptSha1, ReturnType returnType, int numKeys, byte[]... keysAndArgs)
RedisScriptingCommands
scriptSha
.evalSha
in interface RedisScriptingCommands
scriptSha1
- must not be null.returnType
- must not be null.keysAndArgs
- must not be null.public Long append(String key, String value)
StringRedisConnection
value
to key
.append
in interface StringRedisConnection
key
- must not be null.RedisStringCommands.append(byte[], byte[])
public List<String> bLPop(int timeout, String... keys)
StringRedisConnection
keys
(see: RedisListCommands.lPop(byte[])
). timeout
reached.bLPop
in interface StringRedisConnection
keys
- must not be null.RedisListCommands#bLPop(int, byte[]...)
public List<String> bRPop(int timeout, String... keys)
StringRedisConnection
keys
(see: RedisListCommands.rPop(byte[])
). timeout
reached.bRPop
in interface StringRedisConnection
keys
- must not be null.RedisListCommands#bRPop(int, byte[]...)
public String bRPopLPush(int timeout, String srcKey, String dstKey)
StringRedisConnection
srcKey
, append it to dstKey
and return its value (see
RedisListCommands.rPopLPush(byte[], byte[])
). timeout
reached.bRPopLPush
in interface StringRedisConnection
srcKey
- must not be null.dstKey
- must not be null.RedisListCommands.bRPopLPush(int, byte[], byte[])
public Long decr(String key)
StringRedisConnection
key
by 1.decr
in interface StringRedisConnection
key
- must not be null.RedisStringCommands.decr(byte[])
public Long decrBy(String key, long value)
StringRedisConnection
key
by value
.decrBy
in interface StringRedisConnection
key
- must not be null.RedisStringCommands.decrBy(byte[], long)
public Long del(String... keys)
StringRedisConnection
keys
.del
in interface StringRedisConnection
keys
- must not be null.RedisKeyCommands#del(byte[]...)
public Long unlink(String... keys)
StringRedisConnection
keys
from the keyspace. Unlike with StringRedisConnection.del(String...)
the actual memory reclaiming here
happens asynchronously.unlink
in interface StringRedisConnection
keys
- must not be null.public String echo(String message)
StringRedisConnection
message
via server roundtrip.echo
in interface StringRedisConnection
message
- the message to echo.RedisConnectionCommands.echo(byte[])
public Boolean exists(String key)
StringRedisConnection
key
exists.exists
in interface StringRedisConnection
key
- must not be null.RedisKeyCommands.exists(byte[])
public Boolean expire(String key, long seconds)
StringRedisConnection
key
in seconds.expire
in interface StringRedisConnection
key
- must not be null.RedisKeyCommands.expire(byte[], long)
public Boolean expireAt(String key, long unixTime)
StringRedisConnection
key
as a UNIX timestamp.expireAt
in interface StringRedisConnection
key
- must not be null.RedisKeyCommands.expireAt(byte[], long)
public String get(String key)
StringRedisConnection
key
.get
in interface StringRedisConnection
key
- must not be null.RedisStringCommands.get(byte[])
public Boolean getBit(String key, long offset)
StringRedisConnection
offset
of value at key
.getBit
in interface StringRedisConnection
key
- must not be null.RedisStringCommands.getBit(byte[], long)
public String getRange(String key, long start, long end)
StringRedisConnection
key
between start
and end
.getRange
in interface StringRedisConnection
key
- must not be null.RedisStringCommands.getRange(byte[], long, long)
public String getSet(String key, String value)
StringRedisConnection
value
of key
and return its old value.getSet
in interface StringRedisConnection
key
- must not be null.RedisStringCommands.getSet(byte[], byte[])
public Long hDel(String key, String... fields)
StringRedisConnection
fields
.hDel
in interface StringRedisConnection
key
- must not be null.fields
- must not be null.RedisHashCommands#hDel(byte[], byte[]...)
public Boolean hExists(String key, String field)
StringRedisConnection
field
exists.hExists
in interface StringRedisConnection
key
- must not be null.field
- must not be null.RedisHashCommands.hExists(byte[], byte[])
public String hGet(String key, String field)
StringRedisConnection
field
from hash at key
.hGet
in interface StringRedisConnection
key
- must not be null.field
- must not be null.RedisHashCommands.hGet(byte[], byte[])
public Map<String,String> hGetAll(String key)
StringRedisConnection
key
.hGetAll
in interface StringRedisConnection
key
- must not be null.RedisHashCommands.hGetAll(byte[])
public Long hIncrBy(String key, String field, long delta)
StringRedisConnection
value
of a hash field
by the given delta
.hIncrBy
in interface StringRedisConnection
key
- must not be null.field
- must not be null.RedisHashCommands.hIncrBy(byte[], byte[], long)
public Double hIncrBy(String key, String field, double delta)
StringRedisConnection
value
of a hash field
by the given delta
.hIncrBy
in interface StringRedisConnection
key
- must not be null.RedisHashCommands.hIncrBy(byte[], byte[], double)
public Set<String> hKeys(String key)
StringRedisConnection
key
.hKeys
in interface StringRedisConnection
key
- must not be null.RedisHashCommands.hKeys(byte[])
public Long hLen(String key)
StringRedisConnection
key
.hLen
in interface StringRedisConnection
key
- must not be null.RedisHashCommands.hLen(byte[])
public List<String> hMGet(String key, String... fields)
StringRedisConnection
fields
from hash at key
.hMGet
in interface StringRedisConnection
key
- must not be null.fields
- must not be null.RedisHashCommands#hMGet(byte[], byte[]...)
public void hMSet(String key, Map<String,String> hashes)
StringRedisConnection
hashes
hMSet
in interface StringRedisConnection
key
- must not be null.hashes
- must not be null.RedisHashCommands#hMGet(byte[], byte[]...)
public Boolean hSet(String key, String field, String value)
StringRedisConnection
value
of a hash field
.hSet
in interface StringRedisConnection
key
- must not be null.field
- must not be null.RedisHashCommands.hSet(byte[], byte[], byte[])
public Boolean hSetNX(String key, String field, String value)
StringRedisConnection
value
of a hash field
only if field
does not exist.hSetNX
in interface StringRedisConnection
key
- must not be null.field
- must not be null.RedisHashCommands.hSetNX(byte[], byte[], byte[])
public List<String> hVals(String key)
StringRedisConnection
field
.hVals
in interface StringRedisConnection
key
- must not be null.RedisHashCommands.hVals(byte[])
public Long incr(String key)
StringRedisConnection
key
by 1.incr
in interface StringRedisConnection
key
- must not be null.RedisStringCommands.incr(byte[])
public Long incrBy(String key, long value)
StringRedisConnection
key
by delta
.incrBy
in interface StringRedisConnection
key
- must not be null.RedisStringCommands.incrBy(byte[], long)
public Double incrBy(String key, double value)
StringRedisConnection
key
by delta
.incrBy
in interface StringRedisConnection
key
- must not be null.RedisStringCommands.incrBy(byte[], double)
public Collection<String> keys(String pattern)
StringRedisConnection
pattern
.keys
in interface StringRedisConnection
pattern
- must not be null.RedisKeyCommands.keys(byte[])
public String lIndex(String key, long index)
StringRedisConnection
index
form list at key
.lIndex
in interface StringRedisConnection
key
- must not be null.RedisListCommands.lIndex(byte[], long)
public Long lInsert(String key, RedisListCommands.Position where, String pivot, String value)
StringRedisConnection
value
Position#BEFORE
or Position#AFTER
existing pivot
for key
.lInsert
in interface StringRedisConnection
key
- must not be null.where
- must not be null.RedisListCommands.lIndex(byte[], long)
public Long lLen(String key)
StringRedisConnection
key
.lLen
in interface StringRedisConnection
key
- must not be null.RedisListCommands.lLen(byte[])
public String lPop(String key)
StringRedisConnection
key
.lPop
in interface StringRedisConnection
key
- must not be null.RedisListCommands.lPop(byte[])
public Long lPush(String key, String... values)
StringRedisConnection
values
to key
.lPush
in interface StringRedisConnection
key
- must not be null.RedisListCommands#lPush(byte[], byte[]...)
public Long lPushX(String key, String value)
StringRedisConnection
values
to key
only if the list exists.lPushX
in interface StringRedisConnection
key
- must not be null.RedisListCommands.lPushX(byte[], byte[])
public List<String> lRange(String key, long start, long end)
StringRedisConnection
start
and end
from list at key
.lRange
in interface StringRedisConnection
key
- must not be null.RedisListCommands.lRange(byte[], long, long)
public Long lRem(String key, long count, String value)
StringRedisConnection
count
occurrences of value
from the list stored at key
.lRem
in interface StringRedisConnection
key
- must not be null.RedisListCommands.lRem(byte[], long, byte[])
public void lSet(String key, long index, String value)
StringRedisConnection
value
list element at index
.lSet
in interface StringRedisConnection
key
- must not be null.RedisListCommands.lSet(byte[], long, byte[])
public void lTrim(String key, long start, long end)
StringRedisConnection
key
to elements between start
and end
.lTrim
in interface StringRedisConnection
key
- must not be null.RedisListCommands.lTrim(byte[], long, long)
public List<String> mGet(String... keys)
StringRedisConnection
keys
. Values are returned in the order of the requested keys.mGet
in interface StringRedisConnection
keys
- must not be null.RedisStringCommands#mGet(byte[]...)
public Boolean mSetNXString(Map<String,String> tuple)
StringRedisConnection
tuple
only if the provided key does
not exist.mSetNXString
in interface StringRedisConnection
tuple
- must not be null.RedisStringCommands.mSetNX(Map)
public Boolean mSetString(Map<String,String> tuple)
StringRedisConnection
tuple
.mSetString
in interface StringRedisConnection
tuple
- must not be null.RedisStringCommands.mSet(Map)
public Boolean persist(String key)
StringRedisConnection
key
.persist
in interface StringRedisConnection
key
- must not be null.RedisKeyCommands.persist(byte[])
public Boolean move(String key, int dbIndex)
StringRedisConnection
key
to database with index
.move
in interface StringRedisConnection
key
- must not be null.RedisKeyCommands.move(byte[], int)
public void pSubscribe(MessageListener listener, String... patterns)
StringRedisConnection
Note that this operation is blocking and the current thread starts waiting for new messages immediately.
pSubscribe
in interface StringRedisConnection
listener
- message listener, must not be null.patterns
- channel name patterns, must not be null.RedisPubSubCommands#pSubscribe(MessageListener, byte[]...)
public Long publish(String channel, String message)
StringRedisConnection
publish
in interface StringRedisConnection
channel
- the channel to publish to, must not be null.message
- message to publishRedisPubSubCommands.publish(byte[], byte[])
public void rename(String oldName, String newName)
StringRedisConnection
oleName
to newName
.rename
in interface StringRedisConnection
oldName
- must not be null.newName
- must not be null.RedisKeyCommands.rename(byte[], byte[])
public Boolean renameNX(String oldName, String newName)
StringRedisConnection
oleName
to newName
only if newName
does not exist.renameNX
in interface StringRedisConnection
oldName
- must not be null.newName
- must not be null.RedisKeyCommands.renameNX(byte[], byte[])
public String rPop(String key)
StringRedisConnection
key
.rPop
in interface StringRedisConnection
key
- must not be null.RedisListCommands.rPop(byte[])
public String rPopLPush(String srcKey, String dstKey)
StringRedisConnection
srcKey
, append it to dstKey
and return its value.rPopLPush
in interface StringRedisConnection
srcKey
- must not be null.dstKey
- must not be null.RedisListCommands.rPopLPush(byte[], byte[])
public Long rPush(String key, String... values)
StringRedisConnection
values
to key
.rPush
in interface StringRedisConnection
key
- must not be null.RedisListCommands#rPush(byte[], byte[]...)
public Long rPushX(String key, String value)
StringRedisConnection
values
to key
only if the list exists.rPushX
in interface StringRedisConnection
key
- must not be null.RedisListCommands.rPushX(byte[], byte[])
public Long sAdd(String key, String... values)
StringRedisConnection
values
to set at key
.sAdd
in interface StringRedisConnection
key
- must not be null.RedisSetCommands#sAdd(byte[], byte[]...)
public Long sCard(String key)
StringRedisConnection
key
.sCard
in interface StringRedisConnection
key
- must not be null.RedisSetCommands.sCard(byte[])
public Set<String> sDiff(String... keys)
StringRedisConnection
keys
.sDiff
in interface StringRedisConnection
keys
- must not be null.RedisSetCommands#sDiff(byte[]...)
public Long sDiffStore(String destKey, String... keys)
StringRedisConnection
keys
and store result in destKey
.sDiffStore
in interface StringRedisConnection
destKey
- must not be null.keys
- must not be null.RedisSetCommands#sDiffStore(byte[], byte[]...)
public Boolean set(String key, String value)
StringRedisConnection
value
for key
.set
in interface StringRedisConnection
key
- must not be null.value
- must not be null.RedisStringCommands.set(byte[], byte[])
public Boolean set(String key, String value, Expiration expiration, RedisStringCommands.SetOption option)
StringRedisConnection
value
for key
applying timeouts from expiration
if set and inserting/updating values
depending on option
.set
in interface StringRedisConnection
key
- must not be null.value
- must not be null.expiration
- can be null. Defaulted to Expiration.persistent()
.option
- can be null. Defaulted to SetOption#UPSERT
.RedisStringCommands.set(byte[], byte[], Expiration, SetOption)
public Boolean setBit(String key, long offset, boolean value)
StringRedisConnection
offset
in value stored at key
.setBit
in interface StringRedisConnection
key
- must not be null.offset
.RedisStringCommands.setBit(byte[], long, boolean)
public Boolean setEx(String key, long seconds, String value)
StringRedisConnection
value
and expiration in seconds
for key
.setEx
in interface StringRedisConnection
key
- must not be null.value
- must not be null.RedisStringCommands.setEx(byte[], long, byte[])
public Boolean pSetEx(String key, long seconds, String value)
StringRedisConnection
value
and expiration in milliseconds
for key
.pSetEx
in interface StringRedisConnection
key
- must not be null.value
- must not be null.RedisStringCommands.pSetEx(byte[], long, byte[])
public Boolean setNX(String key, String value)
StringRedisConnection
value
for key
, only if key
does not exist.setNX
in interface StringRedisConnection
key
- must not be null.value
- must not be null.RedisStringCommands.setNX(byte[], byte[])
public void setRange(String key, String value, long start)
StringRedisConnection
key
starting at the specified offset
with given value
.setRange
in interface StringRedisConnection
key
- must not be null.RedisStringCommands.setRange(byte[], byte[], long)
public Set<String> sInter(String... keys)
StringRedisConnection
keys
.sInter
in interface StringRedisConnection
keys
- must not be null.RedisSetCommands#sInter(byte[]...)
public Long sInterStore(String destKey, String... keys)
StringRedisConnection
keys
and store result in destKey
.sInterStore
in interface StringRedisConnection
destKey
- must not be null.keys
- must not be null.RedisSetCommands#sInterStore(byte[], byte[]...)
public Boolean sIsMember(String key, String value)
StringRedisConnection
key
contains value
.sIsMember
in interface StringRedisConnection
key
- must not be null.RedisSetCommands.sIsMember(byte[], byte[])
public Set<String> sMembers(String key)
StringRedisConnection
key
.sMembers
in interface StringRedisConnection
key
- must not be null.RedisSetCommands.sMembers(byte[])
public Boolean sMove(String srcKey, String destKey, String value)
StringRedisConnection
value
from srcKey
to destKey
sMove
in interface StringRedisConnection
srcKey
- must not be null.destKey
- must not be null.RedisSetCommands.sMove(byte[], byte[], byte[])
public Long sort(String key, SortParameters params, String storeKey)
StringRedisConnection
key
and store result in storeKey
.sort
in interface StringRedisConnection
key
- must not be null.params
- must not be null.storeKey
- must not be null.public List<String> sort(String key, SortParameters params)
StringRedisConnection
key
.sort
in interface StringRedisConnection
key
- must not be null.params
- must not be null.public ValueEncoding encodingOf(String key)
StringRedisConnection
key
.encodingOf
in interface StringRedisConnection
key
- must not be null.public Duration idletime(String key)
StringRedisConnection
Duration
since the object stored at the given key
is idle.idletime
in interface StringRedisConnection
key
- must not be null.public Long refcount(String key)
StringRedisConnection
key
.refcount
in interface StringRedisConnection
key
- must not be null.public String sPop(String key)
StringRedisConnection
key
.sPop
in interface StringRedisConnection
key
- must not be null.RedisSetCommands.sPop(byte[])
public List<String> sPop(String key, long count)
StringRedisConnection
count
random members from set at key
.sPop
in interface StringRedisConnection
key
- must not be null.count
- the number of random members to return.List
if key does not exist.RedisSetCommands.sPop(byte[], long)
public String sRandMember(String key)
StringRedisConnection
key
.sRandMember
in interface StringRedisConnection
key
- must not be null.RedisSetCommands.sRandMember(byte[])
public List<String> sRandMember(String key, long count)
StringRedisConnection
count
random elements from set at key
.sRandMember
in interface StringRedisConnection
key
- must not be null.RedisSetCommands#sRem(byte[], byte[]...)
public Long sRem(String key, String... values)
StringRedisConnection
values
from set at key
and return the number of removed elements.sRem
in interface StringRedisConnection
key
- must not be null.RedisSetCommands#sRem(byte[], byte[]...)
public Long strLen(String key)
StringRedisConnection
key
.strLen
in interface StringRedisConnection
key
- must not be null.RedisStringCommands.strLen(byte[])
public Long bitCount(String key)
StringRedisConnection
key
.bitCount
in interface StringRedisConnection
key
- must not be null.RedisStringCommands.bitCount(byte[])
public Long bitCount(String key, long start, long end)
StringRedisConnection
key
between start
and
end
.bitCount
in interface StringRedisConnection
key
- must not be null.RedisStringCommands.bitCount(byte[], long, long)
public Long bitOp(RedisStringCommands.BitOperation op, String destination, String... keys)
StringRedisConnection
bitOp
in interface StringRedisConnection
op
- must not be null.destination
- must not be null.keys
- must not be null.RedisStringCommands#bitOp(BitOperation, byte[], byte[]...)
@Nullable public Long bitPos(String key, boolean bit, Range<Long> range)
StringRedisConnection
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.bitPos
in interface StringRedisConnection
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.public void subscribe(MessageListener listener, String... channels)
StringRedisConnection
Note that this operation is blocking and the current thread starts waiting for new messages immediately.
subscribe
in interface StringRedisConnection
listener
- message listener, must not be null.channels
- channel names, must not be null.RedisPubSubCommands#subscribe(MessageListener, byte[]...)
public Set<String> sUnion(String... keys)
StringRedisConnection
keys
.sUnion
in interface StringRedisConnection
keys
- must not be null.RedisSetCommands#sUnion(byte[]...)
public Long sUnionStore(String destKey, String... keys)
StringRedisConnection
keys
and store result in destKey
.sUnionStore
in interface StringRedisConnection
destKey
- must not be null.keys
- must not be null.RedisSetCommands#sUnionStore(byte[], byte[]...)
public Long ttl(String key)
StringRedisConnection
key
in seconds.ttl
in interface StringRedisConnection
key
- must not be null.RedisKeyCommands.ttl(byte[])
public Long ttl(String key, TimeUnit timeUnit)
StringRedisConnection
key
in and convert it to the given TimeUnit
.ttl
in interface StringRedisConnection
key
- must not be null.timeUnit
- must not be null.RedisKeyCommands.ttl(byte[], TimeUnit)
public DataType type(String key)
StringRedisConnection
key
.type
in interface StringRedisConnection
key
- must not be null.RedisKeyCommands.type(byte[])
@Nullable public Long touch(String... keys)
StringRedisConnection
key(s)
.touch
in interface StringRedisConnection
keys
- must not be null.public Boolean zAdd(String key, double score, String value)
StringRedisConnection
value
to a sorted set at key
, or update its score
if it already exists.zAdd
in interface StringRedisConnection
key
- must not be null.score
- the score.value
- the value.RedisZSetCommands.zAdd(byte[], double, byte[])
public Long zAdd(String key, Set<StringRedisConnection.StringTuple> tuples)
StringRedisConnection
tuples
to a sorted set at key
, or update its score
if it already exists.zAdd
in interface StringRedisConnection
key
- must not be null.tuples
- the tuples.RedisZSetCommands.zAdd(byte[], Set)
public Long zCard(String key)
StringRedisConnection
key
.zCard
in interface StringRedisConnection
key
- must not be null.RedisZSetCommands.zCard(byte[])
public Long zCount(String key, double min, double max)
StringRedisConnection
min
and max
.zCount
in interface StringRedisConnection
key
- must not be null.RedisZSetCommands.zCount(byte[], double, double)
public Double zIncrBy(String key, double increment, String value)
StringRedisConnection
value
in sorted set by increment
.zIncrBy
in interface StringRedisConnection
key
- must not be null.value
- the value.RedisZSetCommands.zIncrBy(byte[], double, byte[])
public Long zInterStore(String destKey, RedisZSetCommands.Aggregate aggregate, int[] weights, String... sets)
StringRedisConnection
sets
and store result in destination key
.zInterStore
in interface StringRedisConnection
destKey
- must not be null.aggregate
- must not be null.sets
- must not be null.RedisZSetCommands#zInterStore(byte[], Aggregate, int[], byte[]...)
public Long zInterStore(String destKey, String... sets)
StringRedisConnection
sets
and store result in destination key
.zInterStore
in interface StringRedisConnection
destKey
- must not be null.sets
- must not be null.RedisZSetCommands#zInterStore(byte[], byte[]...)
public Set<String> zRange(String key, long start, long end)
StringRedisConnection
start
and end
from sorted set.zRange
in interface StringRedisConnection
key
- must not be null.RedisZSetCommands.zRange(byte[], long, long)
public Set<String> zRangeByScore(String key, double min, double max, long offset, long count)
StringRedisConnection
start
to end
where score is between min
and max
from
sorted set.zRangeByScore
in interface StringRedisConnection
key
- must not be null.RedisZSetCommands.zRangeByScore(byte[], double, double, long, long)
public Set<String> zRangeByScore(String key, double min, double max)
StringRedisConnection
min
and max
from sorted set.zRangeByScore
in interface StringRedisConnection
key
- must not be null.RedisZSetCommands.zRangeByScore(byte[], double, double)
public Set<StringRedisConnection.StringTuple> zRangeByScoreWithScores(String key, double min, double max, long offset, long count)
StringRedisConnection
Tuple
s in range from start
to end
where score is between min
and
max
from sorted set.zRangeByScoreWithScores
in interface StringRedisConnection
RedisZSetCommands.zRangeByScoreWithScores(byte[], double, double, long, long)
public Set<StringRedisConnection.StringTuple> zRangeByScoreWithScores(String key, double min, double max)
StringRedisConnection
Tuple
s where score is between min
and max
from sorted set.zRangeByScoreWithScores
in interface StringRedisConnection
key
- must not be null.RedisZSetCommands.zRangeByScoreWithScores(byte[], double, double)
public Set<StringRedisConnection.StringTuple> zRangeWithScores(String key, long start, long end)
StringRedisConnection
Tuple
s between start
and end
from sorted set.zRangeWithScores
in interface StringRedisConnection
key
- must not be null.RedisZSetCommands.zRangeWithScores(byte[], long, long)
public Long zRank(String key, String value)
StringRedisConnection
value
in a sorted set.zRank
in interface StringRedisConnection
key
- must not be null.value
- the value.RedisZSetCommands.zRank(byte[], byte[])
public Long zRem(String key, String... values)
StringRedisConnection
values
from sorted set. Return number of removed elements.zRem
in interface StringRedisConnection
key
- must not be null.values
- must not be null.RedisZSetCommands#zRem(byte[], byte[]...)
public Long zRemRange(String key, long start, long end)
StringRedisConnection
start
and end
from sorted set with key
.zRemRange
in interface StringRedisConnection
key
- must not be null.RedisZSetCommands.zRemRange(byte[], long, long)
public Long zRemRangeByScore(String key, double min, double max)
StringRedisConnection
min
and max
from sorted set with key
.zRemRangeByScore
in interface StringRedisConnection
key
- must not be null.RedisZSetCommands.zRemRangeByScore(byte[], double, double)
public Set<String> zRevRange(String key, long start, long end)
StringRedisConnection
start
to end
from sorted set ordered from high to low.zRevRange
in interface StringRedisConnection
key
- must not be null.RedisZSetCommands.zRevRange(byte[], long, long)
public Set<StringRedisConnection.StringTuple> zRevRangeWithScores(String key, long start, long end)
StringRedisConnection
Tuple
s in range from start
to end
from sorted set ordered from high to low.zRevRangeWithScores
in interface StringRedisConnection
key
- must not be null.RedisZSetCommands.zRevRangeWithScores(byte[], long, long)
public Set<String> zRevRangeByScore(String key, double min, double max)
StringRedisConnection
min
and max
from sorted set ordered from high to low.zRevRangeByScore
in interface StringRedisConnection
key
- must not be null.RedisZSetCommands.zRevRangeByScore(byte[], double, double)
public Set<StringRedisConnection.StringTuple> zRevRangeByScoreWithScores(String key, double min, double max)
StringRedisConnection
Tuple
where score is between min
and max
from sorted set ordered from high to
low.zRevRangeByScoreWithScores
in interface StringRedisConnection
key
- must not be null.RedisZSetCommands.zRevRangeByScoreWithScores(byte[], double, double)
public Set<String> zRevRangeByScore(String key, double min, double max, long offset, long count)
StringRedisConnection
start
to end
where score is between min
and max
from
sorted set ordered high -> low.zRevRangeByScore
in interface StringRedisConnection
key
- must not be null.RedisZSetCommands.zRevRangeByScore(byte[], double, double, long, long)
public Set<StringRedisConnection.StringTuple> zRevRangeByScoreWithScores(String key, double min, double max, long offset, long count)
StringRedisConnection
Tuple
in range from start
to end
where score is between min
and
max
from sorted set ordered high -> low.zRevRangeByScoreWithScores
in interface StringRedisConnection
key
- must not be null.RedisZSetCommands.zRevRangeByScoreWithScores(byte[], double, double, long, long)
public Long zRevRank(String key, String value)
StringRedisConnection
value
in a sorted set when scored high to low.zRevRank
in interface StringRedisConnection
key
- must not be null.value
- the value.RedisZSetCommands.zRevRank(byte[], byte[])
public Double zScore(String key, String value)
StringRedisConnection
value
from sorted set with key key
.zScore
in interface StringRedisConnection
key
- must not be null.value
- the value.RedisZSetCommands.zScore(byte[], byte[])
public Long zUnionStore(String destKey, RedisZSetCommands.Aggregate aggregate, int[] weights, String... sets)
StringRedisConnection
sets
and store result in destination key
.zUnionStore
in interface StringRedisConnection
destKey
- must not be null.aggregate
- must not be null.sets
- must not be null.RedisZSetCommands#zUnionStore(byte[], Aggregate, int[], byte[]...)
public Long zUnionStore(String destKey, String... sets)
StringRedisConnection
sets
and store result in destination key
.zUnionStore
in interface StringRedisConnection
destKey
- must not be null.sets
- must not be null.RedisZSetCommands#zUnionStore(byte[], byte[]...)
public Long geoAdd(byte[] key, Point point, byte[] member)
RedisGeoCommands
Point
with given member name to key.geoAdd
in interface RedisGeoCommands
key
- must not be null.point
- must not be null.member
- must not be null.public Long geoAdd(byte[] key, RedisGeoCommands.GeoLocation<byte[]> location)
RedisGeoCommands
RedisGeoCommands.GeoLocation
to key.geoAdd
in interface RedisGeoCommands
key
- must not be null.location
- must not be null.public Long geoAdd(String key, Point point, String member)
StringRedisConnection
Point
with given member name to key.geoAdd
in interface StringRedisConnection
key
- must not be null.point
- must not be null.member
- must not be null.RedisGeoCommands.geoAdd(byte[], Point, byte[])
public Long geoAdd(String key, RedisGeoCommands.GeoLocation<String> location)
StringRedisConnection
GeoLocation
to key.geoAdd
in interface StringRedisConnection
key
- must not be null.location
- must not be null.RedisGeoCommands.geoAdd(byte[], GeoLocation)
public Long geoAdd(byte[] key, Map<byte[],Point> memberCoordinateMap)
RedisGeoCommands
geoAdd
in interface RedisGeoCommands
key
- must not be null.memberCoordinateMap
- must not be null.public Long geoAdd(byte[] key, Iterable<RedisGeoCommands.GeoLocation<byte[]>> locations)
RedisGeoCommands
RedisGeoCommands.GeoLocation
s to keygeoAdd
in interface RedisGeoCommands
key
- must not be null.locations
- must not be null.public Long geoAdd(String key, Map<String,Point> memberCoordinateMap)
StringRedisConnection
geoAdd
in interface StringRedisConnection
key
- must not be null.memberCoordinateMap
- must not be null.RedisGeoCommands.geoAdd(byte[], Map)
public Long geoAdd(String key, Iterable<RedisGeoCommands.GeoLocation<String>> locations)
StringRedisConnection
GeoLocation
s to keygeoAdd
in interface StringRedisConnection
key
- must not be null.locations
- must not be null.RedisGeoCommands.geoAdd(byte[], Iterable)
public Distance geoDist(byte[] key, byte[] member1, byte[] member2)
RedisGeoCommands
Distance
between member1 and member2.geoDist
in interface RedisGeoCommands
key
- must not be null.member1
- must not be null.member2
- must not be null.public Distance geoDist(String key, String member1, String member2)
StringRedisConnection
Distance
between member1 and member2.geoDist
in interface StringRedisConnection
key
- must not be null.member1
- must not be null.member2
- must not be null.RedisGeoCommands.geoDist(byte[], byte[], byte[])
public Distance geoDist(byte[] key, byte[] member1, byte[] member2, Metric metric)
RedisGeoCommands
geoDist
in interface RedisGeoCommands
key
- must not be null.member1
- must not be null.member2
- must not be null.metric
- must not be null.public Distance geoDist(String key, String member1, String member2, Metric metric)
StringRedisConnection
geoDist
in interface StringRedisConnection
key
- must not be null.member1
- must not be null.member2
- must not be null.metric
- must not be null.RedisGeoCommands.geoDist(byte[], byte[], byte[], Metric)
public List<String> geoHash(byte[] key, byte[]... members)
RedisGeoCommands
geoHash
in interface RedisGeoCommands
key
- must not be null.members
- must not be null.public List<String> geoHash(String key, String... members)
StringRedisConnection
geoHash
in interface StringRedisConnection
key
- must not be null.members
- must not be null.RedisGeoCommands#geoHash(byte[], byte[]...)
public List<Point> geoPos(byte[] key, byte[]... members)
RedisGeoCommands
Point
representation of positions for one or more members.geoPos
in interface RedisGeoCommands
key
- must not be null.members
- must not be null.List
when key of members do not exist. null when used in pipeline / transaction.public List<Point> geoPos(String key, String... members)
StringRedisConnection
Point
representation of positions for one or more members.geoPos
in interface StringRedisConnection
key
- must not be null.members
- must not be null.RedisGeoCommands#geoPos(byte[], byte[]...)
public GeoResults<RedisGeoCommands.GeoLocation<String>> geoRadius(String key, Circle within)
StringRedisConnection
Circle
.geoRadius
in interface StringRedisConnection
key
- must not be null.within
- must not be null.RedisGeoCommands.geoRadius(byte[], Circle)
public GeoResults<RedisGeoCommands.GeoLocation<String>> geoRadius(String key, Circle within, RedisGeoCommands.GeoRadiusCommandArgs args)
StringRedisConnection
Circle
applying GeoRadiusCommandArgs
.geoRadius
in interface StringRedisConnection
key
- must not be null.within
- must not be null.args
- must not be null.RedisGeoCommands.geoRadius(byte[], Circle, GeoRadiusCommandArgs)
public GeoResults<RedisGeoCommands.GeoLocation<String>> geoRadiusByMember(String key, String member, double radius)
StringRedisConnection
geoRadiusByMember
in interface StringRedisConnection
key
- must not be null.member
- must not be null.RedisGeoCommands.geoRadiusByMember(byte[], byte[], double)
public GeoResults<RedisGeoCommands.GeoLocation<String>> geoRadiusByMember(String key, String member, Distance radius)
StringRedisConnection
Distance
.geoRadiusByMember
in interface StringRedisConnection
key
- must not be null.member
- must not be null.radius
- must not be null.RedisGeoCommands.geoRadiusByMember(byte[], byte[], Distance)
public GeoResults<RedisGeoCommands.GeoLocation<String>> geoRadiusByMember(String key, String member, Distance radius, RedisGeoCommands.GeoRadiusCommandArgs args)
StringRedisConnection
Distance
and GeoRadiusCommandArgs
.geoRadiusByMember
in interface StringRedisConnection
key
- must not be null.member
- must not be null.radius
- must not be null.args
- must not be null.RedisGeoCommands.geoRadiusByMember(byte[], byte[], Distance, GeoRadiusCommandArgs)
public GeoResults<RedisGeoCommands.GeoLocation<byte[]>> geoRadius(byte[] key, Circle within)
RedisGeoCommands
Circle
.geoRadius
in interface RedisGeoCommands
key
- must not be null.within
- must not be null.public GeoResults<RedisGeoCommands.GeoLocation<byte[]>> geoRadius(byte[] key, Circle within, RedisGeoCommands.GeoRadiusCommandArgs args)
RedisGeoCommands
Circle
applying RedisGeoCommands.GeoRadiusCommandArgs
.geoRadius
in interface RedisGeoCommands
key
- must not be null.within
- must not be null.args
- must not be null.public GeoResults<RedisGeoCommands.GeoLocation<byte[]>> geoRadiusByMember(byte[] key, byte[] member, double radius)
RedisGeoCommands
geoRadiusByMember
in interface RedisGeoCommands
key
- must not be null.member
- must not be null.public GeoResults<RedisGeoCommands.GeoLocation<byte[]>> geoRadiusByMember(byte[] key, byte[] member, Distance radius)
RedisGeoCommands
Distance
.geoRadiusByMember
in interface RedisGeoCommands
key
- must not be null.member
- must not be null.radius
- must not be null.public GeoResults<RedisGeoCommands.GeoLocation<byte[]>> geoRadiusByMember(byte[] key, byte[] member, Distance radius, RedisGeoCommands.GeoRadiusCommandArgs args)
RedisGeoCommands
Distance
and RedisGeoCommands.GeoRadiusCommandArgs
.geoRadiusByMember
in interface RedisGeoCommands
key
- must not be null.member
- must not be null.radius
- must not be null.args
- must not be null.public Long geoRemove(byte[] key, byte[]... members)
RedisGeoCommands
geoRemove
in interface RedisGeoCommands
key
- must not be null.members
- must not be null.public Long geoRemove(String key, String... members)
StringRedisConnection
geoRemove
in interface StringRedisConnection
key
- must not be null.members
- must not be null.RedisGeoCommands#geoRemove(byte[], byte[]...)
public List<Object> closePipeline()
RedisConnection
closePipeline
in interface RedisConnection
public boolean isPipelined()
RedisConnection
isPipelined
in interface RedisConnection
RedisConnection.openPipeline()
,
RedisConnection.isQueueing()
public void openPipeline()
RedisConnection
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.openPipeline
in interface RedisConnection
RedisTxCommands.multi()
public Object execute(String command)
StringRedisConnection
execute
in interface StringRedisConnection
command
- Command to executeRedisCommands#execute(String, byte[]...)
public Object execute(String command, byte[]... args)
RedisCommands
execute
in interface RedisCommands
command
- Command to execute. must not be null.args
- Possible command arguments (may be empty).public Object execute(String command, String... args)
StringRedisConnection
execute
in interface StringRedisConnection
command
- Command to executeargs
- Possible command arguments (may be null)RedisCommands#execute(String, byte[]...)
public Boolean pExpire(String key, long millis)
StringRedisConnection
key
in milliseconds.pExpire
in interface StringRedisConnection
key
- must not be null.RedisKeyCommands.pExpire(byte[], long)
public Boolean pExpireAt(String key, long unixTimeInMillis)
StringRedisConnection
key
as a UNIX timestamp in milliseconds.pExpireAt
in interface StringRedisConnection
key
- must not be null.RedisKeyCommands.pExpireAt(byte[], long)
public Long pTtl(String key)
StringRedisConnection
key
in milliseconds.pTtl
in interface StringRedisConnection
key
- must not be null.RedisKeyCommands.pTtl(byte[])
public Long pTtl(String key, TimeUnit timeUnit)
StringRedisConnection
key
in and convert it to the given TimeUnit
.pTtl
in interface StringRedisConnection
key
- must not be null.timeUnit
- must not be null.RedisKeyCommands.pTtl(byte[], TimeUnit)
public String scriptLoad(String script)
StringRedisConnection
#evalSha(byte[], ReturnType, int, byte[]...)
.scriptLoad
in interface StringRedisConnection
script
- must not be null.RedisScriptingCommands.scriptLoad(byte[])
public <T> T eval(String script, ReturnType returnType, int numKeys, String... keysAndArgs)
eval
in interface StringRedisConnection
script
- must not be null.returnType
- must not be null.keysAndArgs
- must not be null.RedisScriptingCommands#eval(byte[], ReturnType, int, byte[]...)
public <T> T evalSha(String scriptSha1, ReturnType returnType, int numKeys, String... keysAndArgs)
evalSha
in interface StringRedisConnection
scriptSha1
- must not be null.returnType
- must not be null.keysAndArgs
- must not be null.RedisScriptingCommands#evalSha(String, ReturnType, int, byte[]...)
public Long time()
RedisServerCommands
TIME
command.time
in interface RedisServerCommands
public List<RedisClientInfo> getClientList()
StringRedisConnection
getClientList
in interface RedisServerCommands
getClientList
in interface StringRedisConnection
List
of RedisClientInfo
objects.RedisServerCommands.getClientList()
public void slaveOf(String host, int port)
RedisServerCommands
slaveOf
in interface RedisServerCommands
host
- must not be null.public void slaveOfNoOne()
RedisServerCommands
slaveOfNoOne
in interface RedisServerCommands
public Cursor<byte[]> scan(ScanOptions options)
RedisKeyCommands
Cursor
to iterate over keys.scan
in interface RedisKeyCommands
options
- must not be null.public Cursor<RedisZSetCommands.Tuple> zScan(byte[] key, ScanOptions options)
RedisZSetCommands
Cursor
to iterate over elements in sorted set at key
.zScan
in interface RedisZSetCommands
key
- must not be null.options
- must not be null.public Cursor<byte[]> sScan(byte[] key, ScanOptions options)
RedisSetCommands
Cursor
to iterate over elements in set at key
.sScan
in interface RedisSetCommands
key
- must not be null.options
- must not be null.public Cursor<Map.Entry<byte[],byte[]>> hScan(byte[] key, ScanOptions options)
RedisHashCommands
Cursor
to iterate over entries in hash at key
.hScan
in interface RedisHashCommands
key
- must not be null.options
- must not be null.@Nullable public Long hStrLen(byte[] key, byte[] field)
RedisHashCommands
field
in the hash stored at key
. If the key or the
field do not exist, 0
is returned.hStrLen
in interface RedisHashCommands
key
- must not be null.field
- must not be null.public void setClientName(byte[] name)
RedisServerCommands
setClientName
in interface RedisServerCommands
public void setClientName(String name)
StringRedisConnection
setClientName
in interface StringRedisConnection
RedisServerCommands.setClientName(byte[])
public void killClient(String host, int port)
RedisServerCommands
killClient
in interface RedisServerCommands
host
- of connection to close.port
- of connection to closepublic String getClientName()
RedisServerCommands
getClientName
in interface RedisServerCommands
public Cursor<Map.Entry<String,String>> hScan(String key, ScanOptions options)
StringRedisConnection
Cursor
to iterate over entries in hash at key
.hScan
in interface StringRedisConnection
key
- must not be null.options
- must not be null.RedisHashCommands.hScan(byte[], ScanOptions)
public Long hStrLen(String key, String field)
StringRedisConnection
field
in the hash stored at key
. If the key or the
field do not exist, 0
is returned.hStrLen
in interface StringRedisConnection
key
- must not be null.field
- must not be null.public Cursor<String> sScan(String key, ScanOptions options)
StringRedisConnection
Cursor
to iterate over elements in set at key
.sScan
in interface StringRedisConnection
key
- must not be null.options
- must not be null.RedisSetCommands.sScan(byte[], ScanOptions)
public Cursor<StringRedisConnection.StringTuple> zScan(String key, ScanOptions options)
StringRedisConnection
Cursor
to iterate over elements in sorted set at key
.zScan
in interface StringRedisConnection
key
- must not be null.options
- must not be null.RedisZSetCommands.zScan(byte[], ScanOptions)
public RedisSentinelConnection getSentinelConnection()
getSentinelConnection
in interface RedisConnection
public Set<String> zRangeByScore(String key, String min, String max)
StringRedisConnection
min
and max
from sorted set.zRangeByScore
in interface StringRedisConnection
key
- must not be null.min
- must not be null.max
- must not be null.RedisZSetCommands.zRangeByScore(byte[], String, String)
public Set<String> zRangeByScore(String key, String min, String max, long offset, long count)
StringRedisConnection
start
to end
where score is between min
and max
from
sorted set.zRangeByScore
in interface StringRedisConnection
key
- must not be null.min
- must not be null.max
- must not be null.RedisZSetCommands.zRangeByScore(byte[], double, double, long, long)
public Set<byte[]> zRangeByScore(byte[] key, String min, String max)
RedisZSetCommands
min
and max
from sorted set.zRangeByScore
in interface RedisZSetCommands
key
- must not be null.public Set<byte[]> zRangeByScore(byte[] key, String min, String max, long offset, long count)
RedisZSetCommands
start
to end
where score is between min
and max
from
sorted set.zRangeByScore
in interface RedisZSetCommands
key
- must not be null.min
- must not be null.max
- must not be null.public Long pfAdd(byte[] key, byte[]... values)
RedisHyperLogLogCommands
pfAdd
in interface RedisHyperLogLogCommands
key
- must not be null.values
- must not be null.public Long pfAdd(String key, String... values)
StringRedisConnection
pfAdd
in interface StringRedisConnection
key
- must not be null.values
- must not be null.RedisHyperLogLogCommands#pfAdd(byte[], byte[]...)
public Long pfCount(byte[]... keys)
RedisHyperLogLogCommands
pfCount
in interface RedisHyperLogLogCommands
keys
- must not be null.public Long pfCount(String... keys)
StringRedisConnection
pfCount
in interface StringRedisConnection
keys
- must not be null.RedisHyperLogLogCommands#pfCount(byte[]...)
public void pfMerge(byte[] destinationKey, byte[]... sourceKeys)
RedisHyperLogLogCommands
pfMerge
in interface RedisHyperLogLogCommands
destinationKey
- must not be null.sourceKeys
- must not be null.public void pfMerge(String destinationKey, String... sourceKeys)
StringRedisConnection
pfMerge
in interface StringRedisConnection
destinationKey
- must not be null.sourceKeys
- must not be null.RedisHyperLogLogCommands#pfMerge(byte[], byte[]...)
public Set<byte[]> zRangeByLex(byte[] key)
RedisZSetCommands
zRangeByLex
in interface RedisZSetCommands
key
- must not be null.public Set<byte[]> zRangeByLex(byte[] key, RedisZSetCommands.Range range)
RedisZSetCommands
RedisZSetCommands.Range
from the sorted set at key in lexicographical ordering.zRangeByLex
in interface RedisZSetCommands
key
- must not be null.range
- must not be null.public Set<byte[]> zRangeByLex(byte[] key, RedisZSetCommands.Range range, RedisZSetCommands.Limit limit)
RedisZSetCommands
RedisZSetCommands.Range
from the sorted set at key in lexicographical ordering. Result is
limited via RedisZSetCommands.Limit
.zRangeByLex
in interface RedisZSetCommands
key
- must not be null.range
- must not be null.limit
- must not be null.public Set<String> zRangeByLex(String key)
StringRedisConnection
zRangeByLex
in interface StringRedisConnection
key
- must not be null.RedisZSetCommands.zRangeByLex(byte[])
public Set<String> zRangeByLex(String key, RedisZSetCommands.Range range)
StringRedisConnection
Range
from the sorted set at key in lexicographical ordering.zRangeByLex
in interface StringRedisConnection
key
- must not be null.range
- must not be null.RedisZSetCommands.zRangeByLex(byte[], Range)
public Set<String> zRangeByLex(String key, RedisZSetCommands.Range range, RedisZSetCommands.Limit limit)
StringRedisConnection
Range
from the sorted set at key in lexicographical ordering. Result is
limited via Limit
.zRangeByLex
in interface StringRedisConnection
key
- must not be null.range
- must not be null.RedisZSetCommands.zRangeByLex(byte[], Range, Limit)
public void migrate(byte[] key, RedisNode target, int dbIndex, @Nullable RedisServerCommands.MigrateOption option)
RedisServerCommands
migrate
in interface RedisServerCommands
key
- must not be null.target
- must not be null.option
- can be null. Defaulted to RedisServerCommands.MigrateOption.COPY
.public void migrate(byte[] key, RedisNode target, int dbIndex, @Nullable RedisServerCommands.MigrateOption option, long timeout)
RedisServerCommands
migrate
in interface RedisServerCommands
key
- must not be null.target
- must not be null.option
- can be null. Defaulted to RedisServerCommands.MigrateOption.COPY
.public Long xAck(String key, String group, RecordId... recordIds)
xAck
in interface StringRedisConnection
public RecordId xAdd(StringRecord record, RedisStreamCommands.XAddOptions options)
StringRedisConnection
StringRecord
to the stream stored at Record.getStream()
.xAdd
in interface StringRedisConnection
record
- must not be null.options
- must not be null, use XAddOptions#none()
instead.public List<RecordId> xClaimJustId(String key, String group, String consumer, RedisStreamCommands.XClaimOptions options)
StringRedisConnection
xClaimJustId
in interface StringRedisConnection
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.ids
that changed user.public List<StringRecord> xClaim(String key, String group, String consumer, RedisStreamCommands.XClaimOptions options)
StringRedisConnection
xClaim
in interface StringRedisConnection
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.StringRecord
that changed user.public Long xDel(String key, RecordId... recordIds)
xDel
in interface StringRedisConnection
public String xGroupCreate(String key, ReadOffset readOffset, String group)
StringRedisConnection
xGroupCreate
in interface StringRedisConnection
key
- the stream key.group
- name of the consumer group.public String xGroupCreate(String key, ReadOffset readOffset, String group, boolean mkStream)
StringRedisConnection
xGroupCreate
in interface StringRedisConnection
key
- the stream key.group
- name of the consumer group.mkStream
- if true the group will create the stream if needed (MKSTREAM)public Boolean xGroupDelConsumer(String key, Consumer consumer)
StringRedisConnection
xGroupDelConsumer
in interface StringRedisConnection
key
- the stream key.consumer
- consumer identified by group name and consumer key.public Boolean xGroupDestroy(String key, String group)
StringRedisConnection
xGroupDestroy
in interface StringRedisConnection
key
- the stream key.group
- name of the consumer group.public StreamInfo.XInfoStream xInfo(String key)
StringRedisConnection
xInfo
in interface StringRedisConnection
key
- the key the stream is stored at.public StreamInfo.XInfoGroups xInfoGroups(String key)
StringRedisConnection
xInfoGroups
in interface StringRedisConnection
key
- the key the stream is stored at.public StreamInfo.XInfoConsumers xInfoConsumers(String key, String groupName)
StringRedisConnection
xInfoConsumers
in interface StringRedisConnection
key
- the key the stream is stored at.groupName
- name of the consumer group.public Long xLen(String key)
StringRedisConnection
xLen
in interface StringRedisConnection
key
- the stream key.public PendingMessagesSummary xPending(String key, String groupName)
StringRedisConnection
PendingMessagesSummary
for a given consumer group.xPending
in interface StringRedisConnection
key
- the key the stream is stored at. Must not be null.groupName
- the name of the consumer group. Must not be null.public PendingMessages xPending(String key, String groupName, String consumer, Range<String> range, Long count)
StringRedisConnection
xPending
in interface StringRedisConnection
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.public PendingMessages xPending(String key, String groupName, Range<String> range, Long count)
StringRedisConnection
xPending
in interface StringRedisConnection
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.public PendingMessages xPending(String key, String groupName, RedisStreamCommands.XPendingOptions options)
StringRedisConnection
messages
applying given options
.xPending
in interface StringRedisConnection
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.public List<StringRecord> xRange(String key, Range<String> range, RedisZSetCommands.Limit limit)
StringRedisConnection
Range
applying a Limit
.xRange
in interface StringRedisConnection
key
- the stream key.range
- must not be null.limit
- must not be null.public List<StringRecord> xReadAsString(StreamReadOptions readOptions, StreamOffset<String>... streams)
StringRedisConnection
StreamOffset
s.xReadAsString
in interface StringRedisConnection
readOptions
- read arguments.streams
- the streams to read from.public List<StringRecord> xReadGroupAsString(Consumer consumer, StreamReadOptions readOptions, StreamOffset<String>... streams)
StringRedisConnection
StreamOffset
s using a consumer group.xReadGroupAsString
in interface StringRedisConnection
consumer
- consumer/group.readOptions
- read arguments.streams
- the streams to read from.public List<StringRecord> xRevRange(String key, Range<String> range, RedisZSetCommands.Limit limit)
StringRedisConnection
Range
applying a Limit
in reverse order.xRevRange
in interface StringRedisConnection
key
- the stream key.range
- must not be null.limit
- must not be null.public Long xTrim(String key, long count)
StringRedisConnection
count
elements.xTrim
in interface StringRedisConnection
key
- the stream key.count
- length of the stream.public Long xAck(byte[] key, String group, RecordId... recordIds)
RedisStreamCommands
xAck
in interface RedisStreamCommands
key
- the key the stream is stored at.group
- name of the consumer group.recordIds
- the id's of the records to acknowledge.public RecordId xAdd(MapRecord<byte[],byte[],byte[]> record, RedisStreamCommands.XAddOptions options)
RedisStreamCommands
record
to the stream stored at Record.getStream()
. Record.withId(RecordId)
.xAdd
in interface RedisStreamCommands
record
- the record
to append.options
- additional options (eg. MAXLEN). Must not be null, use
RedisStreamCommands.XAddOptions.none()
instead.id
after save. null when used in pipeline / transaction.public List<RecordId> xClaimJustId(byte[] key, String group, String newOwner, RedisStreamCommands.XClaimOptions options)
RedisStreamCommands
xClaimJustId
in interface RedisStreamCommands
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.ids
that changed user.public List<ByteRecord> xClaim(byte[] key, String group, String newOwner, RedisStreamCommands.XClaimOptions options)
RedisStreamCommands
xClaim
in interface RedisStreamCommands
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.ByteRecord
that changed user.public Long xDel(byte[] key, RecordId... recordIds)
RedisStreamCommands
xDel
in interface RedisStreamCommands
key
- the key the stream is stored at.recordIds
- the id's of the records to remove.public String xGroupCreate(byte[] key, String groupName, ReadOffset readOffset)
RedisStreamCommands
xGroupCreate
in interface RedisStreamCommands
key
- the key the stream is stored at.groupName
- name of the consumer group to create.readOffset
- the offset to start at.public String xGroupCreate(byte[] key, String groupName, ReadOffset readOffset, boolean mkStream)
RedisStreamCommands
xGroupCreate
in interface RedisStreamCommands
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)public Boolean xGroupDelConsumer(byte[] key, Consumer consumer)
RedisStreamCommands
xGroupDelConsumer
in interface RedisStreamCommands
key
- the key the stream is stored at.consumer
- consumer identified by group name and consumer name.public Boolean xGroupDestroy(byte[] key, String groupName)
RedisStreamCommands
xGroupDestroy
in interface RedisStreamCommands
key
- the key the stream is stored at.groupName
- name of the consumer group.public StreamInfo.XInfoStream xInfo(byte[] key)
RedisStreamCommands
xInfo
in interface RedisStreamCommands
key
- the key the stream is stored at.public StreamInfo.XInfoGroups xInfoGroups(byte[] key)
RedisStreamCommands
xInfoGroups
in interface RedisStreamCommands
key
- the key the stream is stored at.public StreamInfo.XInfoConsumers xInfoConsumers(byte[] key, String groupName)
RedisStreamCommands
xInfoConsumers
in interface RedisStreamCommands
key
- the key the stream is stored at.groupName
- name of the consumer group.public Long xLen(byte[] key)
RedisStreamCommands
xLen
in interface RedisStreamCommands
key
- the key the stream is stored at.public PendingMessagesSummary xPending(byte[] key, String groupName)
RedisStreamCommands
PendingMessagesSummary
for a given consumer group.xPending
in interface RedisStreamCommands
key
- the key the stream is stored at. Must not be null.groupName
- the name of the consumer group. Must not be null.public PendingMessages xPending(byte[] key, String groupName, RedisStreamCommands.XPendingOptions options)
RedisStreamCommands
xPending
in interface RedisStreamCommands
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.public List<ByteRecord> xRange(byte[] key, Range<String> range, RedisZSetCommands.Limit limit)
RedisStreamCommands
limited number
of records
within a specific Range
from the
stream stored at key. Range.unbounded()
to read from the minimum and the maximum ID possible. RedisZSetCommands.Limit.unlimited()
to read all records.xRange
in interface RedisStreamCommands
key
- the key the stream is stored at.range
- must not be null.limit
- must not be null.public List<ByteRecord> xRead(StreamReadOptions readOptions, StreamOffset<byte[]>... streams)
RedisStreamCommands
StreamOffset
s.xRead
in interface RedisStreamCommands
readOptions
- read arguments.streams
- the streams to read from.public List<ByteRecord> xReadGroup(Consumer consumer, StreamReadOptions readOptions, StreamOffset<byte[]>... streams)
RedisStreamCommands
StreamOffset
s using a consumer group.xReadGroup
in interface RedisStreamCommands
consumer
- consumer/group.readOptions
- read arguments.streams
- the streams to read from.public List<ByteRecord> xRevRange(byte[] key, Range<String> range, RedisZSetCommands.Limit limit)
RedisStreamCommands
Range
applying a RedisZSetCommands.Limit
in reverse order.xRevRange
in interface RedisStreamCommands
key
- the stream key.range
- must not be null.limit
- must not be null.public Long xTrim(byte[] key, long count)
RedisStreamCommands
count
elements.xTrim
in interface RedisStreamCommands
key
- the stream key.count
- length of the stream.public void setDeserializePipelineAndTxResults(boolean deserializePipelineAndTxResults)
closePipeline()
and exec()
will be of the type returned by the underlying connectiondeserializePipelineAndTxResults
- Whether or not to deserialize pipeline and tx resultspublic List<Long> bitField(byte[] key, BitFieldSubCommands subCommands)
RedisStringCommands
key
.bitField
in interface RedisStringCommands
key
- must not be null.subCommands
- must not be null.public List<Long> bitfield(String key, BitFieldSubCommands operation)
StringRedisConnection
key
.bitfield
in interface StringRedisConnection
key
- must not be null.operation
- must not be null.public RedisConnection getDelegate()
DecoratedRedisConnection
RedisConnection
.getDelegate
in interface DecoratedRedisConnection
Copyright © 2011–2020 Pivotal Software, Inc.. All rights reserved.