public class JedisClusterConnection extends Object implements RedisClusterConnection
RedisClusterConnection
implementation on top of JedisCluster
.JedisCluster
api where possible and falls back to direct node communication using
Jedis
where needed.Modifier and Type | Class and Description |
---|---|
protected static interface |
JedisClusterConnection.JedisClusterCommandCallback<T>
Jedis specific ClusterCommandExecutor.ClusterCommandCallback . |
protected static interface |
JedisClusterConnection.JedisMultiKeyClusterCommandCallback<T>
Jedis specific ClusterCommandExecutor.MultiKeyClusterCommandCallback . |
RedisStringCommands.BitOperation, RedisStringCommands.SetOption
RedisListCommands.Position
RedisZSetCommands.Aggregate, RedisZSetCommands.Limit, RedisZSetCommands.Range, RedisZSetCommands.Tuple
RedisServerCommands.MigrateOption, RedisServerCommands.ShutdownOption
RedisGeoCommands.DistanceUnit, RedisGeoCommands.GeoLocation<T>, RedisGeoCommands.GeoRadiusCommandArgs
RedisClusterCommands.AddSlots
Constructor and Description |
---|
JedisClusterConnection(redis.clients.jedis.JedisCluster cluster)
Create new
JedisClusterConnection utilizing native connections via JedisCluster . |
JedisClusterConnection(redis.clients.jedis.JedisCluster cluster,
ClusterCommandExecutor executor)
Create new
JedisClusterConnection utilizing native connections via JedisCluster running commands
across the cluster via given ClusterCommandExecutor . |
Modifier and Type | Method and Description |
---|---|
Long |
append(byte[] key,
byte[] value)
Append a
value to key . |
void |
bgReWriteAof()
Start an Append Only File rewrite process on server.
|
void |
bgReWriteAof(RedisClusterNode node) |
void |
bgSave()
Start background saving of db on server.
|
void |
bgSave(RedisClusterNode node) |
void |
bgWriteAof()
Start an Append Only File rewrite process on server.
|
Long |
bitCount(byte[] key)
Count the number of set bits (population counting) in value stored at
key . |
Long |
bitCount(byte[] key,
long begin,
long end)
Count the number of set bits (population counting) of value stored at
key between begin and
end . |
Long |
bitOp(RedisStringCommands.BitOperation op,
byte[] destination,
byte[]... keys)
Perform bitwise operations between strings.
|
List<byte[]> |
bLPop(int timeout,
byte[]... keys)
Removes and returns first element from lists stored at
keys . |
List<byte[]> |
bRPop(int timeout,
byte[]... keys)
Removes and returns last element from lists stored at
keys . |
byte[] |
bRPopLPush(int timeout,
byte[] srcKey,
byte[] dstKey)
Remove the last element from list at
srcKey , append it to dstKey and return its value. |
void |
close()
Closes (or quits) the connection.
|
List<Object> |
closePipeline()
Executes the commands in the pipeline and returns their result.
|
void |
clusterAddSlots(RedisClusterNode node,
int... slots)
Assign slots to given
RedisClusterNode . |
void |
clusterAddSlots(RedisClusterNode node,
RedisClusterNode.SlotRange range)
Assign
RedisClusterNode.SlotRange.getSlotsArray() to given RedisClusterNode . |
Long |
clusterCountKeysInSlot(int slot)
Count the number of keys assigned to one slot.
|
void |
clusterDeleteSlots(RedisClusterNode node,
int... slots)
Remove slots from
RedisClusterNode . |
void |
clusterDeleteSlotsInRange(RedisClusterNode node,
RedisClusterNode.SlotRange range)
Removes
RedisClusterNode.SlotRange.getSlotsArray() from given RedisClusterNode . |
void |
clusterForget(RedisClusterNode node)
Remove given node from cluster.
|
ClusterInfo |
clusterGetClusterInfo()
Get cluster information.
|
List<byte[]> |
clusterGetKeysInSlot(int slot,
Integer count)
Get keys served by slot.
|
Map<RedisClusterNode,Collection<RedisClusterNode>> |
clusterGetMasterSlaveMap()
Retrieve information about masters and their connected slaves.
|
RedisClusterNode |
clusterGetNodeForKey(byte[] key)
Find the
RedisClusterNode serving given key. |
RedisClusterNode |
clusterGetNodeForSlot(int slot)
Find the
RedisClusterNode serving given slot. |
Set<RedisClusterNode> |
clusterGetNodes()
Retrieve cluster node information such as id, host, port and slots.
|
Set<RedisClusterNode> |
clusterGetSlaves(RedisClusterNode master)
Retrieve information about connected slaves for given master node.
|
Integer |
clusterGetSlotForKey(byte[] key)
Find the slot for a given
key . |
void |
clusterMeet(RedisClusterNode node)
Add given node to cluster.
|
void |
clusterReplicate(RedisClusterNode master,
RedisClusterNode slave)
Assign a slave to given master.
|
void |
clusterSetSlot(RedisClusterNode node,
int slot,
RedisClusterCommands.AddSlots mode) |
protected DataAccessException |
convertJedisAccessException(Exception ex) |
Long |
dbSize()
Get the total number of available keys in currently selected database.
|
Long |
dbSize(RedisClusterNode node) |
Long |
decr(byte[] 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 |
del(byte[]... 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. |
<T> T |
eval(byte[] script,
ReturnType returnType,
int numKeys,
byte[]... keysAndArgs)
Evaluate given
script . |
<T> T |
evalSha(byte[] scriptSha,
ReturnType returnType,
int numKeys,
byte[]... keysAndArgs)
Evaluate given
scriptSha . |
<T> T |
evalSha(String scriptSha,
ReturnType returnType,
int numKeys,
byte[]... keysAndArgs)
Evaluate given
scriptSha . |
List<Object> |
exec()
Executes all queued commands in a transaction started with
RedisTxCommands.multi() . |
Object |
execute(String command,
byte[]... args)
'Native' or 'raw' execution of the given command along-side the given arguments.
|
Boolean |
exists(byte[] key)
Determine if given
key exists. |
Boolean |
expire(byte[] 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. |
void |
flushAll()
Delete all all keys from all databases.
|
void |
flushAll(RedisClusterNode node) |
void |
flushDb()
Delete all keys of the currently selected database.
|
void |
flushDb(RedisClusterNode node) |
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. |
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)
|
List<String> |
geoHash(byte[] key,
byte[]... 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. |
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<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.
|
Long |
geoRemove(byte[] key,
byte[]... members)
Remove the members.
|
byte[] |
get(byte[] key)
Get the value of
key . |
Boolean |
getBit(byte[] key,
long offset)
Get the bit value at
offset of value at key . |
List<RedisClientInfo> |
getClientList()
Request information and statistics about connected clients.
|
List<RedisClientInfo> |
getClientList(RedisClusterNode node) |
String |
getClientName()
Returns the name of the current connection.
|
List<String> |
getConfig(RedisClusterNode node,
String pattern) |
List<String> |
getConfig(String pattern)
Load configuration parameters for given
pattern from server. |
redis.clients.jedis.JedisCluster |
getNativeConnection()
Returns the native connection (the underlying library/driver object).
|
byte[] |
getRange(byte[] key,
long begin,
long end)
Get a substring of value of
key between begin and end . |
RedisSentinelConnection |
getSentinelConnection() |
byte[] |
getSet(byte[] key,
byte[] 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 . |
Boolean |
hExists(byte[] key,
byte[] field)
Determine if given hash
field exists. |
byte[] |
hGet(byte[] key,
byte[] field)
Get value for given
field from hash at key . |
Map<byte[],byte[]> |
hGetAll(byte[] 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 . |
Set<byte[]> |
hKeys(byte[] key)
Get key set (fields) of hash at
key . |
Long |
hLen(byte[] key)
Get size of hash at
key . |
List<byte[]> |
hMGet(byte[] key,
byte[]... 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 |
Cursor<Map.Entry<byte[],byte[]>> |
hScan(byte[] 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 |
hSetNX(byte[] key,
byte[] field,
byte[] value)
Set the
value of a hash field only if field does not exist. |
List<byte[]> |
hVals(byte[] key)
Get entry set (values) of hash at
field . |
Long |
incr(byte[] 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 . |
Properties |
info()
Load default server information like
memory
cpu utilization
replication
|
Properties |
info(RedisClusterNode node) |
Properties |
info(RedisClusterNode node,
String section) |
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 . |
Set<byte[]> |
keys(RedisClusterNode node,
byte[] 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. |
Long |
lastSave(RedisClusterNode node) |
byte[] |
lIndex(byte[] 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 |
lLen(byte[] key)
Get the size of list stored at
key . |
byte[] |
lPop(byte[] key)
Removes and returns first element in list stored at
key . |
Long |
lPush(byte[] key,
byte[]... values)
Prepend
values to key . |
Long |
lPushX(byte[] key,
byte[] value)
Prepend
values to key only if the list exists. |
List<byte[]> |
lRange(byte[] key,
long begin,
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 . |
void |
lSet(byte[] key,
long index,
byte[] value)
Set the
value list element at index . |
void |
lTrim(byte[] key,
long begin,
long end)
Trim list at
key to elements between start and end . |
List<byte[]> |
mGet(byte[]... 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 . |
void |
mSet(Map<byte[],byte[]> tuples)
Set multiple keys to multiple values using key-value pairs provided in
tuple . |
Boolean |
mSetNX(Map<byte[],byte[]> tuples)
Set multiple keys to multiple values using key-value pairs provided in
tuple only if the provided key does
not exist. |
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 |
pExpire(byte[] 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. |
Long |
pfAdd(byte[] key,
byte[]... 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).
|
void |
pfMerge(byte[] destinationKey,
byte[]... sourceKeys)
Merge N different HyperLogLogs at sourceKeys into a single destinationKey.
|
String |
ping()
Test connection.
|
String |
ping(RedisClusterNode node) |
void |
pSetEx(byte[] key,
long milliseconds,
byte[] 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.
|
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 |
publish(byte[] channel,
byte[] message)
Publishes the given message to the given channel.
|
byte[] |
randomKey()
Return a random key from the keyspace.
|
byte[] |
randomKey(RedisClusterNode node) |
void |
rename(byte[] sourceKey,
byte[] targetKey)
Rename key
oldName to newName . |
Boolean |
renameNX(byte[] sourceKey,
byte[] targetKey)
Rename key
oldName to newName only if newName does not exist. |
void |
resetConfigStats()
Reset statistic counters on server.
|
void |
resetConfigStats(RedisClusterNode node) |
void |
restore(byte[] key,
long ttlInMillis,
byte[] serializedValue)
|
byte[] |
rPop(byte[] 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. |
Long |
rPush(byte[] key,
byte[]... values)
Append
values to key . |
Long |
rPushX(byte[] key,
byte[] value)
Append
values to key only if the list exists. |
Long |
sAdd(byte[] key,
byte[]... values)
Add given
values to set at key . |
void |
save()
Synchronous save current db snapshot on server.
|
void |
save(RedisClusterNode node) |
Cursor<byte[]> |
scan(ScanOptions options)
Use a
Cursor to iterate over keys. |
Long |
sCard(byte[] key)
Get size of set at
key . |
List<Boolean> |
scriptExists(String... scriptShas)
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.
|
Set<byte[]> |
sDiff(byte[]... keys)
Diff all sets for given
keys . |
Long |
sDiffStore(byte[] destKey,
byte[]... keys)
Diff all sets for given
keys and store result in destKey . |
void |
select(int dbIndex)
Select the DB with given positive
dbIndex . |
void |
set(byte[] key,
byte[] value)
Set
value for key . |
void |
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 |
setBit(byte[] 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 |
setConfig(RedisClusterNode node,
String param,
String value) |
void |
setConfig(String param,
String value)
Set server configuration for
param to value . |
void |
setEx(byte[] key,
long seconds,
byte[] 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. |
void |
setRange(byte[] key,
byte[] value,
long offset)
Overwrite parts of
key starting at the specified offset with given value . |
void |
shutdown()
Shutdown server.
|
void |
shutdown(RedisClusterNode node) |
void |
shutdown(RedisServerCommands.ShutdownOption option)
Shutdown server.
|
Set<byte[]> |
sInter(byte[]... 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 . |
Boolean |
sIsMember(byte[] key,
byte[] 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 . |
Boolean |
sMove(byte[] srcKey,
byte[] destKey,
byte[] 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 . |
byte[] |
sPop(byte[] key)
Remove and return a random member 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 . |
Long |
sRem(byte[] key,
byte[]... 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 . |
Long |
strLen(byte[] key)
Get the length of the value stored at
key . |
void |
subscribe(MessageListener listener,
byte[]... channels)
Subscribes the connection to the given channels.
|
Set<byte[]> |
sUnion(byte[]... 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 |
time()
Request server timestamp using
TIME command. |
Long |
time(RedisClusterNode node) |
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 . |
DataType |
type(byte[] key)
Determine the type stored at
key . |
void |
unwatch()
Flushes all the previously
#watch(byte[]...) keys. |
void |
watch(byte[]... keys)
Watch given
keys for modifications during transaction started with RedisTxCommands.multi() . |
Boolean |
zAdd(byte[] key,
double score,
byte[] value)
Add
value to a sorted set at key , or update its score if it already exists. |
Long |
zAdd(byte[] key,
Set<RedisZSetCommands.Tuple> tuples)
Add
tuples to a sorted set at key , or update its score if it already exists. |
Long |
zCard(byte[] key)
Get the size of sorted set with
key . |
Long |
zCount(byte[] key,
double min,
double max)
Count number of elements within sorted set with scores between
min and max . |
Long |
zCount(byte[] key,
RedisZSetCommands.Range range)
Count number of elements within sorted set with scores between
Range#min and Range#max . |
Double |
zIncrBy(byte[] key,
double increment,
byte[] value)
Increment the score of element with
value in sorted set by increment . |
Long |
zInterStore(byte[] destKey,
byte[]... sets)
Intersect sorted
sets and store result in destination key . |
Long |
zInterStore(byte[] destKey,
RedisZSetCommands.Aggregate aggregate,
int[] weights,
byte[]... sets)
Intersect sorted
sets and store result in destination key . |
Set<byte[]> |
zRange(byte[] key,
long begin,
long end)
Get elements between
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<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<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<RedisZSetCommands.Tuple> |
zRangeWithScores(byte[] key,
long begin,
long end)
|
Long |
zRank(byte[] key,
byte[] value)
Determine the index of element with
value in a sorted set. |
Long |
zRem(byte[] key,
byte[]... values)
Remove
values from sorted set. |
Long |
zRemRange(byte[] key,
long begin,
long end)
Remove elements in range between
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 . |
Set<byte[]> |
zRevRange(byte[] key,
long begin,
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<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<RedisZSetCommands.Tuple> |
zRevRangeWithScores(byte[] key,
long begin,
long end)
Get set of
RedisZSetCommands.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. |
Cursor<RedisZSetCommands.Tuple> |
zScan(byte[] key,
ScanOptions options)
Use a
Cursor to iterate over elements in sorted set at key . |
Double |
zScore(byte[] key,
byte[] value)
Get the score of element with
value from sorted set with key key . |
Long |
zUnionStore(byte[] destKey,
byte[]... sets)
Union sorted
sets and store result in destination key . |
Long |
zUnionStore(byte[] destKey,
RedisZSetCommands.Aggregate aggregate,
int[] weights,
byte[]... sets)
Union sorted
sets and store result in destination key . |
public JedisClusterConnection(redis.clients.jedis.JedisCluster cluster)
JedisClusterConnection
utilizing native connections via JedisCluster
.cluster
- must not be null.public JedisClusterConnection(redis.clients.jedis.JedisCluster cluster, ClusterCommandExecutor executor)
JedisClusterConnection
utilizing native connections via JedisCluster
running commands
across the cluster via given ClusterCommandExecutor
.cluster
- must not be null.executor
- must not be null.public Object execute(String command, byte[]... args)
RedisCommands
execute
in interface RedisCommands
command
- Command to executeargs
- Possible command arguments (may be null)public Long del(byte[]... keys)
RedisKeyCommands
keys
.del
in interface RedisKeyCommands
keys
- must not be null.public DataType type(byte[] key)
RedisKeyCommands
key
.type
in interface RedisKeyCommands
key
- must not be null.public Set<byte[]> keys(byte[] pattern)
RedisKeyCommands
pattern
.keys
in interface RedisKeyCommands
pattern
- must not be null.public Set<byte[]> keys(RedisClusterNode node, byte[] pattern)
keys
in interface RedisClusterConnection
node
- must not be null.pattern
- must not be null.RedisKeyCommands.keys(byte[])
public Cursor<byte[]> scan(ScanOptions options)
RedisKeyCommands
Cursor
to iterate over keys.scan
in interface RedisKeyCommands
options
- must not be null.public byte[] randomKey()
RedisKeyCommands
randomKey
in interface RedisKeyCommands
public byte[] randomKey(RedisClusterNode node)
randomKey
in interface RedisClusterConnection
node
- must not be null.RedisKeyCommands.randomKey()
public void rename(byte[] sourceKey, byte[] targetKey)
RedisKeyCommands
oldName
to newName
.rename
in interface RedisKeyCommands
sourceKey
- must not be null.targetKey
- must not be null.public Boolean renameNX(byte[] sourceKey, byte[] targetKey)
RedisKeyCommands
oldName
to newName
only if newName
does not exist.renameNX
in interface RedisKeyCommands
sourceKey
- must not be null.targetKey
- 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 pExpire(byte[] key, long millis)
RedisKeyCommands
key
in milliseconds.pExpire
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 Boolean pExpireAt(byte[] key, long unixTimeInMillis)
RedisKeyCommands
key
as a UNIX timestamp in milliseconds.pExpireAt
in interface RedisKeyCommands
key
- must not be null.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 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 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 List<byte[]> sort(byte[] key, SortParameters params)
RedisKeyCommands
key
.sort
in interface RedisKeyCommands
key
- must not be null.params
- 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 byte[] dump(byte[] key)
RedisKeyCommands
key
.dump
in interface RedisKeyCommands
key
- must not be null.public void restore(byte[] key, long ttlInMillis, byte[] serializedValue)
RedisKeyCommands
restore
in interface RedisKeyCommands
key
- must not be null.serializedValue
- must not be null.public byte[] get(byte[] key)
RedisStringCommands
key
.get
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.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.public void set(byte[] key, byte[] value)
RedisStringCommands
value
for key
.set
in interface RedisStringCommands
key
- must not be null.value
- must not be null.public void 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
- can be null. Defaulted to Expiration.persistent()
.option
- can be null. Defaulted to RedisStringCommands.SetOption.UPSERT
.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 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 void 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 void mSet(Map<byte[],byte[]> tuples)
RedisStringCommands
tuple
.mSet
in interface RedisStringCommands
tuples
- must not be null.public Boolean mSetNX(Map<byte[],byte[]> tuples)
RedisStringCommands
tuple
only if the provided key does
not exist.mSetNX
in interface RedisStringCommands
tuples
- must not be null.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 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 append(byte[] key, byte[] value)
RedisStringCommands
value
to key
.append
in interface RedisStringCommands
key
- must not be null.public byte[] getRange(byte[] key, long begin, long end)
RedisStringCommands
key
between begin
and end
.getRange
in interface RedisStringCommands
key
- must not be null.public void setRange(byte[] key, byte[] value, long offset)
RedisStringCommands
key
starting at the specified offset
with given value
.setRange
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 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
.public Long bitCount(byte[] key)
RedisStringCommands
key
.bitCount
in interface RedisStringCommands
key
- must not be null.public Long bitCount(byte[] key, long begin, long end)
RedisStringCommands
key
between begin
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.public Long strLen(byte[] key)
RedisStringCommands
key
.strLen
in interface RedisStringCommands
key
- must not be null.public Long rPush(byte[] key, byte[]... values)
RedisListCommands
values
to key
.rPush
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.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.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.public Long lLen(byte[] key)
RedisListCommands
key
.lLen
in interface RedisListCommands
key
- must not be null.public List<byte[]> lRange(byte[] key, long begin, long end)
RedisListCommands
start
and end
from list at key
.lRange
in interface RedisListCommands
key
- must not be null.public void lTrim(byte[] key, long begin, long end)
RedisListCommands
key
to elements between start
and end
.lTrim
in interface RedisListCommands
key
- must not be null.public byte[] lIndex(byte[] key, long index)
RedisListCommands
index
form list at key
.lIndex
in interface RedisListCommands
key
- must not be null.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.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 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 byte[] lPop(byte[] key)
RedisListCommands
key
.lPop
in interface RedisListCommands
key
- must not be null.public byte[] rPop(byte[] key)
RedisListCommands
key
.rPop
in interface RedisListCommands
key
- must not be null.public List<byte[]> bLPop(int timeout, byte[]... keys)
RedisListCommands
keys
. timeout
reached.bLPop
in interface RedisListCommands
keys
- must not be null.RedisListCommands.lPop(byte[])
public List<byte[]> bRPop(int timeout, byte[]... keys)
RedisListCommands
keys
. timeout
reached.bRPop
in interface RedisListCommands
keys
- must not be null.RedisListCommands.rPop(byte[])
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 byte[] bRPopLPush(int timeout, byte[] srcKey, byte[] dstKey)
RedisListCommands
srcKey
, append it to dstKey
and return its value.
timeout
reached.bRPopLPush
in interface RedisListCommands
srcKey
- must not be null.dstKey
- must not be null.RedisListCommands.rPopLPush(byte[], byte[])
public Long sAdd(byte[] key, byte[]... values)
RedisSetCommands
values
to set at key
.sAdd
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.public byte[] sPop(byte[] key)
RedisSetCommands
key
.sPop
in interface RedisSetCommands
key
- must not be null.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.public Long sCard(byte[] key)
RedisSetCommands
key
.sCard
in interface RedisSetCommands
key
- must not be null.public Boolean sIsMember(byte[] key, byte[] value)
RedisSetCommands
key
contains value
.sIsMember
in interface RedisSetCommands
key
- must not be null.public Set<byte[]> sInter(byte[]... keys)
RedisSetCommands
keys
.sInter
in interface RedisSetCommands
keys
- must not be null.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 Set<byte[]> sUnion(byte[]... keys)
RedisSetCommands
keys
.sUnion
in interface RedisSetCommands
keys
- must not be null.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 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 Set<byte[]> sMembers(byte[] key)
RedisSetCommands
key
.sMembers
in interface RedisSetCommands
key
- must not be null.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 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 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 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 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 zRank(byte[] key, byte[] value)
RedisZSetCommands
value
in a sorted set.zRank
in interface RedisZSetCommands
key
- must not be null.value
- the value.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 Set<byte[]> zRange(byte[] key, long begin, long end)
RedisZSetCommands
start
and end
from sorted set.zRange
in interface RedisZSetCommands
key
- 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.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.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.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.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.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 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[]> 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.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.public Set<RedisZSetCommands.Tuple> zRangeWithScores(byte[] key, long begin, long end)
RedisZSetCommands
zRangeWithScores
in interface RedisZSetCommands
key
- must not be null.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.public Set<RedisZSetCommands.Tuple> zRangeByScoreWithScores(byte[] key, double min, double max)
RedisZSetCommands
zRangeByScoreWithScores
in interface RedisZSetCommands
key
- must not be null.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.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
public Set<byte[]> zRevRange(byte[] key, long begin, long end)
RedisZSetCommands
start
to end
from sorted set ordered from high to low.zRevRange
in interface RedisZSetCommands
key
- must not be null.public Set<RedisZSetCommands.Tuple> zRevRangeWithScores(byte[] key, long begin, 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.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.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.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<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 Long zCount(byte[] key, double min, double max)
RedisZSetCommands
min
and max
.zCount
in interface RedisZSetCommands
key
- must not be null.public Long zCard(byte[] key)
RedisZSetCommands
key
.zCard
in interface RedisZSetCommands
key
- must not be null.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 zRemRange(byte[] key, long begin, 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 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 Long zUnionStore(byte[] destKey, RedisZSetCommands.Aggregate aggregate, int[] 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.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 Long zInterStore(byte[] destKey, RedisZSetCommands.Aggregate aggregate, int[] 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.sets
- 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 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 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.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.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 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 null.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 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.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 Long hDel(byte[] key, byte[]... fields)
RedisHashCommands
fields
.hDel
in interface RedisHashCommands
key
- must not be null.fields
- must not be null.public Long hLen(byte[] key)
RedisHashCommands
key
.hLen
in interface RedisHashCommands
key
- must not be null.public Set<byte[]> hKeys(byte[] key)
RedisHashCommands
key
.hKeys
in interface RedisHashCommands
key
- must not be null.public List<byte[]> hVals(byte[] key)
RedisHashCommands
field
.hVals
in interface RedisHashCommands
key
- must not be null.public Map<byte[],byte[]> hGetAll(byte[] key)
RedisHashCommands
key
.hGetAll
in interface RedisHashCommands
key
- 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.public void multi()
RedisTxCommands
RedisTxCommands.exec()
or rolled back using RedisTxCommands.discard()
multi
in interface RedisTxCommands
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 void discard()
RedisTxCommands
RedisTxCommands.multi()
.discard
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 void unwatch()
RedisTxCommands
#watch(byte[]...)
keys.unwatch
in interface RedisTxCommands
public boolean isSubscribed()
RedisPubSubCommands
isSubscribed
in interface RedisPubSubCommands
public Subscription getSubscription()
RedisPubSubCommands
getSubscription
in interface RedisPubSubCommands
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 publishpublic 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 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 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(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 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(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 List<String> geoHash(byte[] key, byte[]... members)
RedisGeoCommands
geoHash
in interface RedisGeoCommands
key
- must not be null.members
- must not be null.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.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 void select(int dbIndex)
RedisConnectionCommands
dbIndex
.select
in interface RedisConnectionCommands
dbIndex
- the database index.public byte[] echo(byte[] message)
RedisConnectionCommands
message
via server roundtrip.echo
in interface RedisConnectionCommands
message
- the message to echo.public String ping()
RedisConnectionCommands
ping
in interface RedisConnectionCommands
public String ping(RedisClusterNode node)
ping
in interface RedisClusterConnection
node
- must not be null.RedisConnectionCommands.ping()
public void bgWriteAof()
RedisServerCommands
bgWriteAof
in interface RedisServerCommands
public void bgReWriteAof(RedisClusterNode node)
bgReWriteAof
in interface RedisClusterConnection
node
- must not be null.RedisServerCommands.bgReWriteAof()
public void bgReWriteAof()
RedisServerCommands
bgReWriteAof
in interface RedisServerCommands
public void bgSave()
RedisServerCommands
bgSave
in interface RedisServerCommands
public void bgSave(RedisClusterNode node)
bgSave
in interface RedisClusterConnection
node
- must not be null.RedisServerCommands.bgSave()
public Long lastSave()
RedisServerCommands
RedisServerCommands.bgSave()
operation in seconds.lastSave
in interface RedisServerCommands
public Long lastSave(RedisClusterNode node)
lastSave
in interface RedisClusterConnection
node
- must not be null.RedisServerCommands.lastSave()
public void save()
RedisServerCommands
save
in interface RedisServerCommands
public void save(RedisClusterNode node)
save
in interface RedisClusterConnection
node
- must not be null.RedisServerCommands.save()
public Long dbSize()
RedisServerCommands
dbSize
in interface RedisServerCommands
public Long dbSize(RedisClusterNode node)
dbSize
in interface RedisClusterConnection
node
- must not be null.RedisServerCommands.dbSize()
public void flushDb()
RedisServerCommands
flushDb
in interface RedisServerCommands
public void flushDb(RedisClusterNode node)
flushDb
in interface RedisClusterConnection
node
- must not be null.RedisServerCommands.flushDb()
public void flushAll()
RedisServerCommands
flushAll
in interface RedisServerCommands
public void flushAll(RedisClusterNode node)
flushAll
in interface RedisClusterConnection
node
- must not be null.RedisServerCommands.flushAll()
public Properties info()
RedisServerCommands
info
in interface RedisServerCommands
public Properties info(RedisClusterNode node)
info
in interface RedisClusterConnection
node
- must not be null.RedisServerCommands.info()
public Properties info(String section)
RedisServerCommands
selection
.info
in interface RedisServerCommands
public Properties info(RedisClusterNode node, String section)
info
in interface RedisClusterConnection
node
- must not be null.RedisServerCommands.info(String)
public void shutdown()
RedisServerCommands
shutdown
in interface RedisServerCommands
public void shutdown(RedisClusterNode node)
shutdown
in interface RedisClusterConnection
node
- must not be null.RedisServerCommands.shutdown()
public void shutdown(RedisServerCommands.ShutdownOption option)
RedisServerCommands
shutdown
in interface RedisServerCommands
public List<String> getConfig(String pattern)
RedisServerCommands
pattern
from server.getConfig
in interface RedisServerCommands
public List<String> getConfig(RedisClusterNode node, String pattern)
getConfig
in interface RedisClusterConnection
node
- must not be null.RedisServerCommands.getConfig(String)
public void setConfig(String param, String value)
RedisServerCommands
param
to value
.setConfig
in interface RedisServerCommands
public void setConfig(RedisClusterNode node, String param, String value)
setConfig
in interface RedisClusterConnection
node
- must not be null.RedisServerCommands.setConfig(String, String)
public void resetConfigStats()
RedisServerCommands
RedisServerCommands.info()
.resetConfigStats
in interface RedisServerCommands
public void resetConfigStats(RedisClusterNode node)
resetConfigStats
in interface RedisClusterConnection
node
- must not be null.RedisServerCommands.resetConfigStats()
public Long time()
RedisServerCommands
TIME
command.time
in interface RedisServerCommands
public Long time(RedisClusterNode node)
time
in interface RedisClusterConnection
node
- must not be null.RedisServerCommands.time()
public void killClient(String host, int port)
RedisServerCommands
killClient
in interface RedisServerCommands
host
- of connection to close.port
- of connection to closepublic void setClientName(byte[] name)
RedisServerCommands
setClientName
in interface RedisServerCommands
public String getClientName()
RedisServerCommands
getClientName
in interface RedisServerCommands
public List<RedisClientInfo> getClientList()
RedisServerCommands
getClientList
in interface RedisServerCommands
List
of RedisClientInfo
objects.public List<RedisClientInfo> getClientList(RedisClusterNode node)
getClientList
in interface RedisClusterConnection
node
- must not be null.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 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... scriptShas)
RedisScriptingCommands
scriptShas
exist in script cache.scriptExists
in interface RedisScriptingCommands
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 scriptSha, ReturnType returnType, int numKeys, byte[]... keysAndArgs)
RedisScriptingCommands
scriptSha
.evalSha
in interface RedisScriptingCommands
scriptSha
- must not be null.returnType
- must not be null.keysAndArgs
- must not be null.public <T> T evalSha(byte[] scriptSha, ReturnType returnType, int numKeys, byte[]... keysAndArgs)
RedisScriptingCommands
scriptSha
.evalSha
in interface RedisScriptingCommands
scriptSha
- must not be null.returnType
- must not be null.keysAndArgs
- must not be null.public Long pfAdd(byte[] key, byte[]... values)
HyperLogLogCommands
pfAdd
in interface HyperLogLogCommands
key
- must not be null.values
- must not be null.public Long pfCount(byte[]... keys)
HyperLogLogCommands
pfCount
in interface HyperLogLogCommands
keys
- must not be null.public void pfMerge(byte[] destinationKey, byte[]... sourceKeys)
HyperLogLogCommands
pfMerge
in interface HyperLogLogCommands
destinationKey
- must not be null.sourceKeys
- must not be null.public Boolean exists(byte[] key)
RedisKeyCommands
key
exists.exists
in interface RedisKeyCommands
key
- must not be null.public void clusterSetSlot(RedisClusterNode node, int slot, RedisClusterCommands.AddSlots mode)
clusterSetSlot
in interface RedisClusterCommands
node
- must not be null.mode
- must not benull.public List<byte[]> clusterGetKeysInSlot(int slot, Integer count)
RedisClusterCommands
clusterGetKeysInSlot
in interface RedisClusterCommands
count
- must not be null.public void clusterAddSlots(RedisClusterNode node, int... slots)
RedisClusterCommands
RedisClusterNode
.clusterAddSlots
in interface RedisClusterCommands
node
- must not be null.public void clusterAddSlots(RedisClusterNode node, RedisClusterNode.SlotRange range)
RedisClusterCommands
RedisClusterNode.SlotRange.getSlotsArray()
to given RedisClusterNode
.clusterAddSlots
in interface RedisClusterCommands
node
- must not be null.range
- must not be null.public Long clusterCountKeysInSlot(int slot)
RedisClusterCommands
clusterCountKeysInSlot
in interface RedisClusterCommands
public void clusterDeleteSlots(RedisClusterNode node, int... slots)
RedisClusterCommands
RedisClusterNode
.clusterDeleteSlots
in interface RedisClusterCommands
node
- must not be null.public void clusterDeleteSlotsInRange(RedisClusterNode node, RedisClusterNode.SlotRange range)
RedisClusterCommands
RedisClusterNode.SlotRange.getSlotsArray()
from given RedisClusterNode
.clusterDeleteSlotsInRange
in interface RedisClusterCommands
node
- must not be null.range
- must not be null.public void clusterForget(RedisClusterNode node)
RedisClusterCommands
clusterForget
in interface RedisClusterCommands
node
- must not be null.public void clusterMeet(RedisClusterNode node)
RedisClusterCommands
clusterMeet
in interface RedisClusterCommands
node
- must contain host
and RedisNode.getPort()
and must
not be null.public void clusterReplicate(RedisClusterNode master, RedisClusterNode slave)
RedisClusterCommands
clusterReplicate
in interface RedisClusterCommands
master
- must not be null.slave
- must not be null.public Integer clusterGetSlotForKey(byte[] key)
RedisClusterCommands
key
.clusterGetSlotForKey
in interface RedisClusterCommands
key
- must not be null.public RedisClusterNode clusterGetNodeForSlot(int slot)
RedisClusterCommands
RedisClusterNode
serving given slot.clusterGetNodeForSlot
in interface RedisClusterCommands
public Set<RedisClusterNode> clusterGetNodes()
RedisClusterCommands
clusterGetNodes
in interface RedisClusterCommands
public Set<RedisClusterNode> clusterGetSlaves(RedisClusterNode master)
RedisClusterCommands
clusterGetSlaves
in interface RedisClusterCommands
master
- must not be null.public Map<RedisClusterNode,Collection<RedisClusterNode>> clusterGetMasterSlaveMap()
RedisClusterCommands
clusterGetMasterSlaveMap
in interface RedisClusterCommands
public RedisClusterNode clusterGetNodeForKey(byte[] key)
RedisClusterCommands
RedisClusterNode
serving given key.clusterGetNodeForKey
in interface RedisClusterCommands
key
- must not be null.public ClusterInfo clusterGetClusterInfo()
RedisClusterCommands
clusterGetClusterInfo
in interface RedisClusterCommands
public void migrate(byte[] key, RedisNode target, int dbIndex, 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, 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
.protected DataAccessException convertJedisAccessException(Exception ex)
public void close() throws DataAccessException
RedisConnection
close
in interface RedisConnection
DataAccessException
public boolean isClosed()
RedisConnection
isClosed
in interface RedisConnection
public redis.clients.jedis.JedisCluster getNativeConnection()
RedisConnection
getNativeConnection
in interface RedisConnection
public boolean isQueueing()
RedisConnection
isQueueing
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 List<Object> closePipeline() throws RedisPipelineException
RedisConnection
closePipeline
in interface RedisConnection
RedisPipelineException
- if the pipeline contains any incorrect/invalid statementspublic RedisSentinelConnection getSentinelConnection()
getSentinelConnection
in interface RedisConnection
Copyright © 2011–2019 Pivotal Software, Inc.. All rights reserved.