public class UnifiedJedis extends Object implements JedisCommands, JedisBinaryCommands, SampleKeyedCommands, SampleBinaryKeyedCommands, RedisModuleCommands, AutoCloseable
| Modifier and Type | Field and Description |
|---|---|
protected CommandExecutor |
executor |
protected ConnectionProvider |
provider |
| Constructor and Description |
|---|
UnifiedJedis() |
UnifiedJedis(ClusterConnectionProvider provider,
int maxAttempts,
Duration maxTotalRetriesDuration) |
UnifiedJedis(Connection connection) |
UnifiedJedis(ConnectionProvider provider) |
UnifiedJedis(ConnectionProvider provider,
int maxAttempts,
Duration maxTotalRetriesDuration) |
UnifiedJedis(HostAndPort hostAndPort) |
UnifiedJedis(HostAndPort hostAndPort,
JedisClientConfig clientConfig) |
UnifiedJedis(JedisSocketFactory socketFactory) |
UnifiedJedis(Set<HostAndPort> jedisClusterNodes,
JedisClientConfig clientConfig,
org.apache.commons.pool2.impl.GenericObjectPoolConfig<Connection> poolConfig,
int maxAttempts,
Duration maxTotalRetriesDuration) |
UnifiedJedis(Set<HostAndPort> jedisClusterNodes,
JedisClientConfig clientConfig,
int maxAttempts) |
UnifiedJedis(Set<HostAndPort> jedisClusterNodes,
JedisClientConfig clientConfig,
int maxAttempts,
Duration maxTotalRetriesDuration) |
UnifiedJedis(ShardedConnectionProvider provider) |
UnifiedJedis(ShardedConnectionProvider provider,
Pattern tagPattern) |
UnifiedJedis(String url) |
UnifiedJedis(URI uri) |
UnifiedJedis(URI uri,
JedisClientConfig config) |
| Modifier and Type | Method and Description |
|---|---|
long |
append(byte[] key,
byte[] value) |
long |
append(String key,
String value)
Append Command
If the key already exists and is a string, this command appends the provided value at the end
of the string.
|
boolean |
bfAdd(String key,
String item)
BF.ADD {key} {item} |
boolean |
bfExists(String key,
String item)
BF.EXISTS {key} {item} |
Map<String,Object> |
bfInfo(String key) |
List<Boolean> |
bfInsert(String key,
BFInsertParams insertParams,
String... items)
BF.INSERT {key} [CAPACITY {cap}] [ERROR {error}] [EXPANSION {expansion}] [NOCREATE]
[NONSCALING] ITEMS {item ...} |
List<Boolean> |
bfInsert(String key,
String... items)
BF.INSERT {key} ITEMS {item ...} |
List<Boolean> |
bfMAdd(String key,
String... items)
BF.MADD {key} {item ...} |
List<Boolean> |
bfMExists(String key,
String... items)
BF.MEXISTS {key} {item ...} |
String |
bfReserve(String key,
double errorRate,
long capacity)
BF.RESERVE {key} {error_rate} {capacity} |
String |
bfReserve(String key,
double errorRate,
long capacity,
BFReserveParams reserveParams)
BF.RESERVE {key} {error_rate} {capacity} [EXPANSION {expansion}] [NONSCALING] |
long |
bitcount(byte[] key) |
long |
bitcount(byte[] key,
long start,
long end) |
long |
bitcount(byte[] key,
long start,
long end,
BitCountOption option) |
long |
bitcount(String key)
Bitcount Command
Count the number of set bits (population counting) in a string.
|
long |
bitcount(String key,
long start,
long end)
Bitcount Command
Count the number of set bits (population counting) in a string only in an interval start and end.
|
long |
bitcount(String key,
long start,
long end,
BitCountOption option) |
List<Long> |
bitfield(byte[] key,
byte[]... arguments) |
List<Long> |
bitfield(String key,
String... arguments)
Bitfield Command
The command treats a Redis string as an array of bits, and is capable of addressing specific integer
fields of varying bit widths and arbitrary non (necessary) aligned offset.
|
List<Long> |
bitfieldReadonly(byte[] key,
byte[]... arguments) |
List<Long> |
bitfieldReadonly(String key,
String... arguments)
The readonly version of
BITFIELD |
long |
bitop(BitOP op,
byte[] destKey,
byte[]... srcKeys) |
long |
bitop(BitOP op,
String destKey,
String... srcKeys)
Bitop Command
Perform a bitwise operation between multiple keys (containing string values) and store the result in the destKey.
|
long |
bitpos(byte[] key,
boolean value) |
long |
bitpos(byte[] key,
boolean value,
BitPosParams params) |
long |
bitpos(String key,
boolean value)
Bitpos Command
Return the position of the first bit set to 1 or 0 in a string.
|
long |
bitpos(String key,
boolean value,
BitPosParams params)
Bitpos Command
Return the position of the first bit set to 1 or 0 in a string.
|
byte[] |
blmove(byte[] srcKey,
byte[] dstKey,
ListDirection from,
ListDirection to,
double timeout) |
String |
blmove(String srcKey,
String dstKey,
ListDirection from,
ListDirection to,
double timeout)
Pop an element from a list, push it to another list and return it; or block until one is available
|
KeyValue<byte[],List<byte[]>> |
blmpop(long timeout,
ListDirection direction,
byte[]... keys) |
KeyValue<byte[],List<byte[]>> |
blmpop(long timeout,
ListDirection direction,
int count,
byte[]... keys) |
KeyValue<String,List<String>> |
blmpop(long timeout,
ListDirection direction,
int count,
String... keys) |
KeyValue<String,List<String>> |
blmpop(long timeout,
ListDirection direction,
String... keys) |
List<byte[]> |
blpop(double timeout,
byte[]... keys) |
KeyedListElement |
blpop(double timeout,
String... keys)
The blocking version of
ListCommands.lpop(String) LPOP} because it blocks the connection
when there are no elements to pop from any of the given lists. |
KeyedListElement |
blpop(double timeout,
String key) |
List<byte[]> |
blpop(int timeout,
byte[]... keys) |
List<String> |
blpop(int timeout,
String... keys)
The blocking version of
ListCommands.lpop(String) LPOP} because it blocks the connection
when there are no elements to pop from any of the given lists. |
List<String> |
blpop(int timeout,
String key) |
List<byte[]> |
brpop(double timeout,
byte[]... keys) |
KeyedListElement |
brpop(double timeout,
String... keys)
The blocking version of
ListCommands.rpop(String) RPOP} because it blocks the connection
when there are no elements to pop from any of the given lists. |
KeyedListElement |
brpop(double timeout,
String key) |
List<byte[]> |
brpop(int timeout,
byte[]... keys) |
List<String> |
brpop(int timeout,
String... keys)
The blocking version of
ListCommands.rpop(String) RPOP} because it blocks the connection
when there are no elements to pop from any of the given lists. |
List<String> |
brpop(int timeout,
String key) |
byte[] |
brpoplpush(byte[] source,
byte[] destination,
int timeout) |
String |
brpoplpush(String source,
String destination,
int timeout)
The blocking variant of
ListCommands.rpoplpush(String, String). |
KeyValue<byte[],List<Tuple>> |
bzmpop(long timeout,
SortedSetOption option,
byte[]... keys) |
KeyValue<byte[],List<Tuple>> |
bzmpop(long timeout,
SortedSetOption option,
int count,
byte[]... keys) |
KeyValue<String,List<Tuple>> |
bzmpop(long timeout,
SortedSetOption option,
int count,
String... keys) |
KeyValue<String,List<Tuple>> |
bzmpop(long timeout,
SortedSetOption option,
String... keys) |
List<byte[]> |
bzpopmax(double timeout,
byte[]... keys) |
KeyedZSetElement |
bzpopmax(double timeout,
String... keys)
The blocking version of
ZPOPMAX |
List<byte[]> |
bzpopmin(double timeout,
byte[]... keys) |
KeyedZSetElement |
bzpopmin(double timeout,
String... keys)
The blocking version of
ZPOPMIN |
boolean |
cfAdd(String key,
String item)
CF.ADD Adds an item to the cuckoo filter, creating the filter if it does not
exist
|
boolean |
cfAddNx(String key,
String item)
CF.ADDNX Adds an item to the cuckoo filter, only if it does not exist yet
|
long |
cfCount(String key,
String item)
CF.COUNT Returns the number of times an item may be in the filter.
|
boolean |
cfDel(String key,
String item)
CF.DEL Deletes an item once from the filter.
|
boolean |
cfExists(String key,
String item)
CF.EXISTS Check if an item exists in a Cuckoo Filter
|
Map<String,Object> |
cfInfo(String key)
CF.INFO Return information about filter
|
List<Boolean> |
cfInsert(String key,
CFInsertParams insertParams,
String... items)
CF.INSERT Adds one or more items to a cuckoo filter, using the passed
options
|
List<Boolean> |
cfInsert(String key,
String... items)
CF.INSERT Adds one or more items to a cuckoo filter, creating it if it does
not exist yet.
|
List<Boolean> |
cfInsertNx(String key,
CFInsertParams insertParams,
String... items)
CF.INSERTNX Adds one or more items to a cuckoo filter, using the passed
options
|
List<Boolean> |
cfInsertNx(String key,
String... items)
CF.INSERTNX Adds one or more items to a cuckoo filter, only if it does not
exist yet
|
List<Boolean> |
cfMExists(String key,
String... items)
CF.MEXISTS {key} {item ...} |
String |
cfReserve(String key,
long capacity)
CF.RESERVE Creates a Cuckoo Filter under key with the given parameters
|
String |
cfReserve(String key,
long capacity,
CFReserveParams reserveParams)
CF.RESERVE Creates a Cuckoo Filter under key with the given parameters
|
void |
close() |
List<Long> |
cmsIncrBy(String key,
Map<String,Long> itemIncrements)
CMS.INCRBY Increases the count of one or more item.
|
Map<String,Object> |
cmsInfo(String key)
CMS.INFO Returns width, depth and total count of the sketch.
|
String |
cmsInitByDim(String key,
long width,
long depth)
CMS.INITBYDIM Initializes a Count-Min Sketch to dimensions specified by user.
|
String |
cmsInitByProb(String key,
double error,
double probability)
CMS.INITBYPROB Initializes a Count-Min Sketch to accommodate requested
capacity.
|
String |
cmsMerge(String destKey,
Map<String,Long> keysAndWeights)
CMS.MERGE Merges several sketches into one sketch.
|
String |
cmsMerge(String destKey,
String... keys)
CMS.MERGE Merges several sketches into one sketch.
|
List<Long> |
cmsQuery(String key,
String... items)
CMS.QUERY Returns count for item.
|
boolean |
copy(byte[] srcKey,
byte[] dstKey,
boolean replace) |
boolean |
copy(String srcKey,
String dstKey,
boolean replace)
Copy Command
Copy the value stored at the source key to the destination key.
|
long |
dbSize() |
long |
decr(byte[] key) |
long |
decr(String key)
Decr Command
Decrement the number stored at key by one.
|
long |
decrBy(byte[] key,
long decrement) |
long |
decrBy(String key,
long decrement)
DecrBy Command
DECRBY work just like
DECR but instead to decrement by 1 the
decrement is integer. |
long |
del(byte[]... keys) |
long |
del(byte[] key) |
long |
del(String... keys)
Remove the specified keys.
|
long |
del(String key)
Del Command
Remove the specified key.
|
byte[] |
dump(byte[] key) |
byte[] |
dump(String key)
Dump Command
Serialize the value stored at key in a Redis-specific format and return it to the user.
|
Object |
eval(byte[] script) |
Object |
eval(byte[] script,
byte[] sampleKey) |
Object |
eval(byte[] script,
int keyCount,
byte[]... params) |
Object |
eval(byte[] script,
List<byte[]> keys,
List<byte[]> args) |
Object |
eval(String script)
Eval Command
Use to evaluate scripts using the Lua interpreter built into Redis starting from version 2.6.0.
|
Object |
eval(String script,
int keyCount,
String... params)
Eval Command
Use to evaluate scripts using the Lua interpreter built into Redis starting from version 2.6.0.
|
Object |
eval(String script,
List<String> keys,
List<String> args)
Eval Command
Use to evaluate scripts using the Lua interpreter built into Redis starting from version 2.6.0.
|
Object |
eval(String script,
String sampleKey) |
Object |
evalReadonly(byte[] script,
List<byte[]> keys,
List<byte[]> args) |
Object |
evalReadonly(String script,
List<String> keys,
List<String> args)
Readonly version of
EVAL |
Object |
evalsha(byte[] sha1) |
Object |
evalsha(byte[] sha1,
byte[] sampleKey) |
Object |
evalsha(byte[] sha1,
int keyCount,
byte[]... params) |
Object |
evalsha(byte[] sha1,
List<byte[]> keys,
List<byte[]> args) |
Object |
evalsha(String sha1)
EvalSha Command
Similar to
EVAL, but the script cached on the server
side by its SHA1 digest. |
Object |
evalsha(String sha1,
int keyCount,
String... params)
EvalSha Command
Similar to
ScriptingKeyCommands.eval(String, int, String...) EVAL}, but the script cached on the server
side by its SHA1 digest. |
Object |
evalsha(String sha1,
List<String> keys,
List<String> args)
EvalSha Command
Similar to
ScriptingKeyCommands.eval(String, List, List) EVAL}, but the script cached on the server
side by its SHA1 digest. |
Object |
evalsha(String sha1,
String sampleKey) |
Object |
evalshaReadonly(byte[] sha1,
List<byte[]> keys,
List<byte[]> args) |
Object |
evalshaReadonly(String sha1,
List<String> keys,
List<String> args)
Readonly version of
EVAL |
Object |
executeCommand(CommandArguments args) |
<T> T |
executeCommand(CommandObject<T> commandObject) |
long |
exists(byte[]... keys) |
boolean |
exists(byte[] key) |
long |
exists(String... keys)
Exists Command
Test if the specified keys exist.
|
boolean |
exists(String key)
Exists Command
Test if the specified key exist.
|
long |
expire(byte[] key,
long seconds) |
long |
expire(byte[] key,
long seconds,
ExpiryOption expiryOption) |
long |
expire(String key,
long seconds)
Expire Command
Set a timeout on the specified key.
|
long |
expire(String key,
long seconds,
ExpiryOption expiryOption)
Similar to
EXPIRE but with optional expiry setting. |
long |
expireAt(byte[] key,
long unixTime) |
long |
expireAt(byte[] key,
long unixTime,
ExpiryOption expiryOption) |
long |
expireAt(String key,
long unixTime)
ExpireAt Command
EXPIREAT works exactly like
EXPIRE but instead to get the
number of seconds representing the Time To Live of the key as a second argument (that is a
relative way of specifying the TTL), it takes an absolute one in the form of a UNIX timestamp
(Number of seconds elapsed since 1 Gen 1970). |
long |
expireAt(String key,
long unixTime,
ExpiryOption expiryOption)
|
long |
expireTime(byte[] key) |
long |
expireTime(String key)
ExpireTime Command
Returns the absolute Unix timestamp (since January 1, 1970) in seconds at which the given key will expire.
|
Object |
fcall(byte[] name,
List<byte[]> keys,
List<byte[]> args)
Invoke a function.
|
Object |
fcall(String name,
List<String> keys,
List<String> args)
Invoke a function.
|
Object |
fcallReadonly(byte[] name,
List<byte[]> keys,
List<byte[]> args) |
Object |
fcallReadonly(String name,
List<String> keys,
List<String> args)
This is a read-only variant of the
FCALL
command that cannot execute commands that modify data. |
AggregationResult |
ftAggregate(String indexName,
AggregationBuilder aggr) |
String |
ftAliasAdd(String aliasName,
String indexName) |
String |
ftAliasDel(String aliasName) |
String |
ftAliasUpdate(String aliasName,
String indexName) |
String |
ftAlter(String indexName,
Schema schema) |
Map<String,String> |
ftConfigGet(String option) |
Map<String,String> |
ftConfigGet(String indexName,
String option) |
String |
ftConfigSet(String option,
String value) |
String |
ftConfigSet(String indexName,
String option,
String value) |
String |
ftCreate(String indexName,
IndexOptions indexOptions,
Schema schema) |
String |
ftCursorDel(String indexName,
long cursorId) |
AggregationResult |
ftCursorRead(String indexName,
long cursorId,
int count) |
String |
ftDropIndex(String indexName) |
String |
ftDropIndexDD(String indexName) |
String |
ftExplain(String indexName,
Query query) |
List<String> |
ftExplainCLI(String indexName,
Query query) |
Map<String,Object> |
ftInfo(String indexName) |
SearchResult |
ftSearch(byte[] indexName,
Query query) |
SearchResult |
ftSearch(String indexName,
Query query) |
Map<String,List<String>> |
ftSynDump(String indexName) |
String |
ftSynUpdate(String indexName,
String synonymGroupId,
String... terms) |
String |
functionDelete(byte[] libraryName)
This command deletes the library called library-name and all functions in it.
|
String |
functionDelete(String libraryName)
This command deletes the library called library-name and all functions in it.
|
byte[] |
functionDump()
Return the serialized payload of loaded libraries.
|
String |
functionFlush()
Deletes all the libraries, unless called with the optional mode argument, the
'lazyfree-lazy-user-flush' configuration directive sets the effective behavior.
|
String |
functionFlush(FlushMode mode)
Deletes all the libraries, unless called with the optional mode argument, the
'lazyfree-lazy-user-flush' configuration directive sets the effective behavior.
|
String |
functionKill()
Kill a function that is currently executing.
|
List<LibraryInfo> |
functionList()
Return information about the functions and libraries.
|
List<Object> |
functionList(byte[] libraryNamePattern)
Return information about the functions and libraries.
|
List<LibraryInfo> |
functionList(String libraryNamePattern)
Return information about the functions and libraries.
|
List<Object> |
functionListBinary()
Return information about the functions and libraries.
|
List<LibraryInfo> |
functionListWithCode()
Similar to
FUNCTION LIST but include the
libraries source implementation in the reply. |
List<Object> |
functionListWithCode(byte[] libraryNamePattern)
Similar to
FUNCTION LIST but include the
libraries source implementation in the reply. |
List<LibraryInfo> |
functionListWithCode(String libraryNamePattern)
Similar to
FUNCTION LIST but include the
libraries source implementation in the reply. |
List<Object> |
functionListWithCodeBinary()
Similar to
FUNCTION LIST but include the
libraries source implementation in the reply. |
String |
functionLoad(byte[] functionCode)
Load a library to Redis.
|
String |
functionLoad(String functionCode)
Load a library to Redis.
|
String |
functionLoadReplace(byte[] functionCode)
Load a library to Redis.
|
String |
functionLoadReplace(String functionCode)
Load a library to Redis.
|
String |
functionRestore(byte[] serializedValue)
Restore libraries from the serialized payload.
|
String |
functionRestore(byte[] serializedValue,
FunctionRestorePolicy policy)
Restore libraries from the serialized payload.
|
FunctionStats |
functionStats()
Return information about the function that's currently running and information
about the available execution engines.
|
Object |
functionStatsBinary()
Return information about the function that's currently running and information
about the available execution engines.
|
long |
geoadd(byte[] key,
double longitude,
double latitude,
byte[] member) |
long |
geoadd(byte[] key,
GeoAddParams params,
Map<byte[],GeoCoordinate> memberCoordinateMap) |
long |
geoadd(byte[] key,
Map<byte[],GeoCoordinate> memberCoordinateMap) |
long |
geoadd(String key,
double longitude,
double latitude,
String member)
Adds the specified geospatial item (longitude, latitude, member) to the specified key.
|
long |
geoadd(String key,
GeoAddParams params,
Map<String,GeoCoordinate> memberCoordinateMap)
Adds the specified geospatial items (in memberCoordinateMap) to the specified key.
|
long |
geoadd(String key,
Map<String,GeoCoordinate> memberCoordinateMap)
Adds the specified geospatial items (in memberCoordinateMap) to the specified key.
|
Double |
geodist(byte[] key,
byte[] member1,
byte[] member2) |
Double |
geodist(byte[] key,
byte[] member1,
byte[] member2,
GeoUnit unit) |
Double |
geodist(String key,
String member1,
String member2)
Return the distance between two members in the geospatial index represented by the sorted set.
|
Double |
geodist(String key,
String member1,
String member2,
GeoUnit unit)
Return the distance between two members in the geospatial index represented by the sorted set.
|
List<byte[]> |
geohash(byte[] key,
byte[]... members) |
List<String> |
geohash(String key,
String... members)
Return valid Geohash strings representing the position of the given members.
|
List<GeoCoordinate> |
geopos(byte[] key,
byte[]... members) |
List<GeoCoordinate> |
geopos(String key,
String... members)
Return the positions (longitude,latitude) of all the specified members.
|
List<GeoRadiusResponse> |
georadius(byte[] key,
double longitude,
double latitude,
double radius,
GeoUnit unit) |
List<GeoRadiusResponse> |
georadius(byte[] key,
double longitude,
double latitude,
double radius,
GeoUnit unit,
GeoRadiusParam param) |
List<GeoRadiusResponse> |
georadius(String key,
double longitude,
double latitude,
double radius,
GeoUnit unit)
Return the members of a sorted set populated with geospatial information using GEOADD,
which are within the borders of the area specified with the center location and the radius.
|
List<GeoRadiusResponse> |
georadius(String key,
double longitude,
double latitude,
double radius,
GeoUnit unit,
GeoRadiusParam param)
Return the members of a sorted set populated with geospatial information using GEOADD,
which are within the borders of the area specified with the center location and the radius.
|
List<GeoRadiusResponse> |
georadiusByMember(byte[] key,
byte[] member,
double radius,
GeoUnit unit) |
List<GeoRadiusResponse> |
georadiusByMember(byte[] key,
byte[] member,
double radius,
GeoUnit unit,
GeoRadiusParam param) |
List<GeoRadiusResponse> |
georadiusByMember(String key,
String member,
double radius,
GeoUnit unit)
This command is exactly like
GEORADIUS
with the sole difference that instead of taking, as the center of the area to query, a longitude
and latitude value, it takes the name of a member already existing inside the geospatial index
represented by the sorted set. |
List<GeoRadiusResponse> |
georadiusByMember(String key,
String member,
double radius,
GeoUnit unit,
GeoRadiusParam param)
This command is exactly like
GEORADIUS
with the sole difference that instead of taking, as the center of the area to query, a longitude
and latitude value, it takes the name of a member already existing inside the geospatial index
represented by the sorted set. |
List<GeoRadiusResponse> |
georadiusByMemberReadonly(byte[] key,
byte[] member,
double radius,
GeoUnit unit) |
List<GeoRadiusResponse> |
georadiusByMemberReadonly(byte[] key,
byte[] member,
double radius,
GeoUnit unit,
GeoRadiusParam param) |
List<GeoRadiusResponse> |
georadiusByMemberReadonly(String key,
String member,
double radius,
GeoUnit unit)
Readonly version of
GEORADIUSBYMEMBER |
List<GeoRadiusResponse> |
georadiusByMemberReadonly(String key,
String member,
double radius,
GeoUnit unit,
GeoRadiusParam param)
Readonly version of
GEORADIUSBYMEMBER |
long |
georadiusByMemberStore(byte[] key,
byte[] member,
double radius,
GeoUnit unit,
GeoRadiusParam param,
GeoRadiusStoreParam storeParam) |
long |
georadiusByMemberStore(String key,
String member,
double radius,
GeoUnit unit,
GeoRadiusParam param,
GeoRadiusStoreParam storeParam)
This command is exactly like
GEORADIUSBYMEMBER
but storing the results at the destination key (provided with storeParam). |
List<GeoRadiusResponse> |
georadiusReadonly(byte[] key,
double longitude,
double latitude,
double radius,
GeoUnit unit) |
List<GeoRadiusResponse> |
georadiusReadonly(byte[] key,
double longitude,
double latitude,
double radius,
GeoUnit unit,
GeoRadiusParam param) |
List<GeoRadiusResponse> |
georadiusReadonly(String key,
double longitude,
double latitude,
double radius,
GeoUnit unit)
Readonly version of
GEORADIUS, |
List<GeoRadiusResponse> |
georadiusReadonly(String key,
double longitude,
double latitude,
double radius,
GeoUnit unit,
GeoRadiusParam param)
Readonly version of
GEORADIUS, |
long |
georadiusStore(byte[] key,
double longitude,
double latitude,
double radius,
GeoUnit unit,
GeoRadiusParam param,
GeoRadiusStoreParam storeParam) |
long |
georadiusStore(String key,
double longitude,
double latitude,
double radius,
GeoUnit unit,
GeoRadiusParam param,
GeoRadiusStoreParam storeParam)
This command is exactly like
GEORADIUS
but storing the results at the destination key (provided with storeParam). |
List<GeoRadiusResponse> |
geosearch(byte[] key,
byte[] member,
double width,
double height,
GeoUnit unit) |
List<GeoRadiusResponse> |
geosearch(byte[] key,
byte[] member,
double radius,
GeoUnit unit) |
List<GeoRadiusResponse> |
geosearch(byte[] key,
GeoCoordinate coord,
double width,
double height,
GeoUnit unit) |
List<GeoRadiusResponse> |
geosearch(byte[] key,
GeoCoordinate coord,
double radius,
GeoUnit unit) |
List<GeoRadiusResponse> |
geosearch(byte[] key,
GeoSearchParam params) |
List<GeoRadiusResponse> |
geosearch(String key,
GeoCoordinate coord,
double width,
double height,
GeoUnit unit)
Return the members of a sorted set populated with geospatial information using GEOADD,
which are within the borders of the area specified by a given shape.
|
List<GeoRadiusResponse> |
geosearch(String key,
GeoCoordinate coord,
double radius,
GeoUnit unit)
Return the members of a sorted set populated with geospatial information using GEOADD,
which are within the borders of the area specified by a given shape.
|
List<GeoRadiusResponse> |
geosearch(String key,
GeoSearchParam params)
Return the members of a sorted set populated with geospatial information using GEOADD,
which are within the borders of the area specified by a given shape.
|
List<GeoRadiusResponse> |
geosearch(String key,
String member,
double width,
double height,
GeoUnit unit)
Return the members of a sorted set populated with geospatial information using GEOADD,
which are within the borders of the area specified by a given shape.
|
List<GeoRadiusResponse> |
geosearch(String key,
String member,
double radius,
GeoUnit unit)
Return the members of a sorted set populated with geospatial information using GEOADD,
which are within the borders of the area specified by a given shape.
|
long |
geosearchStore(byte[] dest,
byte[] src,
byte[] member,
double width,
double height,
GeoUnit unit) |
long |
geosearchStore(byte[] dest,
byte[] src,
byte[] member,
double radius,
GeoUnit unit) |
long |
geosearchStore(byte[] dest,
byte[] src,
GeoCoordinate coord,
double width,
double height,
GeoUnit unit) |
long |
geosearchStore(byte[] dest,
byte[] src,
GeoCoordinate coord,
double radius,
GeoUnit unit) |
long |
geosearchStore(byte[] dest,
byte[] src,
GeoSearchParam params) |
long |
geosearchStore(String dest,
String src,
GeoCoordinate coord,
double width,
double height,
GeoUnit unit)
This command is exactly like
GEOSEARCH
but storing the results at dest. |
long |
geosearchStore(String dest,
String src,
GeoCoordinate coord,
double radius,
GeoUnit unit)
This command is exactly like
GEOSEARCH
but storing the results at dest. |
long |
geosearchStore(String dest,
String src,
GeoSearchParam params)
This command is exactly like
GEOSEARCH
but storing the results at dest. |
long |
geosearchStore(String dest,
String src,
String member,
double width,
double height,
GeoUnit unit)
This command is exactly like
GEOSEARCH
but storing the results at dest. |
long |
geosearchStore(String dest,
String src,
String member,
double radius,
GeoUnit unit)
This command is exactly like
GEOSEARCH
but storing the results at dest. |
long |
geosearchStoreStoreDist(byte[] dest,
byte[] src,
GeoSearchParam params) |
long |
geosearchStoreStoreDist(String dest,
String src,
GeoSearchParam params)
This command is exactly like
GEOSEARCHSTORE
but storing the results with their destinations from the center point. |
byte[] |
get(byte[] key) |
String |
get(String key)
Get Command
Get the value of the specified key.
|
boolean |
getbit(byte[] key,
long offset) |
boolean |
getbit(String key,
long offset)
GetBit Command
Returns the bit value at offset in the string value stored at key.
|
byte[] |
getDel(byte[] key) |
String |
getDel(String key)
GetDel Command
Get the value of key and delete the key.
|
byte[] |
getEx(byte[] key,
GetExParams params) |
String |
getEx(String key,
GetExParams params)
GetEx Command
Get the value of key and optionally set its expiration.
|
byte[] |
getrange(byte[] key,
long startOffset,
long endOffset) |
String |
getrange(String key,
long startOffset,
long endOffset)
GetRange Command
Return the substring of the string value stored at key, determined by the offsets start
and end (both are inclusive).
|
byte[] |
getSet(byte[] key,
byte[] value) |
String |
getSet(String key,
String value)
GetSet Command
GETSET is an atomic set this value and return the old value command.
|
String |
graphDelete(String name)
Deletes the entire graph
|
ResultSet |
graphQuery(String name,
String query)
Execute a Cypher query.
|
ResultSet |
graphQuery(String name,
String query,
long timeout)
Execute a Cypher query with timeout.
|
ResultSet |
graphQuery(String name,
String query,
Map<String,Object> params)
Executes a cypher query with parameters.
|
ResultSet |
graphQuery(String name,
String query,
Map<String,Object> params,
long timeout)
Executes a cypher query with parameters and timeout.
|
ResultSet |
graphReadonlyQuery(String name,
String query)
Execute a Cypher read-only query.
|
ResultSet |
graphReadonlyQuery(String name,
String query,
long timeout)
Execute a Cypher read-only query with timeout.
|
ResultSet |
graphReadonlyQuery(String name,
String query,
Map<String,Object> params)
Executes a cypher read-only query with parameters.
|
ResultSet |
graphReadonlyQuery(String name,
String query,
Map<String,Object> params,
long timeout)
Executes a cypher read-only query with parameters and timeout.
|
long |
hdel(byte[] key,
byte[]... field) |
long |
hdel(String key,
String... field) |
boolean |
hexists(byte[] key,
byte[] field) |
boolean |
hexists(String key,
String field) |
byte[] |
hget(byte[] key,
byte[] field) |
String |
hget(String key,
String field) |
Map<byte[],byte[]> |
hgetAll(byte[] key) |
Map<String,String> |
hgetAll(String key) |
long |
hincrBy(byte[] key,
byte[] field,
long value) |
long |
hincrBy(String key,
String field,
long value) |
double |
hincrByFloat(byte[] key,
byte[] field,
double value) |
double |
hincrByFloat(String key,
String field,
double value) |
Set<byte[]> |
hkeys(byte[] key) |
Set<String> |
hkeys(String key) |
long |
hlen(byte[] key) |
long |
hlen(String key) |
List<byte[]> |
hmget(byte[] key,
byte[]... fields) |
List<String> |
hmget(String key,
String... fields) |
String |
hmset(byte[] key,
Map<byte[],byte[]> hash) |
String |
hmset(String key,
Map<String,String> hash) |
byte[] |
hrandfield(byte[] key) |
List<byte[]> |
hrandfield(byte[] key,
long count) |
String |
hrandfield(String key) |
List<String> |
hrandfield(String key,
long count) |
Map<byte[],byte[]> |
hrandfieldWithValues(byte[] key,
long count) |
Map<String,String> |
hrandfieldWithValues(String key,
long count) |
ScanResult<Map.Entry<byte[],byte[]>> |
hscan(byte[] key,
byte[] cursor,
ScanParams params) |
ScanResult<Map.Entry<String,String>> |
hscan(String key,
String cursor,
ScanParams params) |
long |
hset(byte[] key,
byte[] field,
byte[] value) |
long |
hset(byte[] key,
Map<byte[],byte[]> hash) |
long |
hset(String key,
Map<String,String> hash) |
long |
hset(String key,
String field,
String value) |
long |
hsetnx(byte[] key,
byte[] field,
byte[] value) |
long |
hsetnx(String key,
String field,
String value) |
long |
hstrlen(byte[] key,
byte[] field) |
long |
hstrlen(String key,
String field) |
List<byte[]> |
hvals(byte[] key) |
List<String> |
hvals(String key) |
long |
incr(byte[] key) |
long |
incr(String key)
Incr Command
Increment the number stored at key by one.
|
long |
incrBy(byte[] key,
long increment) |
long |
incrBy(String key,
long increment)
IncrBy Command
INCRBY work just like
INCR but instead to increment by 1 the
increment is integer. |
double |
incrByFloat(byte[] key,
double increment) |
double |
incrByFloat(String key,
double increment)
IncrByFloat Command
INCRBYFLOAT work just like
StringCommands.incrBy(String, long) INCRBY} but increments by floats
instead of integers. |
List<Long> |
jsonArrAppend(String key,
Path2 path,
Object... objects) |
Long |
jsonArrAppend(String key,
Path path,
Object... pojos) |
List<Long> |
jsonArrAppendWithEscape(String key,
Path2 path,
Object... objects) |
List<Long> |
jsonArrIndex(String key,
Path2 path,
Object scalar) |
long |
jsonArrIndex(String key,
Path path,
Object scalar) |
List<Long> |
jsonArrIndexWithEscape(String key,
Path2 path,
Object scalar) |
List<Long> |
jsonArrInsert(String key,
Path2 path,
int index,
Object... objects) |
long |
jsonArrInsert(String key,
Path path,
int index,
Object... pojos) |
List<Long> |
jsonArrInsertWithEscape(String key,
Path2 path,
int index,
Object... objects) |
Long |
jsonArrLen(String key) |
Long |
jsonArrLen(String key,
Path path) |
List<Long> |
jsonArrLen(String key,
Path2 path) |
Object |
jsonArrPop(String key) |
<T> T |
jsonArrPop(String key,
Class<T> clazz) |
<T> T |
jsonArrPop(String key,
Class<T> clazz,
Path path) |
<T> T |
jsonArrPop(String key,
Class<T> clazz,
Path path,
int index) |
Object |
jsonArrPop(String key,
Path path) |
List<Object> |
jsonArrPop(String key,
Path2 path) |
List<Object> |
jsonArrPop(String key,
Path2 path,
int index) |
Object |
jsonArrPop(String key,
Path path,
int index) |
List<Long> |
jsonArrTrim(String key,
Path2 path,
int start,
int stop) |
Long |
jsonArrTrim(String key,
Path path,
int start,
int stop) |
long |
jsonClear(String key) |
long |
jsonClear(String key,
Path path) |
long |
jsonClear(String key,
Path2 path) |
long |
jsonDel(String key) |
long |
jsonDel(String key,
Path path) |
long |
jsonDel(String key,
Path2 path) |
Object |
jsonGet(String key) |
<T> T |
jsonGet(String key,
Class<T> clazz) |
<T> T |
jsonGet(String key,
Class<T> clazz,
Path... paths) |
Object |
jsonGet(String key,
Path... paths) |
Object |
jsonGet(String key,
Path2... paths) |
List<org.json.JSONArray> |
jsonMGet(Path2 path,
String... keys) |
<T> List<T> |
jsonMGet(Path path,
Class<T> clazz,
String... keys) |
String |
jsonSet(String key,
Path2 path,
Object object) |
String |
jsonSet(String key,
Path2 path,
Object pojo,
JsonSetParams params) |
String |
jsonSet(String key,
Path path,
Object pojo) |
String |
jsonSet(String key,
Path path,
Object pojo,
JsonSetParams params) |
String |
jsonSetWithEscape(String key,
Path2 path,
Object object) |
String |
jsonSetWithEscape(String key,
Path2 path,
Object pojo,
JsonSetParams params) |
long |
jsonStrAppend(String key,
Object string) |
List<Long> |
jsonStrAppend(String key,
Path2 path,
Object string) |
long |
jsonStrAppend(String key,
Path path,
Object string) |
Long |
jsonStrLen(String key) |
Long |
jsonStrLen(String key,
Path path) |
List<Long> |
jsonStrLen(String key,
Path2 path) |
String |
jsonToggle(String key,
Path path) |
List<Boolean> |
jsonToggle(String key,
Path2 path) |
Class<?> |
jsonType(String key) |
Class<?> |
jsonType(String key,
Path path) |
List<Class<?>> |
jsonType(String key,
Path2 path) |
Set<byte[]> |
keys(byte[] pattern) |
Set<String> |
keys(String pattern)
Keys Command
Returns all the keys matching the glob-style pattern as space separated strings.
|
LCSMatchResult |
lcs(byte[] keyA,
byte[] keyB,
LCSParams params)
Calculate the longest common subsequence of keyA and keyB.
|
LCSMatchResult |
lcs(String keyA,
String keyB,
LCSParams params)
Calculate the longest common subsequence of keyA and keyB.
|
byte[] |
lindex(byte[] key,
long index) |
String |
lindex(String key,
long index)
Returns the element at index in the list stored at key.
|
long |
linsert(byte[] key,
ListPosition where,
byte[] pivot,
byte[] value) |
long |
linsert(String key,
ListPosition where,
String pivot,
String value)
Inserts element in the list stored at key either before or after the reference value pivot.
|
long |
llen(byte[] key) |
long |
llen(String key)
Return the length of the list stored at the specified key.
|
byte[] |
lmove(byte[] srcKey,
byte[] dstKey,
ListDirection from,
ListDirection to) |
String |
lmove(String srcKey,
String dstKey,
ListDirection from,
ListDirection to)
Pop an element from a list, push it to another list and return it
|
KeyValue<byte[],List<byte[]>> |
lmpop(ListDirection direction,
byte[]... keys) |
KeyValue<byte[],List<byte[]>> |
lmpop(ListDirection direction,
int count,
byte[]... keys) |
KeyValue<String,List<String>> |
lmpop(ListDirection direction,
int count,
String... keys) |
KeyValue<String,List<String>> |
lmpop(ListDirection direction,
String... keys) |
byte[] |
lpop(byte[] key) |
List<byte[]> |
lpop(byte[] key,
int count) |
String |
lpop(String key)
Atomically return and remove the first (LPOP) or last (RPOP) element of the list.
|
List<String> |
lpop(String key,
int count)
Atomically return and remove the first (LPOP) or last (RPOP) element of the list.
|
Long |
lpos(byte[] key,
byte[] element) |
Long |
lpos(byte[] key,
byte[] element,
LPosParams params) |
List<Long> |
lpos(byte[] key,
byte[] element,
LPosParams params,
long count) |
Long |
lpos(String key,
String element)
Returns the index of the first matching element inside a redis list.
|
Long |
lpos(String key,
String element,
LPosParams params)
In case there are multiple matches Rank option specifies the "rank" of the element to return.
|
List<Long> |
lpos(String key,
String element,
LPosParams params,
long count)
Returns the index of matching elements inside a Redis list.
|
long |
lpush(byte[] key,
byte[]... args) |
long |
lpush(String key,
String... string)
Add the string value to the head (LPUSH) or tail (RPUSH) of the list stored at key.
|
long |
lpushx(byte[] key,
byte[]... args) |
long |
lpushx(String key,
String... strings)
Inserts specified values at the head of the list stored at key.
|
List<byte[]> |
lrange(byte[] key,
long start,
long stop) |
List<String> |
lrange(String key,
long start,
long stop)
Return the specified elements of the list stored at the specified key.
|
long |
lrem(byte[] key,
long count,
byte[] value) |
long |
lrem(String key,
long count,
String value)
Remove the first count occurrences of the value element from the list.
|
String |
lset(byte[] key,
long index,
byte[] value) |
String |
lset(String key,
long index,
String value)
Set a new value as the element at index position of the List at key.
|
String |
ltrim(byte[] key,
long start,
long stop) |
String |
ltrim(String key,
long start,
long stop)
Trim an existing list so that it will contain only the specified range of elements specified.
|
Long |
memoryUsage(byte[] key) |
Long |
memoryUsage(byte[] key,
int samples) |
Long |
memoryUsage(String key)
Memory Usage Command
Report the number of bytes that a key and its value require to be stored in RAM.
|
Long |
memoryUsage(String key,
int samples)
Memory Usage Command
Report the number of bytes that a key and its value require to be stored in RAM.
|
List<byte[]> |
mget(byte[]... keys) |
List<String> |
mget(String... keys)
MGet Command
Get the values of all the specified keys.
|
String |
migrate(String host,
int port,
byte[] key,
int timeout) |
String |
migrate(String host,
int port,
int timeout,
MigrateParams params,
byte[]... keys) |
String |
migrate(String host,
int port,
int timeout,
MigrateParams params,
String... keys)
Migrate Command
Atomically transfer a key from a source Redis instance to a destination Redis instance.
|
String |
migrate(String host,
int port,
String key,
int timeout)
Migrate Command
Atomically transfer a key from a source Redis instance to a destination Redis instance.
|
String |
mset(byte[]... keysvalues) |
String |
mset(String... keysvalues)
MSet Command
Set the the respective keys to the respective values.
|
long |
msetnx(byte[]... keysvalues) |
long |
msetnx(String... keysvalues)
MSetNX Command
Set the respective keys to the respective values.
|
byte[] |
objectEncoding(byte[] key) |
String |
objectEncoding(String key)
Object Encoding Command
Return the internal encoding for the Redis object stored at key.
|
Long |
objectFreq(byte[] key) |
Long |
objectFreq(String key)
Object Freq Command
Return the logarithmic access frequency counter of a Redis object stored at key.
|
Long |
objectIdletime(byte[] key) |
Long |
objectIdletime(String key)
Object IdleTime Command
Return the time in seconds since the last access to the value stored at key.
|
Long |
objectRefcount(byte[] key) |
Long |
objectRefcount(String key)
Object Refcount Command
Return the reference count of the stored at key.
|
long |
persist(byte[] key) |
long |
persist(String key)
Persist Command
Undo a
expire at turning the expire key into a normal key. |
long |
pexpire(byte[] key,
long milliseconds) |
long |
pexpire(byte[] key,
long milliseconds,
ExpiryOption expiryOption) |
long |
pexpire(String key,
long milliseconds)
PExpire Command
This command works exactly like
EXPIRE but the time
to live of the key is specified in milliseconds instead of seconds. |
long |
pexpire(String key,
long milliseconds,
ExpiryOption expiryOption)
Similar to
EXPIRE but with optional expiry setting. |
long |
pexpireAt(byte[] key,
long millisecondsTimestamp) |
long |
pexpireAt(byte[] key,
long millisecondsTimestamp,
ExpiryOption expiryOption) |
long |
pexpireAt(String key,
long millisecondsTimestamp)
PExpireAt Command
This command works exactly like
EXPIREAT but
Unix time at which the key will expire is specified in milliseconds instead of seconds. |
long |
pexpireAt(String key,
long millisecondsTimestamp,
ExpiryOption expiryOption)
|
long |
pexpireTime(byte[] key) |
long |
pexpireTime(String key)
PExpireTime Command
Similar to
EXPIRETIME but returns the absolute Unix expiration
timestamp in milliseconds instead of seconds. |
long |
pfadd(byte[] key,
byte[]... elements) |
long |
pfadd(String key,
String... elements) |
long |
pfcount(byte[]... keys) |
long |
pfcount(byte[] key) |
long |
pfcount(String... keys) |
long |
pfcount(String key) |
String |
pfmerge(byte[] destkey,
byte[]... sourcekeys) |
String |
pfmerge(String destkey,
String... sourcekeys) |
String |
psetex(byte[] key,
long milliseconds,
byte[] value) |
String |
psetex(String key,
long milliseconds,
String value)
PSetEx Command
PSETEX works exactly like
SETEX with the sole difference
that the expire time is specified in milliseconds instead of seconds. |
void |
psubscribe(BinaryJedisPubSub jedisPubSub,
byte[]... patterns) |
void |
psubscribe(JedisPubSub jedisPubSub,
String... patterns) |
long |
pttl(byte[] key) |
long |
pttl(String key)
PTTL Command
The PTTL command returns the remaining time to live in milliseconds of a key that has an
EXPIRE set. |
long |
publish(byte[] channel,
byte[] message) |
long |
publish(String channel,
String message) |
byte[] |
randomBinaryKey() |
String |
randomKey()
RandomKey Command
Return a randomly selected key from the currently selected DB.
|
String |
rename(byte[] oldkey,
byte[] newkey) |
String |
rename(String oldkey,
String newkey)
|
long |
renamenx(byte[] oldkey,
byte[] newkey) |
long |
renamenx(String oldkey,
String newkey)
RenameNX Command
Rename oldkey into newkey but fails if the destination key newkey already exists.
|
String |
restore(byte[] key,
long ttl,
byte[] serializedValue) |
String |
restore(byte[] key,
long ttl,
byte[] serializedValue,
RestoreParams params) |
String |
restore(String key,
long ttl,
byte[] serializedValue)
Restore Command
Create a key associated with a value that is obtained by deserializing the provided serialized
value (obtained via
DUMP). |
String |
restore(String key,
long ttl,
byte[] serializedValue,
RestoreParams params)
Restore Command
Create a key associated with a value that is obtained by deserializing the provided serialized
value (obtained via
DUMP). |
byte[] |
rpop(byte[] key) |
List<byte[]> |
rpop(byte[] key,
int count) |
String |
rpop(String key)
Atomically return and remove the first (LPOP) or last (RPOP) element of the list.
|
List<String> |
rpop(String key,
int count)
Atomically return and remove the first (LPOP) or last (RPOP) element of the list.
|
byte[] |
rpoplpush(byte[] srckey,
byte[] dstkey) |
String |
rpoplpush(String srckey,
String dstkey)
Atomically return and remove the last (tail) element of the srckey list, and push the element
as the first (head) element of the dstkey list.
|
long |
rpush(byte[] key,
byte[]... args) |
long |
rpush(String key,
String... string)
Add the string value to the head (LPUSH) or tail (RPUSH) of the list stored at key.
|
long |
rpushx(byte[] key,
byte[]... args) |
long |
rpushx(String key,
String... strings)
Inserts specified values at the tail of the list stored at key.
|
long |
sadd(byte[] key,
byte[]... members) |
long |
sadd(String key,
String... members)
Add the specified member to the set value stored at key.
|
ScanResult<byte[]> |
scan(byte[] cursor) |
ScanResult<byte[]> |
scan(byte[] cursor,
ScanParams params) |
ScanResult<byte[]> |
scan(byte[] cursor,
ScanParams params,
byte[] type) |
ScanResult<String> |
scan(String cursor) |
ScanResult<String> |
scan(String cursor,
ScanParams params) |
ScanResult<String> |
scan(String cursor,
ScanParams params,
String type) |
long |
scard(byte[] key) |
long |
scard(String key)
Return the set cardinality (number of elements).
|
List<Boolean> |
scriptExists(byte[] sampleKey,
byte[]... sha1s) |
Boolean |
scriptExists(byte[] sha1,
byte[] sampleKey) |
List<Boolean> |
scriptExists(String sampleKey,
String... sha1s) |
Boolean |
scriptExists(String sha1,
String sampleKey) |
String |
scriptFlush(byte[] sampleKey) |
String |
scriptFlush(byte[] sampleKey,
FlushMode flushMode) |
String |
scriptFlush(String sampleKey) |
String |
scriptFlush(String sampleKey,
FlushMode flushMode) |
String |
scriptKill(byte[] sampleKey) |
String |
scriptKill(String sampleKey) |
byte[] |
scriptLoad(byte[] script,
byte[] sampleKey) |
String |
scriptLoad(String script,
String sampleKey) |
Set<byte[]> |
sdiff(byte[]... keys) |
Set<String> |
sdiff(String... keys)
Return the difference between the Sets stored at
keys |
long |
sdiffstore(byte[] dstkey,
byte[]... keys) |
long |
sdiffstore(String dstkey,
String... keys)
This command works exactly like
SDIFF but instead of being
returned the resulting set is stored in dstkey. |
Object |
sendBlockingCommand(byte[] sampleKey,
ProtocolCommand cmd,
byte[]... args) |
Object |
sendBlockingCommand(ProtocolCommand cmd,
byte[]... args) |
Object |
sendBlockingCommand(ProtocolCommand cmd,
String... args) |
Object |
sendBlockingCommand(String sampleKey,
ProtocolCommand cmd,
String... args) |
Object |
sendCommand(byte[] sampleKey,
ProtocolCommand cmd,
byte[]... args) |
Object |
sendCommand(ProtocolCommand cmd) |
Object |
sendCommand(ProtocolCommand cmd,
byte[]... args) |
Object |
sendCommand(ProtocolCommand cmd,
String... args) |
Object |
sendCommand(String sampleKey,
ProtocolCommand cmd,
String... args) |
String |
set(byte[] key,
byte[] value) |
String |
set(byte[] key,
byte[] value,
SetParams params) |
String |
set(String key,
String value)
Set Command
Set the string value as value of the key.
|
String |
set(String key,
String value,
SetParams params)
Set Command
Set the string value as value of the key.
|
boolean |
setbit(byte[] key,
long offset,
boolean value) |
boolean |
setbit(String key,
long offset,
boolean value)
SetBit Command
Sets or clears the bit at offset in the string value stored at key.
|
String |
setex(byte[] key,
long seconds,
byte[] value) |
String |
setex(String key,
long seconds,
String value)
|
long |
setnx(byte[] key,
byte[] value) |
long |
setnx(String key,
String value)
SetNE Command
SETNX works exactly like
SET with the only difference that if
the key already exists no operation is performed. |
long |
setrange(byte[] key,
long offset,
byte[] value) |
long |
setrange(String key,
long offset,
String value)
SetRange Command
GETRANGE overwrite part of the string stored at key, starting at the specified offset, for the entire
length of value.
|
Set<byte[]> |
sinter(byte[]... keys) |
Set<String> |
sinter(String... keys)
Return the members of a set resulting from the intersection of all the sets hold at the
specified keys.
|
long |
sintercard(byte[]... keys)
This command works exactly like
SINTER but instead of returning
the result set, it returns just the cardinality of the result. |
long |
sintercard(int limit,
byte[]... keys)
This command works exactly like
SINTER but instead of returning
the result set, it returns just the cardinality of the result. |
long |
sintercard(int limit,
String... keys)
This command works exactly like
SINTER but instead of returning
the result set, it returns just the cardinality of the result. |
long |
sintercard(String... keys)
This command works exactly like
SINTER but instead of returning
the result set, it returns just the cardinality of the result. |
long |
sinterstore(byte[] dstkey,
byte[]... keys) |
long |
sinterstore(String dstkey,
String... keys)
This command works exactly like
SINTER but instead of being
returned the resulting set is stored as dstkey. |
boolean |
sismember(byte[] key,
byte[] member) |
boolean |
sismember(String key,
String member)
Return true if member is a member of the set stored at key, otherwise false is returned.
|
Set<byte[]> |
smembers(byte[] key) |
Set<String> |
smembers(String key)
Return all the members (elements) of the set value stored at key.
|
List<Boolean> |
smismember(byte[] key,
byte[]... members) |
List<Boolean> |
smismember(String key,
String... members)
Returns whether each member is a member of the set stored at key.
|
long |
smove(byte[] srckey,
byte[] dstkey,
byte[] member) |
long |
smove(String srckey,
String dstkey,
String member)
Move the specified member from the set at srckey to the set at dstkey.
|
List<byte[]> |
sort(byte[] key) |
long |
sort(byte[] key,
byte[] dstkey) |
List<byte[]> |
sort(byte[] key,
SortingParams sortingParams) |
long |
sort(byte[] key,
SortingParams sortingParams,
byte[] dstkey) |
List<String> |
sort(String key)
Sort Command
Sort a Set or a List.
|
List<String> |
sort(String key,
SortingParams sortingParams)
Sort a Set or a List accordingly to the specified parameters.
|
long |
sort(String key,
SortingParams sortingParams,
String dstkey)
Similar to
SORT but store the result in dstkey. |
long |
sort(String key,
String dstkey)
Similar to
SORT but store the result in dstkey. |
List<byte[]> |
sortReadonly(byte[] key,
SortingParams sortingParams) |
List<String> |
sortReadonly(String key,
SortingParams sortingParams)
Read-only variant of the
SORT command. |
byte[] |
spop(byte[] key) |
Set<byte[]> |
spop(byte[] key,
long count) |
String |
spop(String key)
Remove a random element from a Set returning it as return value.
|
Set<String> |
spop(String key,
long count)
By default, the command
SetCommands.spop(String) pops a single member from the set. |
byte[] |
srandmember(byte[] key) |
List<byte[]> |
srandmember(byte[] key,
int count) |
String |
srandmember(String key)
Return a random element from a Set, without removing the element.
|
List<String> |
srandmember(String key,
int count)
Return a random elements from a Set, without removing the elements.
|
long |
srem(byte[] key,
byte[]... members) |
long |
srem(String key,
String... members)
Remove the specified member from the set value stored at key.
|
ScanResult<byte[]> |
sscan(byte[] key,
byte[] cursor,
ScanParams params) |
ScanResult<String> |
sscan(String key,
String cursor,
ScanParams params) |
LCSMatchResult |
strAlgoLCSKeys(byte[] keyA,
byte[] keyB,
StrAlgoLCSParams params) |
LCSMatchResult |
strAlgoLCSKeys(String keyA,
String keyB,
StrAlgoLCSParams params)
Calculate the longest common subsequence of keyA and keyB.
|
LCSMatchResult |
strAlgoLCSStrings(byte[] strA,
byte[] strB,
StrAlgoLCSParams params) |
LCSMatchResult |
strAlgoLCSStrings(String strA,
String strB,
StrAlgoLCSParams params) |
long |
strlen(byte[] key) |
long |
strlen(String key)
StrLen Command
Return the length of the string value stored at key.
|
void |
subscribe(BinaryJedisPubSub jedisPubSub,
byte[]... channels) |
void |
subscribe(JedisPubSub jedisPubSub,
String... channels) |
byte[] |
substr(byte[] key,
int start,
int end) |
String |
substr(String key,
int start,
int end)
SubStr Command
Return a subset of the string from offset start to offset end (both offsets are inclusive).
|
Set<byte[]> |
sunion(byte[]... keys) |
Set<String> |
sunion(String... keys)
Return the members of a set resulting from the union of all the sets hold at the specified
keys.
|
long |
sunionstore(byte[] dstkey,
byte[]... keys) |
long |
sunionstore(String dstkey,
String... keys)
This command works exactly like
SUNION but instead of being
returned the resulting set is stored as dstkey. |
List<String> |
topkAdd(String key,
String... items)
TOPK.ADD {key} {item ...} |
List<Long> |
topkCount(String key,
String... items)
TOPK.COUNT {key} {item ...} |
List<String> |
topkIncrBy(String key,
Map<String,Long> itemIncrements)
TOPK.INCRBY {key} {item} {increment} [{item} {increment} ...] |
Map<String,Object> |
topkInfo(String key)
TOPK.INFO {key} |
List<String> |
topkList(String key)
TOPK.LIST {key} |
List<Boolean> |
topkQuery(String key,
String... items)
TOPK.QUERY {key} {item ...} |
String |
topkReserve(String key,
long topk)
TOPK.RESERVE {key} {topk} |
String |
topkReserve(String key,
long topk,
long width,
long depth,
double decay)
TOPK.RESERVE {key} {topk} [{width} {depth} {decay}] |
long |
touch(byte[]... keys) |
long |
touch(byte[] key) |
long |
touch(String... keys)
Touch Command
Alters the last access time of a key(s).
|
long |
touch(String key)
Touch Command
Alters the last access time of a key.
|
long |
tsAdd(String key,
double value)
TS.ADD key * value |
long |
tsAdd(String key,
long timestamp,
double value)
TS.ADD key timestamp value |
long |
tsAdd(String key,
long timestamp,
double value,
TSCreateParams createParams)
TS.ADD key timestamp value [RETENTION retentionTime] [ENCODING [COMPRESSED|UNCOMPRESSED]] [CHUNK_SIZE size] [ON_DUPLICATE policy] [LABELS label value..] |
String |
tsAlter(String key,
TSAlterParams alterParams)
TS.ALTER key [RETENTION retentionTime] [LABELS label value..] |
String |
tsCreate(String key)
TS.CREATE key |
String |
tsCreate(String key,
TSCreateParams createParams)
TS.CREATE key [RETENTION retentionTime] [ENCODING [UNCOMPRESSED|COMPRESSED]] [CHUNK_SIZE size] [DUPLICATE_POLICY policy] [LABELS label value..] |
String |
tsCreateRule(String sourceKey,
String destKey,
AggregationType aggregationType,
long timeBucket)
TS.CREATERULE sourceKey destKey AGGREGATION aggregationType timeBucket |
long |
tsDel(String key,
long fromTimestamp,
long toTimestamp)
TS.DEL key fromTimestamp toTimestamp |
String |
tsDeleteRule(String sourceKey,
String destKey)
TS.DELETERULE sourceKey destKey |
TSElement |
tsGet(String key)
TS.GET key |
List<TSKeyValue<TSElement>> |
tsMGet(TSMGetParams multiGetParams,
String... filters)
TS.MGET [WITHLABELS | SELECTED_LABELS label1 ..] FILTER filter... |
List<TSKeyedElements> |
tsMRange(long fromTimestamp,
long toTimestamp,
String... filters)
TS.MRANGE fromTimestamp toTimestamp |
List<TSKeyedElements> |
tsMRange(TSMRangeParams multiRangeParams)
{@code TS.MRANGE fromTimestamp toTimestamp
[FILTER_BY_TS TS1 TS2 ..] [FILTER_BY_VALUE min max]
[WITHLABELS | SELECTED_LABELS label1 ..]
[COUNT count] [ALIGN value]
[AGGREGATION aggregationType timeBucket]
FILTER filter..
|
List<TSKeyedElements> |
tsMRevRange(long fromTimestamp,
long toTimestamp,
String... filters)
TS.MREVRANGE fromTimestamp toTimestamp |
List<TSKeyedElements> |
tsMRevRange(TSMRangeParams multiRangeParams)
{@code TS.MREVRANGE fromTimestamp toTimestamp
[FILTER_BY_TS TS1 TS2 ..]
[FILTER_BY_VALUE min max]
[WITHLABELS | SELECTED_LABELS label1 ..]
[COUNT count] [ALIGN value]
[AGGREGATION aggregationType timeBucket]
FILTER filter..
|
List<String> |
tsQueryIndex(String... filters)
TS.QUERYINDEX filter... |
List<TSElement> |
tsRange(String key,
long fromTimestamp,
long toTimestamp)
TS.RANGE key fromTimestamp toTimestamp |
List<TSElement> |
tsRange(String key,
TSRangeParams rangeParams)
TS.RANGE key fromTimestamp toTimestamp
[FILTER_BY_TS TS1 TS2 ..] [FILTER_BY_VALUE min max]
[COUNT count] [ALIGN value] [AGGREGATION aggregationType timeBucket] |
List<TSElement> |
tsRevRange(String key,
long fromTimestamp,
long toTimestamp)
TS.REVRANGE key fromTimestamp toTimestamp |
List<TSElement> |
tsRevRange(String key,
TSRangeParams rangeParams)
TS.REVRANGE key fromTimestamp toTimestamp
[FILTER_BY_TS TS1 TS2 ..] [FILTER_BY_VALUE min max]
[COUNT count] [ALIGN value] [AGGREGATION aggregationType timeBucket] |
long |
ttl(byte[] key) |
long |
ttl(String key)
TTL Command
The TTL command returns the remaining time to live in seconds of a key that has an
EXPIRE set. |
String |
type(byte[] key) |
String |
type(String key)
Type Command
Return the type of the value stored at key in form of a string.
|
long |
unlink(byte[]... keys) |
long |
unlink(byte[] key) |
long |
unlink(String... keys)
Similar to
SORT but can be used with multiple keys. |
long |
unlink(String key)
Unlink Command
This command is very similar to
DEL: it removes the specified key. |
long |
waitReplicas(byte[] sampleKey,
int replicas,
long timeout) |
long |
waitReplicas(String sampleKey,
int replicas,
long timeout) |
long |
xack(byte[] key,
byte[] group,
byte[]... ids) |
long |
xack(String key,
String group,
StreamEntryID... ids)
XACK key group ID [ID ...]
|
byte[] |
xadd(byte[] key,
XAddParams params,
Map<byte[],byte[]> hash) |
StreamEntryID |
xadd(String key,
StreamEntryID id,
Map<String,String> hash)
XADD key ID field string [field string ...]
|
StreamEntryID |
xadd(String key,
XAddParams params,
Map<String,String> hash) |
List<Object> |
xautoclaim(byte[] key,
byte[] groupName,
byte[] consumerName,
long minIdleTime,
byte[] start,
XAutoClaimParams params) |
Map.Entry<StreamEntryID,List<StreamEntry>> |
xautoclaim(String key,
String group,
String consumerName,
long minIdleTime,
StreamEntryID start,
XAutoClaimParams params)
XAUTOCLAIM key group consumer min-idle-time start [COUNT count]
|
List<Object> |
xautoclaimJustId(byte[] key,
byte[] groupName,
byte[] consumerName,
long minIdleTime,
byte[] start,
XAutoClaimParams params) |
Map.Entry<StreamEntryID,List<StreamEntryID>> |
xautoclaimJustId(String key,
String group,
String consumerName,
long minIdleTime,
StreamEntryID start,
XAutoClaimParams params)
XAUTOCLAIM key group consumer min-idle-time start [COUNT count] JUSTID
|
List<byte[]> |
xclaim(byte[] key,
byte[] group,
byte[] consumerName,
long minIdleTime,
XClaimParams params,
byte[]... ids) |
List<StreamEntry> |
xclaim(String key,
String group,
String consumerName,
long minIdleTime,
XClaimParams params,
StreamEntryID... ids)
XCLAIM
|
List<byte[]> |
xclaimJustId(byte[] key,
byte[] group,
byte[] consumerName,
long minIdleTime,
XClaimParams params,
byte[]... ids) |
List<StreamEntryID> |
xclaimJustId(String key,
String group,
String consumerName,
long minIdleTime,
XClaimParams params,
StreamEntryID... ids)
XCLAIM
|
long |
xdel(byte[] key,
byte[]... ids) |
long |
xdel(String key,
StreamEntryID... ids)
XDEL key ID [ID ...]
|
String |
xgroupCreate(byte[] key,
byte[] groupName,
byte[] id,
boolean makeStream) |
String |
xgroupCreate(String key,
String groupName,
StreamEntryID id,
boolean makeStream)
XGROUP CREATE
|
boolean |
xgroupCreateConsumer(byte[] key,
byte[] groupName,
byte[] consumerName) |
boolean |
xgroupCreateConsumer(String key,
String groupName,
String consumerName)
XGROUP CREATECONSUMER
|
long |
xgroupDelConsumer(byte[] key,
byte[] groupName,
byte[] consumerName) |
long |
xgroupDelConsumer(String key,
String groupName,
String consumerName)
XGROUP DELCONSUMER
|
long |
xgroupDestroy(byte[] key,
byte[] groupName) |
long |
xgroupDestroy(String key,
String groupName)
XGROUP DESTROY
|
String |
xgroupSetID(byte[] key,
byte[] groupName,
byte[] id) |
String |
xgroupSetID(String key,
String groupName,
StreamEntryID id)
XGROUP SETID
|
List<Object> |
xinfoConsumers(byte[] key,
byte[] group) |
List<StreamConsumersInfo> |
xinfoConsumers(String key,
String group)
Introspection command used in order to retrieve different information about consumers in the group
|
List<Object> |
xinfoGroup(byte[] key)
Deprecated.
|
List<StreamGroupInfo> |
xinfoGroup(String key)
Deprecated.
|
List<Object> |
xinfoGroups(byte[] key) |
List<StreamGroupInfo> |
xinfoGroups(String key)
Introspection command used in order to retrieve different information about groups in the stream
|
Object |
xinfoStream(byte[] key) |
StreamInfo |
xinfoStream(String key)
Introspection command used in order to retrieve different information about the stream
|
Object |
xinfoStreamFull(byte[] key)
Introspection command used in order to retrieve all information about the stream
|
Object |
xinfoStreamFull(byte[] key,
int count)
Introspection command used in order to retrieve all information about the stream
|
StreamFullInfo |
xinfoStreamFull(String key)
Introspection command used in order to retrieve all information about the stream
|
StreamFullInfo |
xinfoStreamFull(String key,
int count)
Introspection command used in order to retrieve all information about the stream
|
long |
xlen(byte[] key) |
long |
xlen(String key)
XLEN key
|
Object |
xpending(byte[] key,
byte[] groupName) |
List<Object> |
xpending(byte[] key,
byte[] groupName,
byte[] start,
byte[] end,
int count,
byte[] consumerName) |
List<Object> |
xpending(byte[] key,
byte[] groupName,
XPendingParams params) |
StreamPendingSummary |
xpending(String key,
String groupName)
XPENDING key group
|
List<StreamPendingEntry> |
xpending(String key,
String groupName,
StreamEntryID start,
StreamEntryID end,
int count,
String consumerName)
XPENDING key group [start end count] [consumer]
|
List<StreamPendingEntry> |
xpending(String key,
String groupName,
XPendingParams params)
XPENDING key group [[IDLE min-idle-time] start end count [consumer]]
|
List<byte[]> |
xrange(byte[] key,
byte[] start,
byte[] end) |
List<byte[]> |
xrange(byte[] key,
byte[] start,
byte[] end,
int count) |
List<StreamEntry> |
xrange(String key,
StreamEntryID start,
StreamEntryID end)
XRANGE key start end
|
List<StreamEntry> |
xrange(String key,
StreamEntryID start,
StreamEntryID end,
int count)
XRANGE key start end COUNT count
|
List<StreamEntry> |
xrange(String key,
String start,
String end) |
List<StreamEntry> |
xrange(String key,
String start,
String end,
int count) |
List<byte[]> |
xread(XReadParams xReadParams,
Map.Entry<byte[],byte[]>... streams) |
List<Map.Entry<String,List<StreamEntry>>> |
xread(XReadParams xReadParams,
Map<String,StreamEntryID> streams)
XREAD [COUNT count] [BLOCK milliseconds] STREAMS key [key ...] ID [ID ...]
|
List<byte[]> |
xreadGroup(byte[] groupName,
byte[] consumer,
XReadGroupParams xReadGroupParams,
Map.Entry<byte[],byte[]>... streams) |
List<Map.Entry<String,List<StreamEntry>>> |
xreadGroup(String groupName,
String consumer,
XReadGroupParams xReadGroupParams,
Map<String,StreamEntryID> streams)
XREAD [COUNT count] [BLOCK milliseconds] STREAMS key [key ...] ID [ID ...]
|
List<byte[]> |
xrevrange(byte[] key,
byte[] end,
byte[] start) |
List<byte[]> |
xrevrange(byte[] key,
byte[] end,
byte[] start,
int count) |
List<StreamEntry> |
xrevrange(String key,
StreamEntryID end,
StreamEntryID start)
XREVRANGE key end start
|
List<StreamEntry> |
xrevrange(String key,
StreamEntryID end,
StreamEntryID start,
int count)
XREVRANGE key end start COUNT count
|
List<StreamEntry> |
xrevrange(String key,
String end,
String start) |
List<StreamEntry> |
xrevrange(String key,
String end,
String start,
int count) |
long |
xtrim(byte[] key,
long maxLen,
boolean approximateLength) |
long |
xtrim(byte[] key,
XTrimParams params) |
long |
xtrim(String key,
long maxLen,
boolean approximate)
XTRIM key MAXLEN [~] count
|
long |
xtrim(String key,
XTrimParams params)
XTRIM key MAXLEN|MINID [=|~] threshold [LIMIT count]
|
long |
zadd(byte[] key,
double score,
byte[] member) |
long |
zadd(byte[] key,
double score,
byte[] member,
ZAddParams params) |
long |
zadd(byte[] key,
Map<byte[],Double> scoreMembers) |
long |
zadd(byte[] key,
Map<byte[],Double> scoreMembers,
ZAddParams params) |
long |
zadd(String key,
double score,
String member)
Add the specified member having the specified score to the sorted set stored at key.
|
long |
zadd(String key,
double score,
String member,
ZAddParams params)
Similar to
ZADD but can be used with optional params. |
long |
zadd(String key,
Map<String,Double> scoreMembers)
Similar to
ZADD but for multiple members. |
long |
zadd(String key,
Map<String,Double> scoreMembers,
ZAddParams params)
Similar to
ZADD but can be used with optional params,
and fits for multiple members. |
Double |
zaddIncr(byte[] key,
double score,
byte[] member,
ZAddParams params) |
Double |
zaddIncr(String key,
double score,
String member,
ZAddParams params)
Increments the score of member in the sorted set stored at key by increment.
|
long |
zcard(byte[] key) |
long |
zcard(String key)
Return the sorted set cardinality (number of elements).
|
long |
zcount(byte[] key,
byte[] min,
byte[] max) |
long |
zcount(byte[] key,
double min,
double max) |
long |
zcount(String key,
double min,
double max)
Return the number of elements in the sorted set at key with a score between min and max.
|
long |
zcount(String key,
String min,
String max)
Similar to
ZCOUNT but with exclusive range. |
Set<byte[]> |
zdiff(byte[]... keys) |
Set<String> |
zdiff(String... keys)
Compute the difference between all the sets in the given keys.
|
long |
zdiffStore(byte[] dstkey,
byte[]... keys) |
long |
zdiffStore(String dstkey,
String... keys)
Compute the difference between all the sets in the given keys.
|
Set<Tuple> |
zdiffWithScores(byte[]... keys) |
Set<Tuple> |
zdiffWithScores(String... keys)
Compute the difference between all the sets in the given keys.
|
double |
zincrby(byte[] key,
double increment,
byte[] member) |
Double |
zincrby(byte[] key,
double increment,
byte[] member,
ZIncrByParams params) |
double |
zincrby(String key,
double increment,
String member)
If member already exists in the sorted set adds the increment to its score and updates the
position of the element in the sorted set accordingly.
|
Double |
zincrby(String key,
double increment,
String member,
ZIncrByParams params)
Similar to
ZINCRBY but can be used with optionals params. |
Set<byte[]> |
zinter(ZParams params,
byte[]... keys) |
Set<String> |
zinter(ZParams params,
String... keys)
Compute the intersection between all the sets in the given keys.
|
long |
zintercard(byte[]... keys)
Similar to
ZINTER, but
instead of returning the result set, it returns just the cardinality of the result. |
long |
zintercard(long limit,
byte[]... keys)
Similar to
ZINTER, but
instead of returning the result set, it returns just the cardinality of the result. |
long |
zintercard(long limit,
String... keys)
Similar to
ZINTER, but
instead of returning the result set, it returns just the cardinality of the result. |
long |
zintercard(String... keys)
Similar to
ZINTER, but
instead of returning the result set, it returns just the cardinality of the result. |
long |
zinterstore(byte[] dstkey,
byte[]... sets) |
long |
zinterstore(byte[] dstkey,
ZParams params,
byte[]... sets) |
long |
zinterstore(String dstkey,
String... sets)
Compute the intersection between all the sets in the given keys.
|
long |
zinterstore(String dstkey,
ZParams params,
String... sets)
Compute the intersection between all the sets in the given keys.
|
Set<Tuple> |
zinterWithScores(ZParams params,
byte[]... keys) |
Set<Tuple> |
zinterWithScores(ZParams params,
String... keys)
Compute the intersection between all the sets in the given keys.
|
long |
zlexcount(byte[] key,
byte[] min,
byte[] max) |
long |
zlexcount(String key,
String min,
String max)
Return the number of elements in the sorted set at key with a value between min and max, when all
the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering.
|
KeyValue<byte[],List<Tuple>> |
zmpop(SortedSetOption option,
byte[]... keys) |
KeyValue<byte[],List<Tuple>> |
zmpop(SortedSetOption option,
int count,
byte[]... keys) |
KeyValue<String,List<Tuple>> |
zmpop(SortedSetOption option,
int count,
String... keys) |
KeyValue<String,List<Tuple>> |
zmpop(SortedSetOption option,
String... keys) |
List<Double> |
zmscore(byte[] key,
byte[]... members) |
List<Double> |
zmscore(String key,
String... members)
Return the scores associated with the specified members in the sorted set stored at key.
|
Tuple |
zpopmax(byte[] key) |
List<Tuple> |
zpopmax(byte[] key,
int count) |
Tuple |
zpopmax(String key)
Remove and return the member with the highest score in the sorted set stored at key.
|
List<Tuple> |
zpopmax(String key,
int count)
Remove and return up to count members with the highest scores in the sorted set stored at key.
|
Tuple |
zpopmin(byte[] key) |
List<Tuple> |
zpopmin(byte[] key,
int count) |
Tuple |
zpopmin(String key)
Remove and return the member with the lowest score in the sorted set stored at key.
|
List<Tuple> |
zpopmin(String key,
int count)
Remove and return up to count members with the lowest scores in the sorted set stored at key.
|
byte[] |
zrandmember(byte[] key) |
List<byte[]> |
zrandmember(byte[] key,
long count) |
String |
zrandmember(String key)
Return a random element from the sorted set value stored at key.
|
List<String> |
zrandmember(String key,
long count)
Return an array of distinct elements.
|
List<Tuple> |
zrandmemberWithScores(byte[] key,
long count) |
List<Tuple> |
zrandmemberWithScores(String key,
long count)
Similar to
ZRANDMEMBER but the replay will
include the scores with the result. |
List<byte[]> |
zrange(byte[] key,
long start,
long stop) |
List<byte[]> |
zrange(byte[] key,
ZRangeParams zRangeParams) |
List<String> |
zrange(String key,
long start,
long stop)
Returns the specified range of elements in the sorted set stored at key.
|
List<String> |
zrange(String key,
ZRangeParams zRangeParams)
Similar to
ZRANGE but can be used with additional params. |
List<byte[]> |
zrangeByLex(byte[] key,
byte[] min,
byte[] max) |
List<byte[]> |
zrangeByLex(byte[] key,
byte[] min,
byte[] max,
int offset,
int count) |
List<String> |
zrangeByLex(String key,
String min,
String max)
Return all the elements in the sorted set at key with a value between min and max, when all
the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering.
|
List<String> |
zrangeByLex(String key,
String min,
String max,
int offset,
int count)
Similar to
ZRANGE but with limit option. |
List<byte[]> |
zrangeByScore(byte[] key,
byte[] min,
byte[] max) |
List<byte[]> |
zrangeByScore(byte[] key,
byte[] min,
byte[] max,
int offset,
int count) |
List<byte[]> |
zrangeByScore(byte[] key,
double min,
double max) |
List<byte[]> |
zrangeByScore(byte[] key,
double min,
double max,
int offset,
int count) |
List<String> |
zrangeByScore(String key,
double min,
double max)
Return all the elements in the sorted set at key with a score between min and max
(including elements with score equal to min or max).
|
List<String> |
zrangeByScore(String key,
double min,
double max,
int offset,
int count)
Similar to
ZRANGE but with exclusive range. |
List<String> |
zrangeByScore(String key,
String min,
String max)
Similar to
ZRANGE but with exclusive range. |
List<String> |
zrangeByScore(String key,
String min,
String max,
int offset,
int count)
Similar to
ZRANGE but with limit option, |
List<Tuple> |
zrangeByScoreWithScores(byte[] key,
byte[] min,
byte[] max) |
List<Tuple> |
zrangeByScoreWithScores(byte[] key,
byte[] min,
byte[] max,
int offset,
int count) |
List<Tuple> |
zrangeByScoreWithScores(byte[] key,
double min,
double max) |
List<Tuple> |
zrangeByScoreWithScores(byte[] key,
double min,
double max,
int offset,
int count) |
List<Tuple> |
zrangeByScoreWithScores(String key,
double min,
double max)
Similar to
ZRANGE but return with scores. |
List<Tuple> |
zrangeByScoreWithScores(String key,
double min,
double max,
int offset,
int count)
Similar to
ZRANGE but with limit option,
and return with scores. |
List<Tuple> |
zrangeByScoreWithScores(String key,
String min,
String max)
Similar to
ZRANGE but with exclusive range,
and return with scores. |
List<Tuple> |
zrangeByScoreWithScores(String key,
String min,
String max,
int offset,
int count)
Similar to
ZRANGE but with exclusive range,
with limit options and return with scores. |
long |
zrangestore(byte[] dest,
byte[] src,
ZRangeParams zRangeParams) |
long |
zrangestore(String dest,
String src,
ZRangeParams zRangeParams)
Similar to
ZRANGE but stores the result in dest. |
List<Tuple> |
zrangeWithScores(byte[] key,
long start,
long stop) |
List<Tuple> |
zrangeWithScores(byte[] key,
ZRangeParams zRangeParams) |
List<Tuple> |
zrangeWithScores(String key,
long start,
long stop)
Returns the specified range of elements in the sorted set stored at key with the scores.
|
List<Tuple> |
zrangeWithScores(String key,
ZRangeParams zRangeParams)
Similar to
ZRANGE but can be used with additional params. |
Long |
zrank(byte[] key,
byte[] member) |
Long |
zrank(String key,
String member)
Return the rank (or index) of member in the sorted set at key, with scores being ordered from
low to high.
|
long |
zrem(byte[] key,
byte[]... members) |
long |
zrem(String key,
String... members)
Remove the specified member from the sorted set value stored at key.
|
long |
zremrangeByLex(byte[] key,
byte[] min,
byte[] max) |
long |
zremrangeByLex(String key,
String min,
String max)
Remove all elements in the sorted set stored at key between the lexicographical range specified by min and max,
when all the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering.
|
long |
zremrangeByRank(byte[] key,
long start,
long stop) |
long |
zremrangeByRank(String key,
long start,
long stop)
Remove all elements in the sorted set at key with rank between start and end.
|
long |
zremrangeByScore(byte[] key,
byte[] min,
byte[] max) |
long |
zremrangeByScore(byte[] key,
double min,
double max) |
long |
zremrangeByScore(String key,
double min,
double max)
Remove all the elements in the sorted set at key with a score between min and max (including
elements with score equal to min or max).
|
long |
zremrangeByScore(String key,
String min,
String max)
Similar to
ZREMRANGE but with limit option. |
List<byte[]> |
zrevrange(byte[] key,
long start,
long stop) |
List<String> |
zrevrange(String key,
long start,
long stop)
Returns the specified range of elements in the sorted set stored at key.
|
List<byte[]> |
zrevrangeByLex(byte[] key,
byte[] max,
byte[] min) |
List<byte[]> |
zrevrangeByLex(byte[] key,
byte[] max,
byte[] min,
int offset,
int count) |
List<String> |
zrevrangeByLex(String key,
String max,
String min)
Return all the elements in the sorted set at key with a value between max and min, when all
the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering.
|
List<String> |
zrevrangeByLex(String key,
String max,
String min,
int offset,
int count)
Similar to
ZRANGE but with limit option. |
List<byte[]> |
zrevrangeByScore(byte[] key,
byte[] max,
byte[] min) |
List<byte[]> |
zrevrangeByScore(byte[] key,
byte[] max,
byte[] min,
int offset,
int count) |
List<byte[]> |
zrevrangeByScore(byte[] key,
double max,
double min) |
List<byte[]> |
zrevrangeByScore(byte[] key,
double max,
double min,
int offset,
int count) |
List<String> |
zrevrangeByScore(String key,
double max,
double min)
Return all the elements in the sorted set at key with a score between max and min
(including elements with score equal to max or min).
|
List<String> |
zrevrangeByScore(String key,
double max,
double min,
int offset,
int count)
Similar to
ZRANGE but with limit option, |
List<String> |
zrevrangeByScore(String key,
String max,
String min)
Similar to
ZREVRANGE but with exclusive range. |
List<String> |
zrevrangeByScore(String key,
String max,
String min,
int offset,
int count)
Similar to
ZREVRANGE but with limit option, |
List<Tuple> |
zrevrangeByScoreWithScores(byte[] key,
byte[] max,
byte[] min) |
List<Tuple> |
zrevrangeByScoreWithScores(byte[] key,
byte[] max,
byte[] min,
int offset,
int count) |
List<Tuple> |
zrevrangeByScoreWithScores(byte[] key,
double max,
double min) |
List<Tuple> |
zrevrangeByScoreWithScores(byte[] key,
double max,
double min,
int offset,
int count) |
List<Tuple> |
zrevrangeByScoreWithScores(String key,
double max,
double min)
Similar to
ZREVRANGE but return with scores. |
List<Tuple> |
zrevrangeByScoreWithScores(String key,
double max,
double min,
int offset,
int count)
Similar to
ZREVRANGE but with
limit options and return with scores. |
List<Tuple> |
zrevrangeByScoreWithScores(String key,
String max,
String min)
Similar to
ZREVRANGE but with exclusive range,
and return with scores. |
List<Tuple> |
zrevrangeByScoreWithScores(String key,
String max,
String min,
int offset,
int count)
Similar to
ZREVRANGE but with
exclusive range, with limit options and return with scores. |
List<Tuple> |
zrevrangeWithScores(byte[] key,
long start,
long stop) |
List<Tuple> |
zrevrangeWithScores(String key,
long start,
long stop)
Similar to
ZREVRANGE but the reply will
include the scores of the returned elements. |
Long |
zrevrank(byte[] key,
byte[] member) |
Long |
zrevrank(String key,
String member)
Return the rank (or index) of member in the sorted set at key, with scores being ordered from
high to low.
|
ScanResult<Tuple> |
zscan(byte[] key,
byte[] cursor,
ScanParams params) |
ScanResult<Tuple> |
zscan(String key,
String cursor,
ScanParams params) |
Double |
zscore(byte[] key,
byte[] member) |
Double |
zscore(String key,
String member)
Return the score of the specified element of the sorted set at key.
|
Set<byte[]> |
zunion(ZParams params,
byte[]... keys) |
Set<String> |
zunion(ZParams params,
String... keys)
Compute the union between all the sets in the given keys.
|
long |
zunionstore(byte[] dstkey,
byte[]... sets) |
long |
zunionstore(byte[] dstkey,
ZParams params,
byte[]... sets) |
long |
zunionstore(String dstkey,
String... sets)
Compute the union between all the sets in the given keys.
|
long |
zunionstore(String dstkey,
ZParams params,
String... sets)
Compute the union between all the sets in the given keys.
|
Set<Tuple> |
zunionWithScores(ZParams params,
byte[]... keys) |
Set<Tuple> |
zunionWithScores(ZParams params,
String... keys)
Compute the union between all the sets in the given keys.
|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, waithscansscanzscanxaddhscansscanzscanxaddftAlterjsonMGet, jsonMGet, jsonSet, jsonSet, jsonSetLegacy, jsonSetLegacy, jsonSetWithEscape, jsonSetWithEscapecmsIncrByprotected final ConnectionProvider provider
protected final CommandExecutor executor
public UnifiedJedis()
public UnifiedJedis(HostAndPort hostAndPort)
public UnifiedJedis(String url)
public UnifiedJedis(URI uri)
public UnifiedJedis(URI uri, JedisClientConfig config)
public UnifiedJedis(HostAndPort hostAndPort, JedisClientConfig clientConfig)
public UnifiedJedis(ConnectionProvider provider)
public UnifiedJedis(JedisSocketFactory socketFactory)
public UnifiedJedis(Connection connection)
public UnifiedJedis(Set<HostAndPort> jedisClusterNodes, JedisClientConfig clientConfig, int maxAttempts)
public UnifiedJedis(Set<HostAndPort> jedisClusterNodes, JedisClientConfig clientConfig, int maxAttempts, Duration maxTotalRetriesDuration)
public UnifiedJedis(Set<HostAndPort> jedisClusterNodes, JedisClientConfig clientConfig, org.apache.commons.pool2.impl.GenericObjectPoolConfig<Connection> poolConfig, int maxAttempts, Duration maxTotalRetriesDuration)
public UnifiedJedis(ClusterConnectionProvider provider, int maxAttempts, Duration maxTotalRetriesDuration)
public UnifiedJedis(ShardedConnectionProvider provider)
public UnifiedJedis(ShardedConnectionProvider provider, Pattern tagPattern)
public UnifiedJedis(ConnectionProvider provider, int maxAttempts, Duration maxTotalRetriesDuration)
public void close()
close in interface AutoCloseablepublic final <T> T executeCommand(CommandObject<T> commandObject)
public boolean exists(String key)
KeyCommandsTime complexity: O(1)
exists in interface KeyCommandstrue if the key exists, false otherwisepublic long exists(String... keys)
KeyCommandsTime complexity: O(N)
exists in interface KeyCommandskeys.public long persist(String key)
KeyCommandspersist in interface KeyCommandspublic String type(String key)
KeyCommandsTime complexity: O(1)
type in interface KeyCommandspublic boolean exists(byte[] key)
exists in interface KeyBinaryCommandspublic long exists(byte[]... keys)
exists in interface KeyBinaryCommandspublic long persist(byte[] key)
persist in interface KeyBinaryCommandspublic String type(byte[] key)
type in interface KeyBinaryCommandspublic byte[] dump(String key)
KeyCommandsTime complexity: O(1) to access the key and additional O(N*M) to serialize it where N is the number of Redis objects composing the value and M their average size.
dump in interface KeyCommandspublic String restore(String key, long ttl, byte[] serializedValue)
KeyCommandsDUMP).
Time complexity: O(1) to access the key and additional O(N*M) to serialize it where N is the number of Redis objects composing the value and M their average size.
restore in interface KeyCommandsttl - If ttl is 0 the key is created without any expire, otherwise the specified expire
time (in milliseconds) is set.public String restore(String key, long ttl, byte[] serializedValue, RestoreParams params)
KeyCommandsDUMP).
Time complexity: O(1) to access the key and additional O(N*M) to serialize it where N is the number of Redis objects composing the value and M their average size.
restore in interface KeyCommandsttl - If ttl is 0 the key is created without any expire, otherwise the specified expire
time (in milliseconds) is set.params - RestoreParamspublic byte[] dump(byte[] key)
dump in interface KeyBinaryCommandspublic String restore(byte[] key, long ttl, byte[] serializedValue)
restore in interface KeyBinaryCommandspublic String restore(byte[] key, long ttl, byte[] serializedValue, RestoreParams params)
restore in interface KeyBinaryCommandspublic long expire(String key, long seconds)
KeyCommandsVolatile keys are stored on disk like the other keys, the timeout is persistent too like all the other aspects of the dataset. Saving a dataset containing expires and stopping the server does not stop the flow of time as Redis stores on disk the time when the key will no longer be available as Unix time, and not the remaining seconds.
Since Redis 2.1.3 you can update the value of the timeout of a key already having an expire
set. It is also possible to undo the expire at all turning the key into a normal key using the
PERSIST command.
Time complexity: O(1)
expire in interface KeyCommandsseconds - time to expirepublic long expire(String key, long seconds, ExpiryOption expiryOption)
KeyCommandsEXPIRE but with optional expiry setting.expire in interface KeyCommandsseconds - time to expireexpiryOption - can be NX, XX, GT or LTKeyCommands.expire(String, long)public long pexpire(String key, long milliseconds)
KeyCommandsEXPIRE but the time
to live of the key is specified in milliseconds instead of seconds.
Time complexity: O(1)
pexpire in interface KeyCommandsmilliseconds - time to expirepublic long pexpire(String key, long milliseconds, ExpiryOption expiryOption)
KeyCommandsEXPIRE but with optional expiry setting.pexpire in interface KeyCommandsmilliseconds - time to expireexpiryOption - can be NX, XX, GT or LTKeyCommands.pexpire(String, long)public long expireTime(String key)
KeyCommandsThe command returns -1 if the key exists but has no associated expiration time, and -2 if the key does not exist.
Time complexity: O(1)
expireTime in interface KeyCommandspublic long pexpireTime(String key)
KeyCommandsEXPIRETIME but returns the absolute Unix expiration
timestamp in milliseconds instead of seconds.
Time complexity: O(1)
pexpireTime in interface KeyCommandsKeyCommands.expireTime(String)public long expireAt(String key, long unixTime)
KeyCommandsEXPIRE but instead to get the
number of seconds representing the Time To Live of the key as a second argument (that is a
relative way of specifying the TTL), it takes an absolute one in the form of a UNIX timestamp
(Number of seconds elapsed since 1 Gen 1970).
EXPIREAT was introduced in order to implement the Append Only File persistence mode so that EXPIRE commands are automatically translated into EXPIREAT commands for the append only file. Of course EXPIREAT can also used by programmers that need a way to simply specify that a given key should expire at a given time in the future.
Time complexity: O(1)
expireAt in interface KeyCommandsunixTime - time to expirepublic long expireAt(String key, long unixTime, ExpiryOption expiryOption)
KeyCommandsexpireAt in interface KeyCommandsunixTime - time to expireexpiryOption - can be NX, XX, GT or LTKeyCommands.expireAt(String, long)public long pexpireAt(String key, long millisecondsTimestamp)
KeyCommandsEXPIREAT but
Unix time at which the key will expire is specified in milliseconds instead of seconds.
Time complexity: O(1)
pexpireAt in interface KeyCommandsmillisecondsTimestamp - time to expirepublic long pexpireAt(String key, long millisecondsTimestamp, ExpiryOption expiryOption)
KeyCommandspexpireAt in interface KeyCommandsmillisecondsTimestamp - time to expireexpiryOption - can be NX, XX, GT or LTKeyCommands.pexpireAt(String, long)public long expire(byte[] key,
long seconds)
expire in interface KeyBinaryCommandspublic long expire(byte[] key,
long seconds,
ExpiryOption expiryOption)
expire in interface KeyBinaryCommandspublic long pexpire(byte[] key,
long milliseconds)
pexpire in interface KeyBinaryCommandspublic long pexpire(byte[] key,
long milliseconds,
ExpiryOption expiryOption)
pexpire in interface KeyBinaryCommandspublic long expireTime(byte[] key)
expireTime in interface KeyBinaryCommandspublic long pexpireTime(byte[] key)
pexpireTime in interface KeyBinaryCommandspublic long expireAt(byte[] key,
long unixTime)
expireAt in interface KeyBinaryCommandspublic long expireAt(byte[] key,
long unixTime,
ExpiryOption expiryOption)
expireAt in interface KeyBinaryCommandspublic long pexpireAt(byte[] key,
long millisecondsTimestamp)
pexpireAt in interface KeyBinaryCommandspublic long pexpireAt(byte[] key,
long millisecondsTimestamp,
ExpiryOption expiryOption)
pexpireAt in interface KeyBinaryCommandspublic long ttl(String key)
KeyCommandsEXPIRE set. This introspection capability allows a Redis
connection to check how many seconds a given key will continue to be part of the dataset.
Time complexity: O(1)
ttl in interface KeyCommandspublic long pttl(String key)
KeyCommandsEXPIRE set.
Time complexity: O(1)
pttl in interface KeyCommandspublic long touch(String key)
KeyCommandsTime complexity: O(N) where N is the number of keys that will be touched.
touch in interface KeyCommandspublic long touch(String... keys)
KeyCommandsTime complexity: O(N) where N is the number of keys that will be touched.
touch in interface KeyCommandspublic long ttl(byte[] key)
ttl in interface KeyBinaryCommandspublic long pttl(byte[] key)
pttl in interface KeyBinaryCommandspublic long touch(byte[] key)
touch in interface KeyBinaryCommandspublic long touch(byte[]... keys)
touch in interface KeyBinaryCommandspublic List<String> sort(String key)
KeyCommandsSort the elements contained in the List, Set, or Sorted Set values at key. By default, sorting is numeric with elements being compared as double precision floating point numbers. This is the simplest form of SORT.
sort in interface KeyCommandsKeyCommands.sort(String, SortingParams)public List<String> sort(String key, SortingParams sortingParams)
KeyCommandsexamples:
Given are the following sets and key/values:
x = [1, 2, 3] y = [a, b, c] k1 = z k2 = y k3 = x w1 = 9 w2 = 8 w3 = 7Sort Order:
sort(x) or sort(x, sp.asc()) -> [1, 2, 3] sort(x, sp.desc()) -> [3, 2, 1] sort(y) -> [c, a, b] sort(y, sp.alpha()) -> [a, b, c] sort(y, sp.alpha().desc()) -> [c, a, b]Limit (e.g. for Pagination):
sort(x, sp.limit(0, 2)) -> [1, 2] sort(y, sp.alpha().desc().limit(1, 2)) -> [b, a]Sorting by external keys:
sort(x, sb.by(w*)) -> [3, 2, 1] sort(x, sb.by(w*).desc()) -> [1, 2, 3]Getting external keys:
sort(x, sp.by(w*).get(k*)) -> [x, y, z] sort(x, sp.by(w*).get(#).get(k*)) -> [3, x, 2, y, 1, z]
sort in interface KeyCommandssortingParams - SortingParamspublic long sort(String key, String dstkey)
KeyCommandsSORT but store the result in dstkey.sort in interface KeyCommandsKeyCommands.sort(String)public long sort(String key, SortingParams sortingParams, String dstkey)
KeyCommandsSORT but store the result in dstkey.sort in interface KeyCommandssortingParams - SortingParamsKeyCommands.sort(String, SortingParams)public List<String> sortReadonly(String key, SortingParams sortingParams)
KeyCommandsSORT command.
It is exactly like the original SORT but refuses the STORE option and can safely be used in read-only replicas.sortReadonly in interface KeyCommandskey - the key to sortsortingParams - SortingParamspublic List<byte[]> sort(byte[] key)
sort in interface KeyBinaryCommandspublic List<byte[]> sort(byte[] key, SortingParams sortingParams)
sort in interface KeyBinaryCommandspublic long sort(byte[] key,
byte[] dstkey)
sort in interface KeyBinaryCommandspublic List<byte[]> sortReadonly(byte[] key, SortingParams sortingParams)
sortReadonly in interface KeyBinaryCommandspublic long sort(byte[] key,
SortingParams sortingParams,
byte[] dstkey)
sort in interface KeyBinaryCommandspublic long del(String key)
KeyCommandsTime complexity: O(1)
del in interface KeyCommandspublic long del(String... keys)
KeyCommandsTime complexity: O(N)
del in interface KeyCommandspublic long unlink(String key)
KeyCommandsDEL: it removes the specified key.
Just like DEL a key is ignored if it does not exist. However, the command performs the actual
memory reclaiming in a different thread, so it is not blocking, while DEL is. This is where the
command name comes from: the command just unlinks the keys from the keyspace. The actual removal
will happen later asynchronously.
Time complexity: O(1) for each key removed regardless of its size. Then the command does O(N) work in a different thread in order to reclaim memory, where N is the number of allocations the deleted objects where composed of.
unlink in interface KeyCommandspublic long unlink(String... keys)
KeyCommandsSORT but can be used with multiple keys.unlink in interface KeyCommandsKeyCommands.unlink(String)public long del(byte[] key)
del in interface KeyBinaryCommandspublic long del(byte[]... keys)
del in interface KeyBinaryCommandspublic long unlink(byte[] key)
unlink in interface KeyBinaryCommandspublic long unlink(byte[]... keys)
unlink in interface KeyBinaryCommandspublic Long memoryUsage(String key)
KeyCommandsTime complexity: O(1)
memoryUsage in interface KeyCommandspublic Long memoryUsage(String key, int samples)
KeyCommandsTime complexity: O(1)
memoryUsage in interface KeyCommandssamples - the number of sampled nested values. By default, this option is set to 5.
To sample the all the nested values, use 0.public Long memoryUsage(byte[] key)
memoryUsage in interface KeyBinaryCommandspublic Long memoryUsage(byte[] key, int samples)
memoryUsage in interface KeyBinaryCommandspublic boolean copy(String srcKey, String dstKey, boolean replace)
KeyCommandscopy in interface KeyCommandssrcKey - the source key.dstKey - the destination key.replace - removes the destination key before copying the value to it, in order to avoid error.true if source was copied, false otherwisepublic String rename(String oldkey, String newkey)
KeyCommandsoldkey to newkey. If the source and destination name are the same an
error is returned. If newkey already exists it is overwritten.
Time complexity: O(1)
rename in interface KeyCommandspublic long renamenx(String oldkey, String newkey)
KeyCommandsTime complexity: O(1)
renamenx in interface KeyCommandspublic boolean copy(byte[] srcKey,
byte[] dstKey,
boolean replace)
copy in interface KeyBinaryCommandspublic String rename(byte[] oldkey, byte[] newkey)
rename in interface KeyBinaryCommandspublic long renamenx(byte[] oldkey,
byte[] newkey)
renamenx in interface KeyBinaryCommandspublic long dbSize()
public Set<String> keys(String pattern)
KeyCommandsNote that while the time complexity for this operation is O(n) the constant times are pretty low. For example Redis running on an entry level laptop can scan a 1 million keys database in 40 milliseconds. Still it's better to consider this one of the slow commands that may ruin the DB performance if not used with care.
In other words this command is intended only for debugging and special operations like creating a script to change the DB schema. Don't use it in your normal code. Use Redis Sets in order to group together a subset of objects.
Glob style patterns examples:
Use \ to escape special chars if you want to match them verbatim.
Time complexity: O(n) (with n being the number of keys in the DB, and assuming keys and pattern of limited length)
keys in interface KeyCommandspublic ScanResult<String> scan(String cursor)
scan in interface KeyCommandspublic ScanResult<String> scan(String cursor, ScanParams params)
scan in interface KeyCommandspublic ScanResult<String> scan(String cursor, ScanParams params, String type)
scan in interface KeyCommandspublic Set<byte[]> keys(byte[] pattern)
keys in interface KeyBinaryCommandspublic ScanResult<byte[]> scan(byte[] cursor)
scan in interface KeyBinaryCommandspublic ScanResult<byte[]> scan(byte[] cursor, ScanParams params)
scan in interface KeyBinaryCommandspublic ScanResult<byte[]> scan(byte[] cursor, ScanParams params, byte[] type)
scan in interface KeyBinaryCommandspublic String randomKey()
KeyCommandsTime complexity: O(1)
randomKey in interface KeyCommandsnil when the database is emptypublic byte[] randomBinaryKey()
randomBinaryKey in interface KeyBinaryCommandspublic String set(String key, String value)
StringCommandsTime complexity: O(1)
set in interface StringCommandspublic String set(String key, String value, SetParams params)
StringCommandsTime complexity: O(1)<
set in interface StringCommandsparams - SetParamspublic String get(String key)
StringCommandsTime complexity: O(1)
get in interface StringCommandspublic String getDel(String key)
StringCommandsTime complexity: O(1)
getDel in interface StringCommandspublic String getEx(String key, GetExParams params)
StringCommandsGET,
but is a write command with additional options:
EX seconds -- Set the specified expire time, in seconds.
PX milliseconds -- Set the specified expire time, in milliseconds.
EXAT timestamp-seconds -- Set the specified Unix time at which the key will expire, in seconds.
PXAT timestamp-milliseconds -- Set the specified Unix time at which the key will expire, in milliseconds.
PERSIST -- Remove the time to live associated with the key.
Time complexity: O(1)
getEx in interface StringCommandsparams - GetExParamspublic String set(byte[] key, byte[] value)
set in interface StringBinaryCommandspublic String set(byte[] key, byte[] value, SetParams params)
set in interface StringBinaryCommandspublic byte[] get(byte[] key)
get in interface StringBinaryCommandspublic byte[] getDel(byte[] key)
getDel in interface StringBinaryCommandspublic byte[] getEx(byte[] key,
GetExParams params)
getEx in interface StringBinaryCommandspublic boolean setbit(String key, long offset, boolean value)
StringCommandsTime complexity: O(1)
setbit in interface StringCommandspublic boolean getbit(String key, long offset)
StringCommandsTime complexity: O(1)
getbit in interface StringCommandspublic long setrange(String key, long offset, String value)
StringCommandsTime complexity: O(1)
setrange in interface StringCommandspublic String getrange(String key, long startOffset, long endOffset)
StringCommandsTime complexity: O(N) where N is the length of the returned string
getrange in interface StringCommandspublic boolean setbit(byte[] key,
long offset,
boolean value)
setbit in interface StringBinaryCommandspublic boolean getbit(byte[] key,
long offset)
getbit in interface StringBinaryCommandspublic long setrange(byte[] key,
long offset,
byte[] value)
setrange in interface StringBinaryCommandspublic byte[] getrange(byte[] key,
long startOffset,
long endOffset)
getrange in interface StringBinaryCommandspublic String getSet(String key, String value)
StringCommandsTime complexity: O(1)
getSet in interface StringCommandspublic long setnx(String key, String value)
StringCommandsSET with the only difference that if
the key already exists no operation is performed. SETNX actually means "SET if Not Exists".
Time complexity: O(1)
setnx in interface StringCommandspublic String setex(String key, long seconds, String value)
StringCommandsSET + EXPIRE.
The operation is atomic.
Time complexity: O(1)
setex in interface StringCommandspublic String psetex(String key, long milliseconds, String value)
StringCommandsSETEX with the sole difference
that the expire time is specified in milliseconds instead of seconds.
Time complexity: O(1)
psetex in interface StringCommandspublic byte[] getSet(byte[] key,
byte[] value)
getSet in interface StringBinaryCommandspublic long setnx(byte[] key,
byte[] value)
setnx in interface StringBinaryCommandspublic String setex(byte[] key, long seconds, byte[] value)
setex in interface StringBinaryCommandspublic String psetex(byte[] key, long milliseconds, byte[] value)
psetex in interface StringBinaryCommandspublic long incr(String key)
StringCommandsINCR commands are limited to 64 bit signed integers.
Note: this is actually a string operation, that is, in Redis there are not "integer" types. Simply the string stored at the key is parsed as a base 10 64 bit signed integer, incremented, and then converted back as a string.
Time complexity: O(1)
incr in interface StringCommandskey - the key to incrementpublic long incrBy(String key, long increment)
StringCommandsINCR but instead to increment by 1 the
increment is integer.
INCR commands are limited to 64 bit signed integers.
Note: this is actually a string operation, that is, in Redis there are not "integer" types. Simply the string stored at the key is parsed as a base 10 64 bit signed integer, incremented, and then converted back as a string.
Time complexity: O(1)
incrBy in interface StringCommandskey - the key to incrementincrement - the value to increment bypublic double incrByFloat(String key, double increment)
StringCommandsStringCommands.incrBy(String, long) INCRBY} but increments by floats
instead of integers.
INCRBYFLOAT commands are limited to double precision floating point values.
Note: this is actually a string operation, that is, in Redis there are not "double" types. Simply the string stored at the key is parsed as a base double precision floating point value, incremented, and then converted back as a string. There is no DECRYBYFLOAT but providing a negative value will work as expected.
Time complexity: O(1)
incrByFloat in interface StringCommandskey - the key to incrementincrement - the value to increment bypublic long decr(String key)
StringCommandsDECR commands are limited to 64 bit signed integers.
Note: this is actually a string operation, that is, in Redis there are not "integer" types. Simply the string stored at the key is parsed as a base 10 64 bit signed integer, incremented, and then converted back as a string.
Time complexity: O(1)
decr in interface StringCommandskey - the key to decrementpublic long decrBy(String key, long decrement)
StringCommandsDECR but instead to decrement by 1 the
decrement is integer.
DECRBY commands are limited to 64 bit signed integers.
Note: this is actually a string operation, that is, in Redis there are not "integer" types. Simply the string stored at the key is parsed as a base 10 64 bit signed integer, incremented, and then converted back as a string.
Time complexity: O(1)
decrBy in interface StringCommandskey - the key to decrementdecrement - the value to decrement bypublic long incr(byte[] key)
incr in interface StringBinaryCommandspublic long incrBy(byte[] key,
long increment)
incrBy in interface StringBinaryCommandspublic double incrByFloat(byte[] key,
double increment)
incrByFloat in interface StringBinaryCommandspublic long decr(byte[] key)
decr in interface StringBinaryCommandspublic long decrBy(byte[] key,
long decrement)
decrBy in interface StringBinaryCommandspublic List<String> mget(String... keys)
StringCommandsTime complexity: O(1) for every key
mget in interface StringCommandspublic String mset(String... keysvalues)
StringCommandsMSETNX will not perform any operation at all even
if just a single key already exists.
Because of this semantic MSETNX can be used in order to set different keys representing different fields of an unique logic object in a way that ensures that either all the fields or none at all are set.
Both MSET and MSETNX are atomic operations. This means that for instance if the keys A and B are modified, another connection talking to Redis can either see the changes to both A and B at once, or no modification at all.
mset in interface StringCommandskeysvalues - pairs of keys and their values
e.g mset("foo", "foovalue", "bar", "barvalue")public long msetnx(String... keysvalues)
StringCommandsMSET will
replace old values with new values, while MSETNX will not perform any operation at all even if
just a single key already exists.
Because of this semantic MSETNX can be used in order to set different keys representing different fields of an unique logic object in a way that ensures that either all the fields or none at all are set.
Both MSET and MSETNX are atomic operations. This means that for instance if the keys A and B are modified, another connection talking to Redis can either see the changes to both A and B at once, or no modification at all.
msetnx in interface StringCommandskeysvalues - pairs of keys and their values
e.g msetnx("foo", "foovalue", "bar", "barvalue")public List<byte[]> mget(byte[]... keys)
mget in interface StringBinaryCommandspublic String mset(byte[]... keysvalues)
mset in interface StringBinaryCommandspublic long msetnx(byte[]... keysvalues)
msetnx in interface StringBinaryCommandspublic long append(String key, String value)
StringCommandsTime complexity: O(1). The amortized time complexity is O(1) assuming the appended value is small and the already present value is of any size, since the dynamic string library used by Redis will double the free space available on every reallocation.
append in interface StringCommandskey - the key to append tovalue - the value to appendpublic String substr(String key, int start, int end)
StringCommandsThe function handles out of range requests without raising an error, but just limiting the resulting range to the actual length of the string.
Time complexity: O(start+n) (with start being the start index and n the total length of the requested range). Note that the lookup part of this command is O(1) so for small strings this is actually an O(1) command.
substr in interface StringCommandspublic long strlen(String key)
StringCommandsstrlen in interface StringCommandspublic long append(byte[] key,
byte[] value)
append in interface StringBinaryCommandspublic byte[] substr(byte[] key,
int start,
int end)
substr in interface StringBinaryCommandspublic long strlen(byte[] key)
strlen in interface StringBinaryCommandspublic long bitcount(String key)
StringCommandsbitcount in interface StringCommandspublic long bitcount(String key, long start, long end)
StringCommandsLike for the GETRANGE command 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, and so forth.
bitcount in interface StringCommandsstart - byte start indexend - byte end indexpublic long bitcount(String key, long start, long end, BitCountOption option)
bitcount in interface StringCommandsstart - byte start indexend - byte end indexoption - indicate BYTE or BITStringCommands.bitcount(String, long, long)public long bitpos(String key, boolean value)
StringCommandsbitpos in interface StringCommandsvalue - the bit valuepublic long bitpos(String key, boolean value, BitPosParams params)
StringCommandsbitpos in interface StringCommandsvalue - the bit valueparams - BitPosParamspublic long bitcount(byte[] key)
bitcount in interface StringBinaryCommandspublic long bitcount(byte[] key,
long start,
long end)
bitcount in interface StringBinaryCommandspublic long bitcount(byte[] key,
long start,
long end,
BitCountOption option)
bitcount in interface StringBinaryCommandspublic long bitpos(byte[] key,
boolean value)
bitpos in interface StringBinaryCommandspublic long bitpos(byte[] key,
boolean value,
BitPosParams params)
bitpos in interface StringBinaryCommandspublic List<Long> bitfield(String key, String... arguments)
StringCommandsbitfield in interface StringCommandsarguments - may be used with optional argumentspublic List<Long> bitfieldReadonly(String key, String... arguments)
StringCommandsBITFIELDbitfieldReadonly in interface StringCommandspublic List<Long> bitfield(byte[] key, byte[]... arguments)
bitfield in interface StringBinaryCommandspublic List<Long> bitfieldReadonly(byte[] key, byte[]... arguments)
bitfieldReadonly in interface StringBinaryCommandspublic long bitop(BitOP op, String destKey, String... srcKeys)
StringCommandsbitop in interface StringCommandsop - can be AND, OR, XOR or NOTpublic long bitop(BitOP op, byte[] destKey, byte[]... srcKeys)
bitop in interface StringBinaryCommandspublic LCSMatchResult strAlgoLCSKeys(String keyA, String keyB, StrAlgoLCSParams params)
StringCommandsstrAlgoLCSKeys in interface StringCommandspublic LCSMatchResult strAlgoLCSKeys(byte[] keyA, byte[] keyB, StrAlgoLCSParams params)
strAlgoLCSKeys in interface StringBinaryCommandspublic LCSMatchResult lcs(String keyA, String keyB, LCSParams params)
StringCommandslcs in interface StringCommandspublic LCSMatchResult lcs(byte[] keyA, byte[] keyB, LCSParams params)
StringBinaryCommandslcs in interface StringBinaryCommandspublic long rpush(String key, String... string)
ListCommandsTime complexity: O(1)
rpush in interface ListCommandsstring - data to pushpublic long lpush(String key, String... string)
ListCommandsTime complexity: O(1)
lpush in interface ListCommandsstring - data to pushpublic long llen(String key)
ListCommandsTime complexity: O(1)
llen in interface ListCommandspublic List<String> lrange(String key, long start, long stop)
ListCommandsFor example LRANGE foobar 0 2 will return the first three elements of the list.
start and end can also be negative numbers indicating offsets from the end of the list. For example -1 is the last element of the list, -2 the penultimate element and so on.
Consistency with range functions in various programming languages
Note that if you have a list of numbers from 0 to 100, LRANGE 0 10 will return 11 elements, that is, rightmost item is included. This may or may not be consistent with behavior of range-related functions in your programming language of choice (think Ruby's Range.new, Array#slice or Python's range() function).
LRANGE behavior is consistent with one of Tcl.
Out-of-range indexes
Indexes out of range will not produce an error: if start is over the end of the list, or start > end, an empty list is returned. If end is over the end of the list Redis will threat it just like the last element of the list.
Time complexity: O(start+n) (with n being the length of the range and start being the start offset)
lrange in interface ListCommandspublic String ltrim(String key, long start, long stop)
ListCommandsFor example LTRIM foobar 0 2 will modify the list stored at foobar key so that only the first three elements of the list will remain.
start and end can also be negative numbers indicating offsets from the end of the list. For example -1 is the last element of the list, -2 the penultimate element and so on.
Indexes out of range will not produce an error: if start is over the end of the list, or start > end, an empty list is left as value. If end over the end of the list Redis will threat it just like the last element of the list.
Hint: the obvious use of LTRIM is together with LPUSH/RPUSH. For example:
lpush("mylist", "someelement"); ltrim("mylist", 0, 99); *
The above two commands will push elements in the list taking care that the list will not grow without limits. This is very useful when using Redis to store logs for example. It is important to note that when used in this way LTRIM is an O(1) operation because in the average case just one element is removed from the tail of the list.
Time complexity: O(n) (with n being len of list - len of range)
ltrim in interface ListCommandspublic String lindex(String key, long index)
ListCommandsIf the value stored at key is not of list type an error is returned. If the index is out of range a 'nil' reply is returned.
Note that even if the average time complexity is O(n) asking for the first or the last element of the list is O(1).
Time complexity: O(n) (with n being the length of the list)
lindex in interface ListCommandspublic long rpush(byte[] key,
byte[]... args)
rpush in interface ListBinaryCommandspublic long lpush(byte[] key,
byte[]... args)
lpush in interface ListBinaryCommandspublic long llen(byte[] key)
llen in interface ListBinaryCommandspublic List<byte[]> lrange(byte[] key, long start, long stop)
lrange in interface ListBinaryCommandspublic String ltrim(byte[] key, long start, long stop)
ltrim in interface ListBinaryCommandspublic byte[] lindex(byte[] key,
long index)
lindex in interface ListBinaryCommandspublic String lset(String key, long index, String value)
ListCommandsOut of range indexes will generate an error.
Similarly to other list commands accepting indexes, the index can be negative to access elements starting from the end of the list. So -1 is the last element, -2 is the penultimate, and so forth.
Time Complexity O(N) when N being the length of the list. For the first or last elements of the list is O(1)
lset in interface ListCommandspublic long lrem(String key, long count, String value)
ListCommandsTime complexity: O(N) (with N being the length of the list)
lrem in interface ListCommandspublic String lpop(String key)
ListCommandsIf the key does not exist or the list is already empty the special value 'nil' is returned.
lpop in interface ListCommandspublic List<String> lpop(String key, int count)
ListCommandslpop in interface ListCommandspublic String lset(byte[] key, long index, byte[] value)
lset in interface ListBinaryCommandspublic long lrem(byte[] key,
long count,
byte[] value)
lrem in interface ListBinaryCommandspublic byte[] lpop(byte[] key)
lpop in interface ListBinaryCommandspublic List<byte[]> lpop(byte[] key, int count)
lpop in interface ListBinaryCommandspublic Long lpos(String key, String element)
ListCommandsTime complexity: O(N) where N is the number of elements in the list
lpos in interface ListCommandspublic Long lpos(String key, String element, LPosParams params)
ListCommandsMaxlen option compares the element provided only with a given maximum number of list items. A value of 1000 will make sure that the command performs only 1000 comparisons. The comparison is made for the first part or the last part depending on the fact we use a positive or negative rank. Following is how we could use the Maxlen option lpos("foo", "b", LPosParams.lPosParams().rank(1).maxlen(2)).
lpos in interface ListCommandsparams - LPosParamspublic List<Long> lpos(String key, String element, LPosParams params, long count)
ListCommandsTime complexity: O(N) where N is the number of elements in the list
lpos in interface ListCommandsparams - LPosParamspublic Long lpos(byte[] key, byte[] element)
lpos in interface ListBinaryCommandspublic Long lpos(byte[] key, byte[] element, LPosParams params)
lpos in interface ListBinaryCommandspublic List<Long> lpos(byte[] key, byte[] element, LPosParams params, long count)
lpos in interface ListBinaryCommandspublic String rpop(String key)
ListCommandsrpop in interface ListCommandspublic List<String> rpop(String key, int count)
ListCommandsrpop in interface ListCommandscount - return up to count elementspublic byte[] rpop(byte[] key)
rpop in interface ListBinaryCommandspublic List<byte[]> rpop(byte[] key, int count)
rpop in interface ListBinaryCommandspublic long linsert(String key, ListPosition where, String pivot, String value)
ListCommandsWhen key does not exist, it is considered an empty list and no operation is performed.
linsert in interface ListCommandswhere - can be BEFORE or AFTERpivot - reference valuevalue - the valuepublic long lpushx(String key, String... strings)
ListCommandsLPUSH,
no operation will be performed when key does not yet exist.lpushx in interface ListCommandsstrings - the strings to pushpublic long rpushx(String key, String... strings)
ListCommandsRPUSH,
no operation will be performed when key does not yet exist.rpushx in interface ListCommandsstrings - the strings to pushpublic long linsert(byte[] key,
ListPosition where,
byte[] pivot,
byte[] value)
linsert in interface ListBinaryCommandspublic long lpushx(byte[] key,
byte[]... args)
lpushx in interface ListBinaryCommandspublic long rpushx(byte[] key,
byte[]... args)
rpushx in interface ListBinaryCommandspublic List<String> blpop(int timeout, String key)
blpop in interface ListCommandsListCommands.blpop(int, String...)public KeyedListElement blpop(double timeout, String key)
blpop in interface ListCommandsListCommands.blpop(double, String...)public List<String> brpop(int timeout, String key)
brpop in interface ListCommandsListCommands.brpop(int, String...)public KeyedListElement brpop(double timeout, String key)
brpop in interface ListCommandsListCommands.brpop(double, String...)public List<String> blpop(int timeout, String... keys)
ListCommandsListCommands.lpop(String) LPOP} because it blocks the connection
when there are no elements to pop from any of the given lists. An element is popped from the head of
the first list that is non-empty, with the given keys being checked in the order that they are given.blpop in interface ListCommandstimeout - the timeout argument is interpreted as a double value specifying the maximum number of
seconds to block. A timeout of zero can be used to block indefinitely.public KeyedListElement blpop(double timeout, String... keys)
ListCommandsListCommands.lpop(String) LPOP} because it blocks the connection
when there are no elements to pop from any of the given lists. An element is popped from the head of
the first list that is non-empty, with the given keys being checked in the order that they are given.blpop in interface ListCommandstimeout - the timeout argument is interpreted as a double value specifying the maximum number of
seconds to block. A timeout of zero can be used to block indefinitely.public List<String> brpop(int timeout, String... keys)
ListCommandsListCommands.rpop(String) RPOP} because it blocks the connection
when there are no elements to pop from any of the given lists. An element is popped from the tail of
the first list that is non-empty, with the given keys being checked in the order that they are given.brpop in interface ListCommandstimeout - the timeout argument is interpreted as a double value specifying the maximum number of
seconds to block. A timeout of zero can be used to block indefinitely.public KeyedListElement brpop(double timeout, String... keys)
ListCommandsListCommands.rpop(String) RPOP} because it blocks the connection
when there are no elements to pop from any of the given lists. An element is popped from the tail of
the first list that is non-empty, with the given keys being checked in the order that they are given.brpop in interface ListCommandstimeout - the timeout argument is interpreted as a double value specifying the maximum number of
seconds to block. A timeout of zero can be used to block indefinitely.public List<byte[]> blpop(int timeout, byte[]... keys)
blpop in interface ListBinaryCommandspublic List<byte[]> blpop(double timeout, byte[]... keys)
blpop in interface ListBinaryCommandspublic List<byte[]> brpop(int timeout, byte[]... keys)
brpop in interface ListBinaryCommandspublic List<byte[]> brpop(double timeout, byte[]... keys)
brpop in interface ListBinaryCommandspublic String rpoplpush(String srckey, String dstkey)
ListCommandsIf the key does not exist or the list is already empty the special value 'nil' is returned. If the srckey and dstkey are the same the operation is equivalent to removing the last element from the list and pushing it as first element of the list, so it's a "list rotation" command.
Time complexity: O(1)
rpoplpush in interface ListCommandspublic String brpoplpush(String source, String destination, int timeout)
ListCommandsListCommands.rpoplpush(String, String). When source is
empty, Redis will block the connection until another client pushes to it or until timeout is
reached. A timeout of zero can be used to block indefinitely.
Time complexity: O(1)
brpoplpush in interface ListCommandstimeout - the timeout argument is interpreted as a double value specifying the maximum number of
seconds to block. A timeout of zero can be used to block indefinitely.public byte[] rpoplpush(byte[] srckey,
byte[] dstkey)
rpoplpush in interface ListBinaryCommandspublic byte[] brpoplpush(byte[] source,
byte[] destination,
int timeout)
brpoplpush in interface ListBinaryCommandspublic String lmove(String srcKey, String dstKey, ListDirection from, ListDirection to)
ListCommandslmove in interface ListCommandsfrom - can be LEFT or RIGHTto - can be LEFT or RIGHTpublic String blmove(String srcKey, String dstKey, ListDirection from, ListDirection to, double timeout)
ListCommandsblmove in interface ListCommandsfrom - can be LEFT or RIGHTto - can be LEFT or RIGHTtimeout - the timeout argument is interpreted as a double value specifying the maximum number of
seconds to block. A timeout of zero can be used to block indefinitely.public byte[] lmove(byte[] srcKey,
byte[] dstKey,
ListDirection from,
ListDirection to)
lmove in interface ListBinaryCommandspublic byte[] blmove(byte[] srcKey,
byte[] dstKey,
ListDirection from,
ListDirection to,
double timeout)
blmove in interface ListBinaryCommandspublic KeyValue<String,List<String>> lmpop(ListDirection direction, String... keys)
lmpop in interface ListCommandspublic KeyValue<String,List<String>> lmpop(ListDirection direction, int count, String... keys)
lmpop in interface ListCommandspublic KeyValue<String,List<String>> blmpop(long timeout, ListDirection direction, String... keys)
blmpop in interface ListCommandspublic KeyValue<String,List<String>> blmpop(long timeout, ListDirection direction, int count, String... keys)
blmpop in interface ListCommandspublic KeyValue<byte[],List<byte[]>> lmpop(ListDirection direction, byte[]... keys)
lmpop in interface ListBinaryCommandspublic KeyValue<byte[],List<byte[]>> lmpop(ListDirection direction, int count, byte[]... keys)
lmpop in interface ListBinaryCommandspublic KeyValue<byte[],List<byte[]>> blmpop(long timeout, ListDirection direction, byte[]... keys)
blmpop in interface ListBinaryCommandspublic KeyValue<byte[],List<byte[]>> blmpop(long timeout, ListDirection direction, int count, byte[]... keys)
blmpop in interface ListBinaryCommandspublic long hset(String key, String field, String value)
hset in interface HashCommandspublic long hset(String key, Map<String,String> hash)
hset in interface HashCommandspublic String hget(String key, String field)
hget in interface HashCommandspublic long hsetnx(String key, String field, String value)
hsetnx in interface HashCommandspublic String hmset(String key, Map<String,String> hash)
hmset in interface HashCommandspublic List<String> hmget(String key, String... fields)
hmget in interface HashCommandspublic long hset(byte[] key,
byte[] field,
byte[] value)
hset in interface HashBinaryCommandspublic long hset(byte[] key,
Map<byte[],byte[]> hash)
hset in interface HashBinaryCommandspublic byte[] hget(byte[] key,
byte[] field)
hget in interface HashBinaryCommandspublic long hsetnx(byte[] key,
byte[] field,
byte[] value)
hsetnx in interface HashBinaryCommandspublic String hmset(byte[] key, Map<byte[],byte[]> hash)
hmset in interface HashBinaryCommandspublic List<byte[]> hmget(byte[] key, byte[]... fields)
hmget in interface HashBinaryCommandspublic long hincrBy(String key, String field, long value)
hincrBy in interface HashCommandspublic double hincrByFloat(String key, String field, double value)
hincrByFloat in interface HashCommandspublic boolean hexists(String key, String field)
hexists in interface HashCommandspublic long hdel(String key, String... field)
hdel in interface HashCommandspublic long hlen(String key)
hlen in interface HashCommandspublic long hincrBy(byte[] key,
byte[] field,
long value)
hincrBy in interface HashBinaryCommandspublic double hincrByFloat(byte[] key,
byte[] field,
double value)
hincrByFloat in interface HashBinaryCommandspublic boolean hexists(byte[] key,
byte[] field)
hexists in interface HashBinaryCommandspublic long hdel(byte[] key,
byte[]... field)
hdel in interface HashBinaryCommandspublic long hlen(byte[] key)
hlen in interface HashBinaryCommandspublic Set<String> hkeys(String key)
hkeys in interface HashCommandspublic List<String> hvals(String key)
hvals in interface HashCommandspublic Map<String,String> hgetAll(String key)
hgetAll in interface HashCommandspublic Set<byte[]> hkeys(byte[] key)
hkeys in interface HashBinaryCommandspublic List<byte[]> hvals(byte[] key)
hvals in interface HashBinaryCommandspublic Map<byte[],byte[]> hgetAll(byte[] key)
hgetAll in interface HashBinaryCommandspublic String hrandfield(String key)
hrandfield in interface HashCommandspublic List<String> hrandfield(String key, long count)
hrandfield in interface HashCommandspublic Map<String,String> hrandfieldWithValues(String key, long count)
hrandfieldWithValues in interface HashCommandspublic ScanResult<Map.Entry<String,String>> hscan(String key, String cursor, ScanParams params)
hscan in interface HashCommandspublic long hstrlen(String key, String field)
hstrlen in interface HashCommandspublic byte[] hrandfield(byte[] key)
hrandfield in interface HashBinaryCommandspublic List<byte[]> hrandfield(byte[] key, long count)
hrandfield in interface HashBinaryCommandspublic Map<byte[],byte[]> hrandfieldWithValues(byte[] key, long count)
hrandfieldWithValues in interface HashBinaryCommandspublic ScanResult<Map.Entry<byte[],byte[]>> hscan(byte[] key, byte[] cursor, ScanParams params)
hscan in interface HashBinaryCommandspublic long hstrlen(byte[] key,
byte[] field)
hstrlen in interface HashBinaryCommandspublic long sadd(String key, String... members)
SetCommandsTime complexity O(1)
sadd in interface SetCommandspublic Set<String> smembers(String key)
SetCommandsSINTER.
Time complexity O(N)
smembers in interface SetCommandspublic long srem(String key, String... members)
SetCommandsTime complexity O(1)
srem in interface SetCommandspublic String spop(String key)
SetCommands
The SetCommands.srandmember(String) command does a similar work but the returned element is
not removed from the Set.
Time complexity O(1)
spop in interface SetCommandspublic Set<String> spop(String key, long count)
SetCommandsSetCommands.spop(String) pops a single member from the set.
In this command, the reply will consist of up to count members, depending on the set's cardinality.
The SetCommands.srandmember(String) command does a similar work but the returned element is
not removed from the Set.
Time complexity O(N), where N is the value of the passed count
spop in interface SetCommandspublic long scard(String key)
SetCommandsscard in interface SetCommandspublic boolean sismember(String key, String member)
SetCommandsTime complexity O(1)
sismember in interface SetCommandstrue if the element is a member of the set, false otherwisepublic List<Boolean> smismember(String key, String... members)
SetCommandsTime complexity O(N) where N is the number of elements being checked for membership
smismember in interface SetCommandspublic long sadd(byte[] key,
byte[]... members)
sadd in interface SetBinaryCommandspublic Set<byte[]> smembers(byte[] key)
smembers in interface SetBinaryCommandspublic long srem(byte[] key,
byte[]... members)
srem in interface SetBinaryCommandspublic byte[] spop(byte[] key)
spop in interface SetBinaryCommandspublic Set<byte[]> spop(byte[] key, long count)
spop in interface SetBinaryCommandspublic long scard(byte[] key)
scard in interface SetBinaryCommandspublic boolean sismember(byte[] key,
byte[] member)
sismember in interface SetBinaryCommandspublic List<Boolean> smismember(byte[] key, byte[]... members)
smismember in interface SetBinaryCommandspublic String srandmember(String key)
SetCommands
The SPOP command does a similar work but the returned element
is popped (removed) from the Set.
Time complexity O(1)
srandmember in interface SetCommandspublic List<String> srandmember(String key, int count)
SetCommands
The SPOP command does a similar work but the returned element
is popped (removed) from the Set.
Time complexity O(1)
srandmember in interface SetCommandscount - if positive, return an array of distinct elements.
If negative the behavior changes and the command is allowed to
return the same element multiple timespublic ScanResult<String> sscan(String key, String cursor, ScanParams params)
sscan in interface SetCommandspublic byte[] srandmember(byte[] key)
srandmember in interface SetBinaryCommandspublic List<byte[]> srandmember(byte[] key, int count)
srandmember in interface SetBinaryCommandspublic ScanResult<byte[]> sscan(byte[] key, byte[] cursor, ScanParams params)
sscan in interface SetBinaryCommandspublic Set<String> sdiff(String... keys)
SetCommandskeys
Example:
key1 = [x, a, b, c] key2 = [c] key3 = [a, d] SDIFF key1,key2,key3 => [x, b]Non existing keys are considered like empty sets.
Time complexity O(N) with N being the total number of elements of all the sets
sdiff in interface SetCommandskeys - group of setspublic long sdiffstore(String dstkey, String... keys)
SetCommandsSDIFF but instead of being
returned the resulting set is stored in dstkey.sdiffstore in interface SetCommandskeys - group of setspublic Set<String> sinter(String... keys)
SetCommandsLRANGE the result is sent to
the connection as a multi-bulk reply (see the protocol specification for more information). If
just a single key is specified, then this command produces the same result as
SMEMBERS. Actually SMEMBERS is just syntax sugar for SINTER.
Non existing keys are considered like empty sets, so if one of the keys is missing an empty set is returned (since the intersection with an empty set always is an empty set).
Time complexity O(N*M) worst case where N is the cardinality of the smallest set and M the number of sets
sinter in interface SetCommandskeys - group of setspublic long sinterstore(String dstkey, String... keys)
SetCommandsSINTER but instead of being
returned the resulting set is stored as dstkey.
Time complexity O(N*M) worst case where N is the cardinality of the smallest set and M the number of sets
sinterstore in interface SetCommandskeys - group of setspublic long sintercard(String... keys)
SetCommandsSINTER but instead of returning
the result set, it returns just the cardinality of the result. LIMIT defaults to 0 and means unlimited
Time complexity O(N*M) worst case where N is the cardinality of the smallest
sintercard in interface SetCommandskeys - group of setspublic long sintercard(int limit,
String... keys)
SetCommandsSINTER but instead of returning
the result set, it returns just the cardinality of the result.
Time complexity O(N*M) worst case where N is the cardinality of the smallest
sintercard in interface SetCommandslimit - If the intersection cardinality reaches limit partway through the computation,
the algorithm will exit and yield limit as the cardinality.keys - group of setspublic Set<String> sunion(String... keys)
SetCommandsLRANGE the result is sent to the
connection as a multi-bulk reply (see the protocol specification for more information). If just
a single key is specified, then this command produces the same result as
SMEMBERS.
Non existing keys are considered like empty sets.
Time complexity O(N) where N is the total number of elements in all the provided sets
sunion in interface SetCommandskeys - group of setspublic long sunionstore(String dstkey, String... keys)
SetCommandsSUNION but instead of being
returned the resulting set is stored as dstkey. Any existing value in dstkey will be
over-written.
Time complexity O(N) where N is the total number of elements in all the provided sets
sunionstore in interface SetCommandskeys - group of setspublic long smove(String srckey, String dstkey, String member)
SetCommandsIf the source set does not exist or does not contain the specified element no operation is performed and zero is returned, otherwise the element is removed from the source set and added to the destination set. On success one is returned, even if the element was already present in the destination set.
An error is raised if the source or destination keys contain a non Set value.
Time complexity O(1)
smove in interface SetCommandspublic Set<byte[]> sdiff(byte[]... keys)
sdiff in interface SetBinaryCommandspublic long sdiffstore(byte[] dstkey,
byte[]... keys)
sdiffstore in interface SetBinaryCommandspublic Set<byte[]> sinter(byte[]... keys)
sinter in interface SetBinaryCommandspublic long sinterstore(byte[] dstkey,
byte[]... keys)
sinterstore in interface SetBinaryCommandspublic long sintercard(byte[]... keys)
SetBinaryCommandsSINTER but instead of returning
the result set, it returns just the cardinality of the result. LIMIT defaults to 0 and means unlimited
Time complexity O(N*M) worst case where N is the cardinality of the smallest
sintercard in interface SetBinaryCommandspublic long sintercard(int limit,
byte[]... keys)
SetBinaryCommandsSINTER but instead of returning
the result set, it returns just the cardinality of the result.
Time complexity O(N*M) worst case where N is the cardinality of the smallest
sintercard in interface SetBinaryCommandslimit - If the intersection cardinality reaches limit partway through the computation,
the algorithm will exit and yield limit as the cardinality.public Set<byte[]> sunion(byte[]... keys)
sunion in interface SetBinaryCommandspublic long sunionstore(byte[] dstkey,
byte[]... keys)
sunionstore in interface SetBinaryCommandspublic long smove(byte[] srckey,
byte[] dstkey,
byte[] member)
smove in interface SetBinaryCommandspublic long zadd(String key, double score, String member)
SortedSetCommandsThe score value can be the string representation of a double precision floating point number.
Time complexity O(log(N)) with N being the number of elements in the sorted set
zadd in interface SortedSetCommandspublic long zadd(String key, double score, String member, ZAddParams params)
SortedSetCommandsZADD but can be used with optional params.zadd in interface SortedSetCommandsparams - ZAddParamsSortedSetCommands.zadd(String, double, String)public long zadd(String key, Map<String,Double> scoreMembers)
SortedSetCommandsZADD but for multiple members.zadd in interface SortedSetCommandsSortedSetCommands.zadd(String, double, String)public long zadd(String key, Map<String,Double> scoreMembers, ZAddParams params)
SortedSetCommandsZADD but can be used with optional params,
and fits for multiple members.zadd in interface SortedSetCommandsparams - ZAddParamsSortedSetCommands.zadd(String, double, String)public Double zaddIncr(String key, double score, String member, ZAddParams params)
SortedSetCommandsThe score value should be the string representation of a numeric value, and accepts double precision floating point numbers. It is possible to provide a negative value to decrement the score.
Time complexity O(log(N)) with N being the number of elements in the sorted set
zaddIncr in interface SortedSetCommandsparams - ZAddParamspublic long zadd(byte[] key,
double score,
byte[] member)
zadd in interface SortedSetBinaryCommandspublic long zadd(byte[] key,
double score,
byte[] member,
ZAddParams params)
zadd in interface SortedSetBinaryCommandspublic long zadd(byte[] key,
Map<byte[],Double> scoreMembers)
zadd in interface SortedSetBinaryCommandspublic long zadd(byte[] key,
Map<byte[],Double> scoreMembers,
ZAddParams params)
zadd in interface SortedSetBinaryCommandspublic Double zaddIncr(byte[] key, double score, byte[] member, ZAddParams params)
zaddIncr in interface SortedSetBinaryCommandspublic long zrem(String key, String... members)
SortedSetCommandsTime complexity O(log(N)) with N being the number of elements in the sorted set
zrem in interface SortedSetCommandspublic double zincrby(String key, double increment, String member)
SortedSetCommandsThe score value can be the string representation of a double precision floating point number. It's possible to provide a negative value to perform a decrement.
For an introduction to sorted sets check the Introduction to Redis data types page.
Time complexity O(log(N)) with N being the number of elements in the sorted set
zincrby in interface SortedSetCommandspublic Double zincrby(String key, double increment, String member, ZIncrByParams params)
SortedSetCommandsZINCRBY but can be used with optionals params.zincrby in interface SortedSetCommandsparams - ZIncrByParamsSortedSetCommands.zincrby(String, double, String)public Long zrank(String key, String member)
SortedSetCommandsWhen the given member does not exist in the sorted set, the special value 'nil' is returned. The returned rank (or index) of the member is 0-based for both commands.
Time complexity O(log(N))
zrank in interface SortedSetCommandspublic Long zrevrank(String key, String member)
SortedSetCommandsWhen the given member does not exist in the sorted set, the special value 'nil' is returned. The returned rank (or index) of the member is 0-based for both commands.
Time complexity O(log(N))
zrevrank in interface SortedSetCommandspublic long zrem(byte[] key,
byte[]... members)
zrem in interface SortedSetBinaryCommandspublic double zincrby(byte[] key,
double increment,
byte[] member)
zincrby in interface SortedSetBinaryCommandspublic Double zincrby(byte[] key, double increment, byte[] member, ZIncrByParams params)
zincrby in interface SortedSetBinaryCommandspublic Long zrank(byte[] key, byte[] member)
zrank in interface SortedSetBinaryCommandspublic Long zrevrank(byte[] key, byte[] member)
zrevrank in interface SortedSetBinaryCommandspublic String zrandmember(String key)
SortedSetCommandsTime complexity O(N) where N is the number of elements returned
zrandmember in interface SortedSetCommandspublic List<String> zrandmember(String key, long count)
SortedSetCommandsZCARD), whichever is lower.
Time complexity O(N) where N is the number of elements returned
zrandmember in interface SortedSetCommandscount - choose up to count elementspublic List<Tuple> zrandmemberWithScores(String key, long count)
SortedSetCommandsZRANDMEMBER but the replay will
include the scores with the result.zrandmemberWithScores in interface SortedSetCommandscount - choose up to count elementsSortedSetCommands.zrandmember(String, long)public long zcard(String key)
SortedSetCommandsTime complexity O(1)
zcard in interface SortedSetCommandspublic Double zscore(String key, String member)
SortedSetCommandsTime complexity O(1)
zscore in interface SortedSetCommandspublic List<Double> zmscore(String key, String... members)
SortedSetCommandsTime complexity O(N) where N is the number of members being requested
zmscore in interface SortedSetCommandspublic byte[] zrandmember(byte[] key)
zrandmember in interface SortedSetBinaryCommandspublic List<byte[]> zrandmember(byte[] key, long count)
zrandmember in interface SortedSetBinaryCommandspublic List<Tuple> zrandmemberWithScores(byte[] key, long count)
zrandmemberWithScores in interface SortedSetBinaryCommandspublic long zcard(byte[] key)
zcard in interface SortedSetBinaryCommandspublic Double zscore(byte[] key, byte[] member)
zscore in interface SortedSetBinaryCommandspublic List<Double> zmscore(byte[] key, byte[]... members)
zmscore in interface SortedSetBinaryCommandspublic Tuple zpopmax(String key)
SortedSetCommandsTime complexity O(log(N)) with N being the number of elements in the sorted set
zpopmax in interface SortedSetCommandspublic List<Tuple> zpopmax(String key, int count)
SortedSetCommandsTime complexity O(log(N)*M) with N being the number of elements in the sorted set, and M being the number of elements popped.
zpopmax in interface SortedSetCommandscount - the number of elements to poppublic Tuple zpopmin(String key)
SortedSetCommandsTime complexity O(log(N)) with N being the number of elements in the sorted set
zpopmin in interface SortedSetCommandspublic List<Tuple> zpopmin(String key, int count)
SortedSetCommandsTime complexity O(log(N)*M) with N being the number of elements in the sorted set, and M being the number of elements popped.
zpopmin in interface SortedSetCommandscount - the number of elements to poppublic long zcount(String key, double min, double max)
SortedSetCommandsTime complexity O(log(N)) with N being the number of elements in the sorted set.
zcount in interface SortedSetCommandskey - the key to querymin - minimum scoremax - maximum scorepublic long zcount(String key, String min, String max)
SortedSetCommandsZCOUNT but with exclusive range.zcount in interface SortedSetCommandsSortedSetCommands.zcount(String, double, double)public Tuple zpopmax(byte[] key)
zpopmax in interface SortedSetBinaryCommandspublic List<Tuple> zpopmax(byte[] key, int count)
zpopmax in interface SortedSetBinaryCommandspublic Tuple zpopmin(byte[] key)
zpopmin in interface SortedSetBinaryCommandspublic List<Tuple> zpopmin(byte[] key, int count)
zpopmin in interface SortedSetBinaryCommandspublic long zcount(byte[] key,
double min,
double max)
zcount in interface SortedSetBinaryCommandspublic long zcount(byte[] key,
byte[] min,
byte[] max)
zcount in interface SortedSetBinaryCommandspublic List<String> zrange(String key, long start, long stop)
SortedSetCommandsTime complexity O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements returned.
zrange in interface SortedSetCommandskey - the key to querystart - the minimum indexstop - the maximum indexpublic List<String> zrevrange(String key, long start, long stop)
SortedSetCommandsTime complexity O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements returned.
zrevrange in interface SortedSetCommandskey - the key to querystart - the minimum indexstop - the maximum indexpublic List<Tuple> zrangeWithScores(String key, long start, long stop)
SortedSetCommandszrangeWithScores in interface SortedSetCommandskey - the key to querystart - the minimum indexstop - the maximum indexpublic List<Tuple> zrevrangeWithScores(String key, long start, long stop)
SortedSetCommandsZREVRANGE but the reply will
include the scores of the returned elements.zrevrangeWithScores in interface SortedSetCommandskey - the key to querystart - the minimum indexstop - the maximum indexSortedSetCommands.zrevrange(String, long, long)public List<String> zrange(String key, ZRangeParams zRangeParams)
SortedSetCommandsZRANGE but can be used with additional params.zrange in interface SortedSetCommandskey - the key to queryzRangeParams - ZRangeParamsSortedSetCommands.zrange(String, long, long)public List<Tuple> zrangeWithScores(String key, ZRangeParams zRangeParams)
SortedSetCommandsZRANGE but can be used with additional params.zrangeWithScores in interface SortedSetCommandskey - the key to queryzRangeParams - ZRangeParamsSortedSetCommands.zrangeWithScores(String, long, long)public long zrangestore(String dest, String src, ZRangeParams zRangeParams)
SortedSetCommandsZRANGE but stores the result in dest.zrangestore in interface SortedSetCommandsdest - the storing keysrc - the key to queryzRangeParams - ZRangeParamsSortedSetCommands.zrange(String, ZRangeParams)public List<String> zrangeByScore(String key, double min, double max)
SortedSetCommandsTime complexity O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned.
zrangeByScore in interface SortedSetCommandskey - the key to querymin - minimum scoremax - maximum scorepublic List<String> zrangeByScore(String key, String min, String max)
SortedSetCommandsZRANGE but with exclusive range.zrangeByScore in interface SortedSetCommandsSortedSetCommands.zrangeByScore(String, double, double)public List<String> zrevrangeByScore(String key, double max, double min)
SortedSetCommandsThe elements having the same score are returned in reverse lexicographical order.
Time complexity O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned.
zrevrangeByScore in interface SortedSetCommandskey - the key to querymax - maximum scoremin - minimum scorepublic List<String> zrangeByScore(String key, double min, double max, int offset, int count)
SortedSetCommandsZRANGE but with exclusive range.zrangeByScore in interface SortedSetCommandskey - the key to querymin - minimum scoremax - maximum scoreoffset - the first index of the sub-rangecount - count of the sub-range. A negative count returns all elements from the offsetSortedSetCommands.zrangeByScore(String, double, double)public List<String> zrevrangeByScore(String key, String max, String min)
SortedSetCommandsZREVRANGE but with exclusive range.zrevrangeByScore in interface SortedSetCommandsSortedSetCommands.zrevrangeByScore(String, double, double)public List<String> zrangeByScore(String key, String min, String max, int offset, int count)
SortedSetCommandsZRANGE but with limit option,zrangeByScore in interface SortedSetCommandskey - the key to querymin - minimum scoremax - maximum scoreoffset - the first index of the sub-rangecount - count of the sub-range. A negative count returns all elements from the offsetand with exclusive range.public List<String> zrevrangeByScore(String key, double max, double min, int offset, int count)
SortedSetCommandsZRANGE but with limit option,zrevrangeByScore in interface SortedSetCommandskey - the key to querymax - maximum scoremin - minimum scoreoffset - the first index of the sub-rangecount - count of the sub-range. A negative count returns all elements from the offsetSortedSetCommands.zrevrangeByScore(String, double, double)public List<Tuple> zrangeByScoreWithScores(String key, double min, double max)
SortedSetCommandsZRANGE but return with scores.zrangeByScoreWithScores in interface SortedSetCommandskey - the key to querymin - minimum scoremax - maximum scorereturn both the element and its score, instead of the element alone.public List<Tuple> zrevrangeByScoreWithScores(String key, double max, double min)
SortedSetCommandsZREVRANGE but return with scores.zrevrangeByScoreWithScores in interface SortedSetCommandskey - the key to querymax - maximum scoremin - minimum scorereturn both the element and its score, instead of the element alone.public List<Tuple> zrangeByScoreWithScores(String key, double min, double max, int offset, int count)
SortedSetCommandsZRANGE but with limit option,
and return with scores.zrangeByScoreWithScores in interface SortedSetCommandskey - the key to querymin - minimum scoremax - maximum scoreoffset - the first index of the sub-rangecount - count of the sub-range. A negative count returns all elements from the offsetSortedSetCommands.zrangeByScore(String, double, double)public List<String> zrevrangeByScore(String key, String max, String min, int offset, int count)
SortedSetCommandsZREVRANGE but with limit option,zrevrangeByScore in interface SortedSetCommandskey - the key to querymax - maximum scoremin - minimum scoreoffset - the first index of the sub-rangecount - count of the sub-range. A negative count returns all elements from the offsetand with exclusive range.public List<Tuple> zrangeByScoreWithScores(String key, String min, String max)
SortedSetCommandsZRANGE but with exclusive range,
and return with scores.zrangeByScoreWithScores in interface SortedSetCommandsSortedSetCommands.zrangeByScore(String, double, double)public List<Tuple> zrevrangeByScoreWithScores(String key, String max, String min)
SortedSetCommandsZREVRANGE but with exclusive range,
and return with scores.zrevrangeByScoreWithScores in interface SortedSetCommandsSortedSetCommands.zrevrangeByScore(String, double, double)public List<Tuple> zrangeByScoreWithScores(String key, String min, String max, int offset, int count)
SortedSetCommandsZRANGE but with exclusive range,
with limit options and return with scores.zrangeByScoreWithScores in interface SortedSetCommandskey - the key to querymin - minimum scoremax - maximum scoreoffset - the first index of the sub-rangecount - count of the sub-range. A negative count returns all elements from the offsetSortedSetCommands.zrangeByScore(String, String, String)public List<Tuple> zrevrangeByScoreWithScores(String key, double max, double min, int offset, int count)
SortedSetCommandsZREVRANGE but with
limit options and return with scores.zrevrangeByScoreWithScores in interface SortedSetCommandskey - the key to querymax - maximum scoremin - minimum scoreoffset - the first index of the sub-rangecount - count of the sub-range. A negative count returns all elements from the offsetSortedSetCommands.zrevrangeByScore(String, double, double)public List<Tuple> zrevrangeByScoreWithScores(String key, String max, String min, int offset, int count)
SortedSetCommandsZREVRANGE but with
exclusive range, with limit options and return with scores.zrevrangeByScoreWithScores in interface SortedSetCommandskey - the key to querymax - maximum scoremin - minimum scoreoffset - the first index of the sub-rangecount - count of the sub-range. A negative count returns all elements from the offsetSortedSetCommands.zrevrangeByScore(String, double, double)public List<byte[]> zrange(byte[] key, long start, long stop)
zrange in interface SortedSetBinaryCommandspublic List<byte[]> zrevrange(byte[] key, long start, long stop)
zrevrange in interface SortedSetBinaryCommandspublic List<Tuple> zrangeWithScores(byte[] key, long start, long stop)
zrangeWithScores in interface SortedSetBinaryCommandspublic List<Tuple> zrevrangeWithScores(byte[] key, long start, long stop)
zrevrangeWithScores in interface SortedSetBinaryCommandspublic List<byte[]> zrange(byte[] key, ZRangeParams zRangeParams)
zrange in interface SortedSetBinaryCommandspublic List<Tuple> zrangeWithScores(byte[] key, ZRangeParams zRangeParams)
zrangeWithScores in interface SortedSetBinaryCommandspublic long zrangestore(byte[] dest,
byte[] src,
ZRangeParams zRangeParams)
zrangestore in interface SortedSetBinaryCommandspublic List<byte[]> zrangeByScore(byte[] key, double min, double max)
zrangeByScore in interface SortedSetBinaryCommandspublic List<byte[]> zrangeByScore(byte[] key, byte[] min, byte[] max)
zrangeByScore in interface SortedSetBinaryCommandspublic List<byte[]> zrevrangeByScore(byte[] key, double max, double min)
zrevrangeByScore in interface SortedSetBinaryCommandspublic List<byte[]> zrangeByScore(byte[] key, double min, double max, int offset, int count)
zrangeByScore in interface SortedSetBinaryCommandspublic List<byte[]> zrevrangeByScore(byte[] key, byte[] max, byte[] min)
zrevrangeByScore in interface SortedSetBinaryCommandspublic List<byte[]> zrangeByScore(byte[] key, byte[] min, byte[] max, int offset, int count)
zrangeByScore in interface SortedSetBinaryCommandspublic List<byte[]> zrevrangeByScore(byte[] key, double max, double min, int offset, int count)
zrevrangeByScore in interface SortedSetBinaryCommandspublic List<Tuple> zrangeByScoreWithScores(byte[] key, double min, double max)
zrangeByScoreWithScores in interface SortedSetBinaryCommandspublic List<Tuple> zrevrangeByScoreWithScores(byte[] key, double max, double min)
zrevrangeByScoreWithScores in interface SortedSetBinaryCommandspublic List<Tuple> zrangeByScoreWithScores(byte[] key, double min, double max, int offset, int count)
zrangeByScoreWithScores in interface SortedSetBinaryCommandspublic List<byte[]> zrevrangeByScore(byte[] key, byte[] max, byte[] min, int offset, int count)
zrevrangeByScore in interface SortedSetBinaryCommandspublic List<Tuple> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max)
zrangeByScoreWithScores in interface SortedSetBinaryCommandspublic List<Tuple> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min)
zrevrangeByScoreWithScores in interface SortedSetBinaryCommandspublic List<Tuple> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max, int offset, int count)
zrangeByScoreWithScores in interface SortedSetBinaryCommandspublic List<Tuple> zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset, int count)
zrevrangeByScoreWithScores in interface SortedSetBinaryCommandspublic List<Tuple> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min, int offset, int count)
zrevrangeByScoreWithScores in interface SortedSetBinaryCommandspublic long zremrangeByRank(String key, long start, long stop)
SortedSetCommandsTime complexity O(log(N))+O(M) with N being the number of elements in the sorted set and M the number of elements removed by the operation.
zremrangeByRank in interface SortedSetCommandspublic long zremrangeByScore(String key, double min, double max)
SortedSetCommandsTime complexity O(log(N))+O(M) with N being the number of elements in the sorted set and M the number of elements removed by the operation.
zremrangeByScore in interface SortedSetCommandsmin - minimum score to removemax - maximum score to removepublic long zremrangeByScore(String key, String min, String max)
SortedSetCommandsZREMRANGE but with limit option.zremrangeByScore in interface SortedSetCommandsSortedSetCommands.zremrangeByScore(String, double, double)public long zremrangeByRank(byte[] key,
long start,
long stop)
zremrangeByRank in interface SortedSetBinaryCommandspublic long zremrangeByScore(byte[] key,
double min,
double max)
zremrangeByScore in interface SortedSetBinaryCommandspublic long zremrangeByScore(byte[] key,
byte[] min,
byte[] max)
zremrangeByScore in interface SortedSetBinaryCommandspublic long zlexcount(String key, String min, String max)
SortedSetCommandsTime complexity O(log(N)) with N being the number of elements in the sorted set.
zlexcount in interface SortedSetCommandsmin - minimum valuemax - maximum valuepublic List<String> zrangeByLex(String key, String min, String max)
SortedSetCommandsTime complexity O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned.
zrangeByLex in interface SortedSetCommandsmin - minimum valuemax - maximum valuepublic List<String> zrangeByLex(String key, String min, String max, int offset, int count)
SortedSetCommandsZRANGE but with limit option.zrangeByLex in interface SortedSetCommandsmin - minimum valuemax - maximum valueoffset - the first index of the sub-rangecount - count of the sub-range. A negative count returns all elements from the offsetSortedSetCommands.zrangeByLex(String, String, String)public List<String> zrevrangeByLex(String key, String max, String min)
SortedSetCommandsTime complexity O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned.
zrevrangeByLex in interface SortedSetCommandsmax - maximum valuemin - minimum valuepublic List<String> zrevrangeByLex(String key, String max, String min, int offset, int count)
SortedSetCommandsZRANGE but with limit option.zrevrangeByLex in interface SortedSetCommandsmax - maximum valuemin - minimum valueoffset - the first index of the sub-rangecount - count of the sub-range. A negative count returns all elements from the offsetSortedSetCommands.zrevrangeByLex(String, String, String)public long zremrangeByLex(String key, String min, String max)
SortedSetCommandsTime complexity O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements removed by the operation.
zremrangeByLex in interface SortedSetCommandsmin - minimum value to removemax - maximum value to removepublic long zlexcount(byte[] key,
byte[] min,
byte[] max)
zlexcount in interface SortedSetBinaryCommandspublic List<byte[]> zrangeByLex(byte[] key, byte[] min, byte[] max)
zrangeByLex in interface SortedSetBinaryCommandspublic List<byte[]> zrangeByLex(byte[] key, byte[] min, byte[] max, int offset, int count)
zrangeByLex in interface SortedSetBinaryCommandspublic List<byte[]> zrevrangeByLex(byte[] key, byte[] max, byte[] min)
zrevrangeByLex in interface SortedSetBinaryCommandspublic List<byte[]> zrevrangeByLex(byte[] key, byte[] max, byte[] min, int offset, int count)
zrevrangeByLex in interface SortedSetBinaryCommandspublic long zremrangeByLex(byte[] key,
byte[] min,
byte[] max)
zremrangeByLex in interface SortedSetBinaryCommandspublic ScanResult<Tuple> zscan(String key, String cursor, ScanParams params)
zscan in interface SortedSetCommandspublic ScanResult<Tuple> zscan(byte[] key, byte[] cursor, ScanParams params)
zscan in interface SortedSetBinaryCommandspublic KeyedZSetElement bzpopmax(double timeout, String... keys)
SortedSetCommandsZPOPMAXbzpopmax in interface SortedSetCommandstimeout - specifying the maximum number of seconds to block. A timeout of zero can
be used to block indefinitely.public KeyedZSetElement bzpopmin(double timeout, String... keys)
SortedSetCommandsZPOPMINbzpopmin in interface SortedSetCommandstimeout - specifying the maximum number of seconds to block. A timeout of zero can
be used to block indefinitely.public List<byte[]> bzpopmax(double timeout, byte[]... keys)
bzpopmax in interface SortedSetBinaryCommandspublic List<byte[]> bzpopmin(double timeout, byte[]... keys)
bzpopmin in interface SortedSetBinaryCommandspublic Set<String> zdiff(String... keys)
SortedSetCommandsTime complexity O(L + (N-K)log(N)) worst case where L is the total number of elements in all the sets, N is the size of the first set, and K is the size of the result set.
zdiff in interface SortedSetCommandskeys - group of setspublic Set<Tuple> zdiffWithScores(String... keys)
SortedSetCommandszdiffWithScores in interface SortedSetCommandskeys - group of setspublic long zdiffStore(String dstkey, String... keys)
SortedSetCommandszdiffStore in interface SortedSetCommandskeys - group of setspublic Set<byte[]> zdiff(byte[]... keys)
zdiff in interface SortedSetBinaryCommandspublic Set<Tuple> zdiffWithScores(byte[]... keys)
zdiffWithScores in interface SortedSetBinaryCommandspublic long zdiffStore(byte[] dstkey,
byte[]... keys)
zdiffStore in interface SortedSetBinaryCommandspublic long zinterstore(String dstkey, String... sets)
SortedSetCommandszinterstore in interface SortedSetCommandssets - group of setspublic long zinterstore(String dstkey, ZParams params, String... sets)
SortedSetCommandszinterstore in interface SortedSetCommandsparams - ZParamssets - group of setspublic Set<String> zinter(ZParams params, String... keys)
SortedSetCommandsTime complexity O(N*K)+O(M*log(M)) worst case with N being the smallest input sorted set, K being the number of input sorted sets and M being the number of elements in the resulting sorted set.
zinter in interface SortedSetCommandsparams - ZParamskeys - group of setspublic Set<Tuple> zinterWithScores(ZParams params, String... keys)
SortedSetCommandszinterWithScores in interface SortedSetCommandsparams - ZParamskeys - group of setspublic long zinterstore(byte[] dstkey,
byte[]... sets)
zinterstore in interface SortedSetBinaryCommandspublic long zinterstore(byte[] dstkey,
ZParams params,
byte[]... sets)
zinterstore in interface SortedSetBinaryCommandspublic long zintercard(byte[]... keys)
SortedSetBinaryCommandsZINTER, but
instead of returning the result set, it returns just the cardinality of the result.
Time complexity O(N*K) worst case with N being the smallest input sorted set, K being the number of input sorted sets
zintercard in interface SortedSetBinaryCommandskeys - group of setsSortedSetBinaryCommands#zinter(ZParams, byte[]...)public long zintercard(long limit,
byte[]... keys)
SortedSetBinaryCommandsZINTER, but
instead of returning the result set, it returns just the cardinality of the result.
Time complexity O(N*K) worst case with N being the smallest input sorted set, K being the number of input sorted sets
zintercard in interface SortedSetBinaryCommandslimit - If the intersection cardinality reaches limit partway through the computation,
the algorithm will exit and yield limit as the cardinalitykeys - group of setsSortedSetBinaryCommands#zinter(ZParams, byte[]...)public long zintercard(String... keys)
SortedSetCommandsZINTER, but
instead of returning the result set, it returns just the cardinality of the result.
Time complexity O(N*K) worst case with N being the smallest input sorted set, K being the number of input sorted sets
zintercard in interface SortedSetCommandskeys - group of setsSortedSetCommands.zinter(ZParams, String...)public long zintercard(long limit,
String... keys)
SortedSetCommandsZINTER, but
instead of returning the result set, it returns just the cardinality of the result.
Time complexity O(N*K) worst case with N being the smallest input sorted set, K being the number of input sorted sets
zintercard in interface SortedSetCommandslimit - If the intersection cardinality reaches limit partway through the computation,
the algorithm will exit and yield limit as the cardinalitykeys - group of setsSortedSetCommands.zinter(ZParams, String...)public Set<byte[]> zinter(ZParams params, byte[]... keys)
zinter in interface SortedSetBinaryCommandspublic Set<Tuple> zinterWithScores(ZParams params, byte[]... keys)
zinterWithScores in interface SortedSetBinaryCommandspublic Set<String> zunion(ZParams params, String... keys)
SortedSetCommandsTime complexity O(N)+O(M log(M)) with N being the sum of the sizes of the input sorted sets, and M being the number of elements in the resulting sorted set.
zunion in interface SortedSetCommandsparams - ZParamskeys - group of setspublic Set<Tuple> zunionWithScores(ZParams params, String... keys)
SortedSetCommandszunionWithScores in interface SortedSetCommandsparams - ZParamskeys - group of setspublic long zunionstore(String dstkey, String... sets)
SortedSetCommandszunionstore in interface SortedSetCommandssets - group of setspublic long zunionstore(String dstkey, ZParams params, String... sets)
SortedSetCommandszunionstore in interface SortedSetCommandsparams - ZParamssets - group of setspublic Set<byte[]> zunion(ZParams params, byte[]... keys)
zunion in interface SortedSetBinaryCommandspublic Set<Tuple> zunionWithScores(ZParams params, byte[]... keys)
zunionWithScores in interface SortedSetBinaryCommandspublic long zunionstore(byte[] dstkey,
byte[]... sets)
zunionstore in interface SortedSetBinaryCommandspublic long zunionstore(byte[] dstkey,
ZParams params,
byte[]... sets)
zunionstore in interface SortedSetBinaryCommandspublic KeyValue<String,List<Tuple>> zmpop(SortedSetOption option, String... keys)
zmpop in interface SortedSetCommandspublic KeyValue<String,List<Tuple>> zmpop(SortedSetOption option, int count, String... keys)
zmpop in interface SortedSetCommandspublic KeyValue<String,List<Tuple>> bzmpop(long timeout, SortedSetOption option, String... keys)
bzmpop in interface SortedSetCommandspublic KeyValue<String,List<Tuple>> bzmpop(long timeout, SortedSetOption option, int count, String... keys)
bzmpop in interface SortedSetCommandspublic KeyValue<byte[],List<Tuple>> zmpop(SortedSetOption option, byte[]... keys)
zmpop in interface SortedSetBinaryCommandspublic KeyValue<byte[],List<Tuple>> zmpop(SortedSetOption option, int count, byte[]... keys)
zmpop in interface SortedSetBinaryCommandspublic KeyValue<byte[],List<Tuple>> bzmpop(long timeout, SortedSetOption option, byte[]... keys)
bzmpop in interface SortedSetBinaryCommandspublic KeyValue<byte[],List<Tuple>> bzmpop(long timeout, SortedSetOption option, int count, byte[]... keys)
bzmpop in interface SortedSetBinaryCommandspublic long geoadd(String key, double longitude, double latitude, String member)
GeoCommandsTime complexity: O(log(N)) where N is the number of elements in the sorted set.
geoadd in interface GeoCommandspublic long geoadd(String key, Map<String,GeoCoordinate> memberCoordinateMap)
GeoCommandsTime complexity: O(log(N)) for each item added, where N is the number of elements in the sorted set.
geoadd in interface GeoCommandsmemberCoordinateMap - Members names with their geo coordinatespublic long geoadd(String key, GeoAddParams params, Map<String,GeoCoordinate> memberCoordinateMap)
GeoCommandsTime complexity: O(log(N)) for each item added
geoadd in interface GeoCommandsparams - Additional optionsmemberCoordinateMap - Members names with their geo coordinatespublic Double geodist(String key, String member1, String member2)
GeoCommandsTime complexity: O(log(N))
geodist in interface GeoCommandspublic Double geodist(String key, String member1, String member2, GeoUnit unit)
GeoCommandsTime complexity: O(log(N))
geodist in interface GeoCommandsunit - can be M, KM, MI or FT can M, KM, MI or FTpublic List<String> geohash(String key, String... members)
GeoCommandsTime complexity: O(log(N)) for each member requested
geohash in interface GeoCommandspublic List<GeoCoordinate> geopos(String key, String... members)
GeoCommandsTime complexity: O(N) where N is the number of members requested.
geopos in interface GeoCommandspublic long geoadd(byte[] key,
double longitude,
double latitude,
byte[] member)
geoadd in interface GeoBinaryCommandspublic long geoadd(byte[] key,
Map<byte[],GeoCoordinate> memberCoordinateMap)
geoadd in interface GeoBinaryCommandspublic long geoadd(byte[] key,
GeoAddParams params,
Map<byte[],GeoCoordinate> memberCoordinateMap)
geoadd in interface GeoBinaryCommandspublic Double geodist(byte[] key, byte[] member1, byte[] member2)
geodist in interface GeoBinaryCommandspublic Double geodist(byte[] key, byte[] member1, byte[] member2, GeoUnit unit)
geodist in interface GeoBinaryCommandspublic List<byte[]> geohash(byte[] key, byte[]... members)
geohash in interface GeoBinaryCommandspublic List<GeoCoordinate> geopos(byte[] key, byte[]... members)
geopos in interface GeoBinaryCommandspublic List<GeoRadiusResponse> georadius(String key, double longitude, double latitude, double radius, GeoUnit unit)
GeoCommandsTime complexity: O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.
georadius in interface GeoCommandslongitude - of the center pointlatitude - of the center pointradius - of the areaunit - can be M, KM, MI or FTpublic List<GeoRadiusResponse> georadiusReadonly(String key, double longitude, double latitude, double radius, GeoUnit unit)
GeoCommandsGEORADIUS,
Time complexity: O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.
georadiusReadonly in interface GeoCommandslongitude - of the center pointlatitude - of the center pointradius - of the areaunit - can be M, KM, MI or FTGeoCommands.georadius(String, double, double, double, GeoUnit)public List<GeoRadiusResponse> georadius(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
GeoCommandsGeoRadiusParam:
WITHDIST: Also return the distance of the returned items from the specified center.
The distance is returned in the same unit as the unit specified as the radius argument of the command.
WITHCOORD: Also return the longitude,latitude coordinates of the matching items.
WITHHASH: Also return the raw geohash-encoded sorted set score of the item, in the form of a 52
bit unsigned integer. This is only useful for low level hacks or debugging and is otherwise of
little interest for the general user.
Time complexity: O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.
georadius in interface GeoCommandslongitude - of the center pointlatitude - of the center pointradius - of the areaunit - can be M, KM, MI or FTparam - GeoRadiusParampublic List<GeoRadiusResponse> georadiusReadonly(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
GeoCommandsGEORADIUS,
Time complexity: O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.
georadiusReadonly in interface GeoCommandslongitude - of the center pointlatitude - of the center pointradius - of the areaunit - can be M, KM, MI or FTparam - GeoRadiusParamGeoCommands.georadius(String, double, double, double, GeoUnit, GeoRadiusParam)public List<GeoRadiusResponse> georadiusByMember(String key, String member, double radius, GeoUnit unit)
GeoCommandsGEORADIUS
with the sole difference that instead of taking, as the center of the area to query, a longitude
and latitude value, it takes the name of a member already existing inside the geospatial index
represented by the sorted set.
Time complexity: O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.
georadiusByMember in interface GeoCommandsmember - represents the center of the arearadius - of the areaunit - can be M, KM, MI or FTpublic List<GeoRadiusResponse> georadiusByMemberReadonly(String key, String member, double radius, GeoUnit unit)
GeoCommandsGEORADIUSBYMEMBER
Time complexity: O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.
georadiusByMemberReadonly in interface GeoCommandsmember - represents the center of the arearadius - of the areaunit - can be M, KM, MI or FTpublic List<GeoRadiusResponse> georadiusByMember(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param)
GeoCommandsGEORADIUS
with the sole difference that instead of taking, as the center of the area to query, a longitude
and latitude value, it takes the name of a member already existing inside the geospatial index
represented by the sorted set.
Time complexity: O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.
georadiusByMember in interface GeoCommandsmember - represents the center of the arearadius - of the areaunit - can be M, KM, MI or FTparam - GeoRadiusParampublic List<GeoRadiusResponse> georadiusByMemberReadonly(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param)
GeoCommandsGEORADIUSBYMEMBER
Time complexity: O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.
georadiusByMemberReadonly in interface GeoCommandsmember - represents the center of the arearadius - of the areaunit - can be M, KM, MI or FTparam - GeoRadiusParampublic long georadiusStore(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam)
GeoCommandsGEORADIUS
but storing the results at the destination key (provided with storeParam).
Time complexity: O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.
georadiusStore in interface GeoCommandslongitude - of the center pointlatitude - of the center pointradius - of the areaunit - can be M, KM, MI or FTparam - GeoRadiusParamstoreParam - GeoRadiusStoreParampublic long georadiusByMemberStore(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam)
GeoCommandsGEORADIUSBYMEMBER
but storing the results at the destination key (provided with storeParam).
Time complexity: O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.
georadiusByMemberStore in interface GeoCommandsmember - represents the center of the arearadius - of the areaunit - can be M, KM, MI or FTparam - GeoRadiusParamstoreParam - GeoRadiusStoreParampublic List<GeoRadiusResponse> geosearch(String key, String member, double radius, GeoUnit unit)
GeoCommands
This command can be used in place of the GEORADIUSBYMEMBER command.
Time complexity: O(N+log(M)) where N is the number of elements in the grid-aligned bounding box area around the shape provided as the filter and M is the number of items inside the shape
geosearch in interface GeoCommandsmember - represents the center of the arearadius - of the areaunit - can be M, KM, MI or FTpublic List<GeoRadiusResponse> geosearch(String key, GeoCoordinate coord, double radius, GeoUnit unit)
GeoCommands
This command can be used in place of the GEORADIUS command.
Time complexity: O(N+log(M)) where N is the number of elements in the grid-aligned bounding box area around the shape provided as the filter and M is the number of items inside the shape
geosearch in interface GeoCommandscoord - represents the center of the arearadius - of the areaunit - can be M, KM, MI or FTpublic List<GeoRadiusResponse> geosearch(String key, String member, double width, double height, GeoUnit unit)
GeoCommandsThe axis-aligned rectangle, determined by height and width, when the center point is determined by the position of the given member.
Time complexity: O(N+log(M)) where N is the number of elements in the grid-aligned bounding box area around the shape provided as the filter and M is the number of items inside the shape
geosearch in interface GeoCommandsmember - represents the center of the areawidth - of the rectangular areaheight - of the rectangular areaunit - can be M, KM, MI or FTpublic List<GeoRadiusResponse> geosearch(String key, GeoCoordinate coord, double width, double height, GeoUnit unit)
GeoCommandsThe axis-aligned rectangle, determined by height and width, when the center point is determined by the given coordinate.
Time complexity: O(N+log(M)) where N is the number of elements in the grid-aligned bounding box area around the shape provided as the filter and M is the number of items inside the shape
geosearch in interface GeoCommandscoord - represents the center pointwidth - of the rectangular areaheight - of the rectangular areaunit - can be M, KM, MI or FTpublic List<GeoRadiusResponse> geosearch(String key, GeoSearchParam params)
GeoCommandsTime complexity: O(N+log(M)) where N is the number of elements in the grid-aligned bounding box area around the shape provided as the filter and M is the number of items inside the shape
geosearch in interface GeoCommandsparams - GeoSearchParampublic long geosearchStore(String dest, String src, String member, double radius, GeoUnit unit)
GeoCommandsGEOSEARCH
but storing the results at dest.
Time complexity: O(N+log(M)) where N is the number of elements in the grid-aligned bounding box area around the shape provided as the filter and M is the number of items inside the shape
geosearchStore in interface GeoCommandssrc - the sorted set (key)member - represents the center of the arearadius - of the circular areaunit - can be M, KM, MI or FTpublic long geosearchStore(String dest, String src, GeoCoordinate coord, double radius, GeoUnit unit)
GeoCommandsGEOSEARCH
but storing the results at dest.
Time complexity: O(N+log(M)) where N is the number of elements in the grid-aligned bounding box area around the shape provided as the filter and M is the number of items inside the shape
geosearchStore in interface GeoCommandscoord - represents the center pointradius - of the circular areaunit - can be M, KM, MI or FTpublic long geosearchStore(String dest, String src, String member, double width, double height, GeoUnit unit)
GeoCommandsGEOSEARCH
but storing the results at dest.
Time complexity: O(N+log(M)) where N is the number of elements in the grid-aligned bounding box area around the shape provided as the filter and M is the number of items inside the shape
geosearchStore in interface GeoCommandsmember - represents the center of the areawidth - of the rectangular areaheight - of the rectangular areaunit - can be M, KM, MI or FTpublic long geosearchStore(String dest, String src, GeoCoordinate coord, double width, double height, GeoUnit unit)
GeoCommandsGEOSEARCH
but storing the results at dest.
Time complexity: O(N+log(M)) where N is the number of elements in the grid-aligned bounding box area around the shape provided as the filter and M is the number of items inside the shape
geosearchStore in interface GeoCommandscoord - represents the center pointwidth - of the rectangular areaheight - of the rectangular areaunit - can be M, KM, MI or FTpublic long geosearchStore(String dest, String src, GeoSearchParam params)
GeoCommandsGEOSEARCH
but storing the results at dest.
Time complexity: O(N+log(M)) where N is the number of elements in the grid-aligned bounding box area around the shape provided as the filter and M is the number of items inside the shape
geosearchStore in interface GeoCommandsparams - GeoSearchParampublic long geosearchStoreStoreDist(String dest, String src, GeoSearchParam params)
GeoCommandsGEOSEARCHSTORE
but storing the results with their destinations from the center point.
Time complexity: O(N+log(M)) where N is the number of elements in the grid-aligned bounding box area around the shape provided as the filter and M is the number of items inside the shape
geosearchStoreStoreDist in interface GeoCommandsparams - GeoSearchParampublic List<GeoRadiusResponse> georadius(byte[] key, double longitude, double latitude, double radius, GeoUnit unit)
georadius in interface GeoBinaryCommandspublic List<GeoRadiusResponse> georadiusReadonly(byte[] key, double longitude, double latitude, double radius, GeoUnit unit)
georadiusReadonly in interface GeoBinaryCommandspublic List<GeoRadiusResponse> georadius(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
georadius in interface GeoBinaryCommandspublic List<GeoRadiusResponse> georadiusReadonly(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
georadiusReadonly in interface GeoBinaryCommandspublic List<GeoRadiusResponse> georadiusByMember(byte[] key, byte[] member, double radius, GeoUnit unit)
georadiusByMember in interface GeoBinaryCommandspublic List<GeoRadiusResponse> georadiusByMemberReadonly(byte[] key, byte[] member, double radius, GeoUnit unit)
georadiusByMemberReadonly in interface GeoBinaryCommandspublic List<GeoRadiusResponse> georadiusByMember(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param)
georadiusByMember in interface GeoBinaryCommandspublic List<GeoRadiusResponse> georadiusByMemberReadonly(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param)
georadiusByMemberReadonly in interface GeoBinaryCommandspublic long georadiusStore(byte[] key,
double longitude,
double latitude,
double radius,
GeoUnit unit,
GeoRadiusParam param,
GeoRadiusStoreParam storeParam)
georadiusStore in interface GeoBinaryCommandspublic long georadiusByMemberStore(byte[] key,
byte[] member,
double radius,
GeoUnit unit,
GeoRadiusParam param,
GeoRadiusStoreParam storeParam)
georadiusByMemberStore in interface GeoBinaryCommandspublic List<GeoRadiusResponse> geosearch(byte[] key, byte[] member, double radius, GeoUnit unit)
geosearch in interface GeoBinaryCommandspublic List<GeoRadiusResponse> geosearch(byte[] key, GeoCoordinate coord, double radius, GeoUnit unit)
geosearch in interface GeoBinaryCommandspublic List<GeoRadiusResponse> geosearch(byte[] key, byte[] member, double width, double height, GeoUnit unit)
geosearch in interface GeoBinaryCommandspublic List<GeoRadiusResponse> geosearch(byte[] key, GeoCoordinate coord, double width, double height, GeoUnit unit)
geosearch in interface GeoBinaryCommandspublic List<GeoRadiusResponse> geosearch(byte[] key, GeoSearchParam params)
geosearch in interface GeoBinaryCommandspublic long geosearchStore(byte[] dest,
byte[] src,
byte[] member,
double radius,
GeoUnit unit)
geosearchStore in interface GeoBinaryCommandspublic long geosearchStore(byte[] dest,
byte[] src,
GeoCoordinate coord,
double radius,
GeoUnit unit)
geosearchStore in interface GeoBinaryCommandspublic long geosearchStore(byte[] dest,
byte[] src,
byte[] member,
double width,
double height,
GeoUnit unit)
geosearchStore in interface GeoBinaryCommandspublic long geosearchStore(byte[] dest,
byte[] src,
GeoCoordinate coord,
double width,
double height,
GeoUnit unit)
geosearchStore in interface GeoBinaryCommandspublic long geosearchStore(byte[] dest,
byte[] src,
GeoSearchParam params)
geosearchStore in interface GeoBinaryCommandspublic long geosearchStoreStoreDist(byte[] dest,
byte[] src,
GeoSearchParam params)
geosearchStoreStoreDist in interface GeoBinaryCommandspublic long pfadd(String key, String... elements)
pfadd in interface HyperLogLogCommandspublic String pfmerge(String destkey, String... sourcekeys)
pfmerge in interface HyperLogLogCommandspublic long pfcount(String key)
pfcount in interface HyperLogLogCommandspublic long pfcount(String... keys)
pfcount in interface HyperLogLogCommandspublic long pfadd(byte[] key,
byte[]... elements)
pfadd in interface HyperLogLogBinaryCommandspublic String pfmerge(byte[] destkey, byte[]... sourcekeys)
pfmerge in interface HyperLogLogBinaryCommandspublic long pfcount(byte[] key)
pfcount in interface HyperLogLogBinaryCommandspublic long pfcount(byte[]... keys)
pfcount in interface HyperLogLogBinaryCommandspublic StreamEntryID xadd(String key, StreamEntryID id, Map<String,String> hash)
StreamCommandsxadd in interface StreamCommandspublic StreamEntryID xadd(String key, XAddParams params, Map<String,String> hash)
xadd in interface StreamCommandspublic long xlen(String key)
StreamCommandsxlen in interface StreamCommandspublic List<StreamEntry> xrange(String key, StreamEntryID start, StreamEntryID end)
StreamCommandsxrange in interface StreamCommandsstart - minimum StreamEntryID for the retrieved range, passing null will indicate minimum ID possible in the streamend - maximum StreamEntryID for the retrieved range, passing null will indicate maximum ID possible in the streampublic List<StreamEntry> xrange(String key, StreamEntryID start, StreamEntryID end, int count)
StreamCommandsxrange in interface StreamCommandsstart - minimum StreamEntryID for the retrieved range, passing null will indicate minimum ID possible in the streamend - maximum StreamEntryID for the retrieved range, passing null will indicate maximum ID possible in the streamcount - maximum number of entries returnedpublic List<StreamEntry> xrevrange(String key, StreamEntryID end, StreamEntryID start)
StreamCommandsxrevrange in interface StreamCommandsend - maximum StreamEntryID for the retrieved range, passing null will indicate maximum ID possible in the streamstart - minimum StreamEntryID for the retrieved range, passing null will indicate minimum ID possible in the streampublic List<StreamEntry> xrevrange(String key, StreamEntryID end, StreamEntryID start, int count)
StreamCommandsxrevrange in interface StreamCommandsend - maximum StreamEntryID for the retrieved range, passing null will indicate maximum ID possible in the streamstart - minimum StreamEntryID for the retrieved range, passing null will indicate minimum ID possible in the streamcount - The entries with IDs matching the specified range.public List<StreamEntry> xrange(String key, String start, String end)
xrange in interface StreamCommandspublic List<StreamEntry> xrange(String key, String start, String end, int count)
xrange in interface StreamCommandspublic List<StreamEntry> xrevrange(String key, String end, String start)
xrevrange in interface StreamCommandspublic List<StreamEntry> xrevrange(String key, String end, String start, int count)
xrevrange in interface StreamCommandspublic long xack(String key, String group, StreamEntryID... ids)
StreamCommandsxack in interface StreamCommandspublic String xgroupCreate(String key, String groupName, StreamEntryID id, boolean makeStream)
StreamCommandsxgroupCreate in interface StreamCommandspublic String xgroupSetID(String key, String groupName, StreamEntryID id)
StreamCommandsxgroupSetID in interface StreamCommandspublic long xgroupDestroy(String key, String groupName)
StreamCommandsxgroupDestroy in interface StreamCommandspublic boolean xgroupCreateConsumer(String key, String groupName, String consumerName)
StreamCommandsxgroupCreateConsumer in interface StreamCommandspublic long xgroupDelConsumer(String key, String groupName, String consumerName)
StreamCommandsxgroupDelConsumer in interface StreamCommandspublic StreamPendingSummary xpending(String key, String groupName)
StreamCommandsxpending in interface StreamCommandspublic List<StreamPendingEntry> xpending(String key, String groupName, StreamEntryID start, StreamEntryID end, int count, String consumerName)
StreamCommandsxpending in interface StreamCommandspublic List<StreamPendingEntry> xpending(String key, String groupName, XPendingParams params)
StreamCommandsxpending in interface StreamCommandspublic long xdel(String key, StreamEntryID... ids)
StreamCommandsxdel in interface StreamCommandspublic long xtrim(String key, long maxLen, boolean approximate)
StreamCommandsxtrim in interface StreamCommandspublic long xtrim(String key, XTrimParams params)
StreamCommandsxtrim in interface StreamCommandspublic List<StreamEntry> xclaim(String key, String group, String consumerName, long minIdleTime, XClaimParams params, StreamEntryID... ids)
StreamCommandsxclaim in interface StreamCommandspublic List<StreamEntryID> xclaimJustId(String key, String group, String consumerName, long minIdleTime, XClaimParams params, StreamEntryID... ids)
StreamCommandsxclaimJustId in interface StreamCommandspublic Map.Entry<StreamEntryID,List<StreamEntry>> xautoclaim(String key, String group, String consumerName, long minIdleTime, StreamEntryID start, XAutoClaimParams params)
StreamCommandsxautoclaim in interface StreamCommandskey - Stream Keygroup - Consumer GroupconsumerName - Consumer name to transfer the auto claimed entriesminIdleTime - Entries pending more than minIdleTime will be transferred ownershipstart - StreamEntryID - Entries >= start will be transferred ownership, passing null will indicate '-'params - XAutoClaimParamspublic Map.Entry<StreamEntryID,List<StreamEntryID>> xautoclaimJustId(String key, String group, String consumerName, long minIdleTime, StreamEntryID start, XAutoClaimParams params)
StreamCommandsxautoclaimJustId in interface StreamCommandskey - Stream Keygroup - Consumer GroupconsumerName - Consumer name to transfer the auto claimed entriesminIdleTime - Entries pending more than minIdleTime will be transferred ownershipstart - StreamEntryID - Entries >= start will be transferred ownership, passing null will indicate '-'params - XAutoClaimParamspublic StreamInfo xinfoStream(String key)
StreamCommandsxinfoStream in interface StreamCommandskey - Stream nameStreamInfo that contains information about the streampublic StreamFullInfo xinfoStreamFull(String key)
StreamCommandsxinfoStreamFull in interface StreamCommandskey - Stream nameStreamFullInfo that contains information about the streampublic StreamFullInfo xinfoStreamFull(String key, int count)
StreamCommandsxinfoStreamFull in interface StreamCommandskey - Stream namecount - stream info countStreamFullInfo that contains information about the stream@Deprecated public List<StreamGroupInfo> xinfoGroup(String key)
xinfoGroup in interface StreamCommandspublic List<StreamGroupInfo> xinfoGroups(String key)
StreamCommandsxinfoGroups in interface StreamCommandskey - Stream nameStreamGroupInfo containing information about groupspublic List<StreamConsumersInfo> xinfoConsumers(String key, String group)
StreamCommandsxinfoConsumers in interface StreamCommandskey - Stream namegroup - Group nameStreamConsumersInfo containing information about consumers that belong
to the the grouppublic List<Map.Entry<String,List<StreamEntry>>> xread(XReadParams xReadParams, Map<String,StreamEntryID> streams)
StreamCommandsxread in interface StreamCommandspublic List<Map.Entry<String,List<StreamEntry>>> xreadGroup(String groupName, String consumer, XReadGroupParams xReadGroupParams, Map<String,StreamEntryID> streams)
StreamCommandsxreadGroup in interface StreamCommandspublic byte[] xadd(byte[] key,
XAddParams params,
Map<byte[],byte[]> hash)
xadd in interface StreamBinaryCommandspublic long xlen(byte[] key)
xlen in interface StreamBinaryCommandspublic List<byte[]> xrange(byte[] key, byte[] start, byte[] end)
xrange in interface StreamBinaryCommandspublic List<byte[]> xrange(byte[] key, byte[] start, byte[] end, int count)
xrange in interface StreamBinaryCommandspublic List<byte[]> xrevrange(byte[] key, byte[] end, byte[] start)
xrevrange in interface StreamBinaryCommandspublic List<byte[]> xrevrange(byte[] key, byte[] end, byte[] start, int count)
xrevrange in interface StreamBinaryCommandspublic long xack(byte[] key,
byte[] group,
byte[]... ids)
xack in interface StreamBinaryCommandspublic String xgroupCreate(byte[] key, byte[] groupName, byte[] id, boolean makeStream)
xgroupCreate in interface StreamBinaryCommandspublic String xgroupSetID(byte[] key, byte[] groupName, byte[] id)
xgroupSetID in interface StreamBinaryCommandspublic long xgroupDestroy(byte[] key,
byte[] groupName)
xgroupDestroy in interface StreamBinaryCommandspublic boolean xgroupCreateConsumer(byte[] key,
byte[] groupName,
byte[] consumerName)
xgroupCreateConsumer in interface StreamBinaryCommandspublic long xgroupDelConsumer(byte[] key,
byte[] groupName,
byte[] consumerName)
xgroupDelConsumer in interface StreamBinaryCommandspublic long xdel(byte[] key,
byte[]... ids)
xdel in interface StreamBinaryCommandspublic long xtrim(byte[] key,
long maxLen,
boolean approximateLength)
xtrim in interface StreamBinaryCommandspublic long xtrim(byte[] key,
XTrimParams params)
xtrim in interface StreamBinaryCommandspublic Object xpending(byte[] key, byte[] groupName)
xpending in interface StreamBinaryCommandspublic List<Object> xpending(byte[] key, byte[] groupName, byte[] start, byte[] end, int count, byte[] consumerName)
xpending in interface StreamBinaryCommandspublic List<Object> xpending(byte[] key, byte[] groupName, XPendingParams params)
xpending in interface StreamBinaryCommandspublic List<byte[]> xclaim(byte[] key, byte[] group, byte[] consumerName, long minIdleTime, XClaimParams params, byte[]... ids)
xclaim in interface StreamBinaryCommandspublic List<byte[]> xclaimJustId(byte[] key, byte[] group, byte[] consumerName, long minIdleTime, XClaimParams params, byte[]... ids)
xclaimJustId in interface StreamBinaryCommandspublic List<Object> xautoclaim(byte[] key, byte[] groupName, byte[] consumerName, long minIdleTime, byte[] start, XAutoClaimParams params)
xautoclaim in interface StreamBinaryCommandspublic List<Object> xautoclaimJustId(byte[] key, byte[] groupName, byte[] consumerName, long minIdleTime, byte[] start, XAutoClaimParams params)
xautoclaimJustId in interface StreamBinaryCommandspublic Object xinfoStream(byte[] key)
xinfoStream in interface StreamBinaryCommandspublic Object xinfoStreamFull(byte[] key)
StreamBinaryCommandsxinfoStreamFull in interface StreamBinaryCommandskey - Stream namepublic Object xinfoStreamFull(byte[] key, int count)
StreamBinaryCommandsxinfoStreamFull in interface StreamBinaryCommandskey - Stream namecount - stream info count@Deprecated public List<Object> xinfoGroup(byte[] key)
xinfoGroup in interface StreamBinaryCommandspublic List<Object> xinfoGroups(byte[] key)
xinfoGroups in interface StreamBinaryCommandspublic List<Object> xinfoConsumers(byte[] key, byte[] group)
xinfoConsumers in interface StreamBinaryCommandspublic List<byte[]> xread(XReadParams xReadParams, Map.Entry<byte[],byte[]>... streams)
xread in interface StreamBinaryCommandspublic List<byte[]> xreadGroup(byte[] groupName, byte[] consumer, XReadGroupParams xReadGroupParams, Map.Entry<byte[],byte[]>... streams)
xreadGroup in interface StreamBinaryCommandspublic Object eval(String script)
ScriptingKeyCommandseval in interface ScriptingKeyCommandsscript - Lua 5.1 script. The script does not need to define a Lua function (and should not).
It is just a Lua program that will run in the context of the Redis server.public Object eval(String script, int keyCount, String... params)
ScriptingKeyCommandseval in interface ScriptingKeyCommandsscript - Lua 5.1 script. The script does not need to define a Lua function (and should not).
It is just a Lua program that will run in the context of the Redis server.keyCount - the count of the provided keysparams - arguments that can be accessed from the scriptpublic Object eval(String script, List<String> keys, List<String> args)
ScriptingKeyCommandseval in interface ScriptingKeyCommandsscript - Lua 5.1 script. The script does not need to define a Lua function (and should not).
It is just a Lua program that will run in the context of the Redis server.keys - arguments that can be accessed by the scriptargs - additional arguments should not represent key names and can be accessed by the scriptpublic Object evalReadonly(String script, List<String> keys, List<String> args)
ScriptingKeyCommandsEVALevalReadonly in interface ScriptingKeyCommandsscript - Lua 5.1 script. The script does not need to define a Lua function (and should not).
It is just a Lua program that will run in the context of the Redis server.keys - arguments that can be accessed by the scriptargs - additional arguments should not represent key names and can be accessed by the scriptScriptingKeyCommands.eval(String, List, List)public Object evalsha(String sha1)
ScriptingKeyCommandsEVAL, but the script cached on the server
side by its SHA1 digest. Scripts are cached on the server side using the SCRIPT LOAD command.evalsha in interface ScriptingKeyCommandssha1 - the scriptScriptingKeyCommands.eval(String)public Object evalsha(String sha1, int keyCount, String... params)
ScriptingKeyCommandsScriptingKeyCommands.eval(String, int, String...) EVAL}, but the script cached on the server
side by its SHA1 digest. Scripts are cached on the server side using the SCRIPT LOAD command.evalsha in interface ScriptingKeyCommandssha1 - the scriptScriptingKeyCommands.eval(String, int, String...)public Object evalsha(String sha1, List<String> keys, List<String> args)
ScriptingKeyCommandsScriptingKeyCommands.eval(String, List, List) EVAL}, but the script cached on the server
side by its SHA1 digest. Scripts are cached on the server side using the SCRIPT LOAD command.evalsha in interface ScriptingKeyCommandssha1 - the scriptScriptingKeyCommands.eval(String, List, List)public Object evalshaReadonly(String sha1, List<String> keys, List<String> args)
ScriptingKeyCommandsEVALevalshaReadonly in interface ScriptingKeyCommandssha1 - the scriptScriptingKeyCommands.evalsha(String, List, List)public Object eval(byte[] script)
eval in interface ScriptingKeyBinaryCommandspublic Object eval(byte[] script, int keyCount, byte[]... params)
eval in interface ScriptingKeyBinaryCommandspublic Object eval(byte[] script, List<byte[]> keys, List<byte[]> args)
eval in interface ScriptingKeyBinaryCommandspublic Object evalReadonly(byte[] script, List<byte[]> keys, List<byte[]> args)
evalReadonly in interface ScriptingKeyBinaryCommandspublic Object evalsha(byte[] sha1)
evalsha in interface ScriptingKeyBinaryCommandspublic Object evalsha(byte[] sha1, int keyCount, byte[]... params)
evalsha in interface ScriptingKeyBinaryCommandspublic Object evalsha(byte[] sha1, List<byte[]> keys, List<byte[]> args)
evalsha in interface ScriptingKeyBinaryCommandspublic Object evalshaReadonly(byte[] sha1, List<byte[]> keys, List<byte[]> args)
evalshaReadonly in interface ScriptingKeyBinaryCommandspublic Object fcall(String name, List<String> keys, List<String> args)
FunctionCommandsfcall in interface FunctionCommandspublic Object fcallReadonly(String name, List<String> keys, List<String> args)
FunctionCommandsFCALL
command that cannot execute commands that modify data.fcallReadonly in interface FunctionCommandspublic String functionDelete(String libraryName)
FunctionCommandsfunctionDelete in interface FunctionCommandspublic String functionFlush()
FunctionCommandsfunctionFlush in interface FunctionBinaryCommandsfunctionFlush in interface FunctionCommandspublic String functionFlush(FlushMode mode)
FunctionCommandsfunctionFlush in interface FunctionBinaryCommandsfunctionFlush in interface FunctionCommandsmode - ASYNC: Asynchronously flush the libraries, SYNC: Synchronously flush the libraries.public String functionKill()
FunctionCommandsfunctionKill in interface FunctionBinaryCommandsfunctionKill in interface FunctionCommandspublic List<LibraryInfo> functionList()
FunctionCommandsfunctionList in interface FunctionCommandsLibraryInfopublic List<LibraryInfo> functionList(String libraryNamePattern)
FunctionCommandsfunctionList in interface FunctionCommandslibraryNamePattern - a pattern for matching library namesLibraryInfopublic List<LibraryInfo> functionListWithCode()
FunctionCommandsFUNCTION LIST but include the
libraries source implementation in the reply.functionListWithCode in interface FunctionCommandsLibraryInfoFunctionCommands.functionList()public List<LibraryInfo> functionListWithCode(String libraryNamePattern)
FunctionCommandsFUNCTION LIST but include the
libraries source implementation in the reply.functionListWithCode in interface FunctionCommandslibraryNamePattern - a pattern for matching library namesLibraryInfoFunctionCommands.functionList(String)public String functionLoad(String functionCode)
FunctionCommandsfunctionLoad in interface FunctionCommandsfunctionCode - the source code. The library payload must start
with Shebang statement that provides a metadata
about the library (like the engine to use and the library name).
Shebang format: #!public String functionLoadReplace(String functionCode)
FunctionCommandsfunctionLoadReplace in interface FunctionCommandsfunctionCode - the source codepublic FunctionStats functionStats()
FunctionCommandsfunctionStats in interface FunctionCommandsFunctionStatspublic Object fcall(byte[] name, List<byte[]> keys, List<byte[]> args)
FunctionBinaryCommandsfcall in interface FunctionBinaryCommandspublic Object fcallReadonly(byte[] name, List<byte[]> keys, List<byte[]> args)
fcallReadonly in interface FunctionBinaryCommandspublic String functionDelete(byte[] libraryName)
FunctionBinaryCommandsfunctionDelete in interface FunctionBinaryCommandspublic byte[] functionDump()
FunctionCommandsFUNCTION RESTORE command.functionDump in interface FunctionBinaryCommandsfunctionDump in interface FunctionCommandspublic List<Object> functionListBinary()
FunctionBinaryCommandsfunctionListBinary in interface FunctionBinaryCommandsLibraryInfopublic List<Object> functionList(byte[] libraryNamePattern)
FunctionBinaryCommandsfunctionList in interface FunctionBinaryCommandslibraryNamePattern - a pattern for matching library namesLibraryInfopublic List<Object> functionListWithCodeBinary()
FunctionBinaryCommandsFUNCTION LIST but include the
libraries source implementation in the reply.functionListWithCodeBinary in interface FunctionBinaryCommandsLibraryInfoFunctionCommands.functionList()public List<Object> functionListWithCode(byte[] libraryNamePattern)
FunctionBinaryCommandsFUNCTION LIST but include the
libraries source implementation in the reply.functionListWithCode in interface FunctionBinaryCommandslibraryNamePattern - a pattern for matching library namesLibraryInfoFunctionBinaryCommands.functionList(byte[])public String functionLoad(byte[] functionCode)
FunctionBinaryCommandsfunctionLoad in interface FunctionBinaryCommandsfunctionCode - the source code. The library payload must start
with Shebang statement that provides a metadata
about the library (like the engine to use and the library name).
Shebang format: #!public String functionLoadReplace(byte[] functionCode)
FunctionBinaryCommandsfunctionLoadReplace in interface FunctionBinaryCommandsfunctionCode - the source codepublic String functionRestore(byte[] serializedValue)
FunctionCommandsfunctionRestore in interface FunctionBinaryCommandsfunctionRestore in interface FunctionCommandsserializedValue - the serialized payloadpublic String functionRestore(byte[] serializedValue, FunctionRestorePolicy policy)
FunctionCommandsfunctionRestore in interface FunctionBinaryCommandsfunctionRestore in interface FunctionCommandsserializedValue - the serialized payloadpolicy - can be FLUSH, APPEND or REPLACEpublic Object functionStatsBinary()
FunctionBinaryCommandsfunctionStatsBinary in interface FunctionBinaryCommandsFunctionStatspublic Long objectRefcount(String key)
KeyCommandsTime complexity: O(1)
objectRefcount in interface KeyCommandspublic String objectEncoding(String key)
KeyCommandsTime complexity: O(1)
objectEncoding in interface KeyCommandspublic Long objectIdletime(String key)
KeyCommandsTime complexity: O(1)
objectIdletime in interface KeyCommandspublic Long objectFreq(String key)
KeyCommandsTime complexity: O(1)
objectFreq in interface KeyCommandspublic Long objectRefcount(byte[] key)
objectRefcount in interface KeyBinaryCommandspublic byte[] objectEncoding(byte[] key)
objectEncoding in interface KeyBinaryCommandspublic Long objectIdletime(byte[] key)
objectIdletime in interface KeyBinaryCommandspublic Long objectFreq(byte[] key)
objectFreq in interface KeyBinaryCommandspublic String migrate(String host, int port, String key, int timeout)
KeyCommandsmigrate in interface KeyCommandstimeout - the maximum idle time in any moment of the communication with the
destination instance in milliseconds.public String migrate(String host, int port, int timeout, MigrateParams params, String... keys)
KeyCommandsmigrate in interface KeyCommandstimeout - the maximum idle time in any moment of the communication with the
destination instance in milliseconds.params - MigrateParamspublic String migrate(String host, int port, byte[] key, int timeout)
migrate in interface KeyBinaryCommandspublic String migrate(String host, int port, int timeout, MigrateParams params, byte[]... keys)
migrate in interface KeyBinaryCommandspublic long waitReplicas(String sampleKey, int replicas, long timeout)
waitReplicas in interface SampleKeyedCommandspublic long waitReplicas(byte[] sampleKey,
int replicas,
long timeout)
waitReplicas in interface SampleBinaryKeyedCommandspublic Object eval(String script, String sampleKey)
eval in interface SampleKeyedCommandspublic Object evalsha(String sha1, String sampleKey)
evalsha in interface SampleKeyedCommandspublic Object eval(byte[] script, byte[] sampleKey)
eval in interface SampleBinaryKeyedCommandspublic Object evalsha(byte[] sha1, byte[] sampleKey)
evalsha in interface SampleBinaryKeyedCommandspublic Boolean scriptExists(String sha1, String sampleKey)
scriptExists in interface SampleKeyedCommandspublic List<Boolean> scriptExists(String sampleKey, String... sha1s)
scriptExists in interface SampleKeyedCommandspublic Boolean scriptExists(byte[] sha1, byte[] sampleKey)
scriptExists in interface SampleBinaryKeyedCommandspublic List<Boolean> scriptExists(byte[] sampleKey, byte[]... sha1s)
scriptExists in interface SampleBinaryKeyedCommandspublic String scriptLoad(String script, String sampleKey)
scriptLoad in interface SampleKeyedCommandspublic String scriptFlush(String sampleKey)
scriptFlush in interface SampleKeyedCommandspublic String scriptFlush(String sampleKey, FlushMode flushMode)
scriptFlush in interface SampleKeyedCommandspublic String scriptKill(String sampleKey)
scriptKill in interface SampleKeyedCommandspublic byte[] scriptLoad(byte[] script,
byte[] sampleKey)
scriptLoad in interface SampleBinaryKeyedCommandspublic String scriptFlush(byte[] sampleKey)
scriptFlush in interface SampleBinaryKeyedCommandspublic String scriptFlush(byte[] sampleKey, FlushMode flushMode)
scriptFlush in interface SampleBinaryKeyedCommandspublic String scriptKill(byte[] sampleKey)
scriptKill in interface SampleBinaryKeyedCommandspublic long publish(byte[] channel,
byte[] message)
public void subscribe(JedisPubSub jedisPubSub, String... channels)
public void psubscribe(JedisPubSub jedisPubSub, String... patterns)
public void subscribe(BinaryJedisPubSub jedisPubSub, byte[]... channels)
public void psubscribe(BinaryJedisPubSub jedisPubSub, byte[]... patterns)
public LCSMatchResult strAlgoLCSStrings(String strA, String strB, StrAlgoLCSParams params)
public LCSMatchResult strAlgoLCSStrings(byte[] strA, byte[] strB, StrAlgoLCSParams params)
public String ftCreate(String indexName, IndexOptions indexOptions, Schema schema)
ftCreate in interface RediSearchCommandspublic String ftAlter(String indexName, Schema schema)
ftAlter in interface RediSearchCommandspublic SearchResult ftSearch(String indexName, Query query)
ftSearch in interface RediSearchCommandspublic SearchResult ftSearch(byte[] indexName, Query query)
ftSearch in interface RediSearchCommandspublic String ftExplain(String indexName, Query query)
ftExplain in interface RediSearchCommandspublic List<String> ftExplainCLI(String indexName, Query query)
ftExplainCLI in interface RediSearchCommandspublic AggregationResult ftAggregate(String indexName, AggregationBuilder aggr)
ftAggregate in interface RediSearchCommandspublic AggregationResult ftCursorRead(String indexName, long cursorId, int count)
ftCursorRead in interface RediSearchCommandspublic String ftCursorDel(String indexName, long cursorId)
ftCursorDel in interface RediSearchCommandspublic String ftDropIndex(String indexName)
ftDropIndex in interface RediSearchCommandspublic String ftDropIndexDD(String indexName)
ftDropIndexDD in interface RediSearchCommandspublic String ftSynUpdate(String indexName, String synonymGroupId, String... terms)
ftSynUpdate in interface RediSearchCommandspublic Map<String,List<String>> ftSynDump(String indexName)
ftSynDump in interface RediSearchCommandspublic Map<String,Object> ftInfo(String indexName)
ftInfo in interface RediSearchCommandspublic String ftAliasAdd(String aliasName, String indexName)
ftAliasAdd in interface RediSearchCommandspublic String ftAliasUpdate(String aliasName, String indexName)
ftAliasUpdate in interface RediSearchCommandspublic String ftAliasDel(String aliasName)
ftAliasDel in interface RediSearchCommandspublic Map<String,String> ftConfigGet(String option)
ftConfigGet in interface RediSearchCommandspublic Map<String,String> ftConfigGet(String indexName, String option)
ftConfigGet in interface RediSearchCommandspublic String ftConfigSet(String option, String value)
ftConfigSet in interface RediSearchCommandspublic String ftConfigSet(String indexName, String option, String value)
ftConfigSet in interface RediSearchCommandspublic String jsonSet(String key, Path2 path, Object object)
jsonSet in interface RedisJsonCommandspublic String jsonSetWithEscape(String key, Path2 path, Object object)
jsonSetWithEscape in interface RedisJsonCommandspublic String jsonSet(String key, Path path, Object pojo)
jsonSet in interface RedisJsonCommandspublic String jsonSet(String key, Path2 path, Object pojo, JsonSetParams params)
jsonSet in interface RedisJsonCommandspublic String jsonSetWithEscape(String key, Path2 path, Object pojo, JsonSetParams params)
jsonSetWithEscape in interface RedisJsonCommandspublic String jsonSet(String key, Path path, Object pojo, JsonSetParams params)
jsonSet in interface RedisJsonCommandspublic Object jsonGet(String key)
jsonGet in interface RedisJsonCommandspublic <T> T jsonGet(String key, Class<T> clazz)
jsonGet in interface RedisJsonCommandspublic Object jsonGet(String key, Path2... paths)
jsonGet in interface RedisJsonCommandspublic Object jsonGet(String key, Path... paths)
jsonGet in interface RedisJsonCommandspublic <T> T jsonGet(String key, Class<T> clazz, Path... paths)
jsonGet in interface RedisJsonCommandspublic List<org.json.JSONArray> jsonMGet(Path2 path, String... keys)
jsonMGet in interface RedisJsonCommandspublic <T> List<T> jsonMGet(Path path, Class<T> clazz, String... keys)
jsonMGet in interface RedisJsonCommandspublic long jsonDel(String key)
jsonDel in interface RedisJsonCommandspublic long jsonDel(String key, Path2 path)
jsonDel in interface RedisJsonCommandspublic long jsonDel(String key, Path path)
jsonDel in interface RedisJsonCommandspublic long jsonClear(String key)
jsonClear in interface RedisJsonCommandspublic long jsonClear(String key, Path2 path)
jsonClear in interface RedisJsonCommandspublic long jsonClear(String key, Path path)
jsonClear in interface RedisJsonCommandspublic List<Boolean> jsonToggle(String key, Path2 path)
jsonToggle in interface RedisJsonCommandspublic String jsonToggle(String key, Path path)
jsonToggle in interface RedisJsonCommandspublic Class<?> jsonType(String key)
jsonType in interface RedisJsonCommandspublic List<Class<?>> jsonType(String key, Path2 path)
jsonType in interface RedisJsonCommandspublic Class<?> jsonType(String key, Path path)
jsonType in interface RedisJsonCommandspublic long jsonStrAppend(String key, Object string)
jsonStrAppend in interface RedisJsonCommandspublic List<Long> jsonStrAppend(String key, Path2 path, Object string)
jsonStrAppend in interface RedisJsonCommandspublic long jsonStrAppend(String key, Path path, Object string)
jsonStrAppend in interface RedisJsonCommandspublic Long jsonStrLen(String key)
jsonStrLen in interface RedisJsonCommandspublic List<Long> jsonStrLen(String key, Path2 path)
jsonStrLen in interface RedisJsonCommandspublic Long jsonStrLen(String key, Path path)
jsonStrLen in interface RedisJsonCommandspublic List<Long> jsonArrAppend(String key, Path2 path, Object... objects)
jsonArrAppend in interface RedisJsonCommandspublic List<Long> jsonArrAppendWithEscape(String key, Path2 path, Object... objects)
jsonArrAppendWithEscape in interface RedisJsonCommandspublic Long jsonArrAppend(String key, Path path, Object... pojos)
jsonArrAppend in interface RedisJsonCommandspublic List<Long> jsonArrIndex(String key, Path2 path, Object scalar)
jsonArrIndex in interface RedisJsonCommandspublic List<Long> jsonArrIndexWithEscape(String key, Path2 path, Object scalar)
jsonArrIndexWithEscape in interface RedisJsonCommandspublic long jsonArrIndex(String key, Path path, Object scalar)
jsonArrIndex in interface RedisJsonCommandspublic List<Long> jsonArrInsert(String key, Path2 path, int index, Object... objects)
jsonArrInsert in interface RedisJsonCommandspublic List<Long> jsonArrInsertWithEscape(String key, Path2 path, int index, Object... objects)
jsonArrInsertWithEscape in interface RedisJsonCommandspublic long jsonArrInsert(String key, Path path, int index, Object... pojos)
jsonArrInsert in interface RedisJsonCommandspublic Object jsonArrPop(String key)
jsonArrPop in interface RedisJsonCommandspublic <T> T jsonArrPop(String key, Class<T> clazz)
jsonArrPop in interface RedisJsonCommandspublic List<Object> jsonArrPop(String key, Path2 path)
jsonArrPop in interface RedisJsonCommandspublic Object jsonArrPop(String key, Path path)
jsonArrPop in interface RedisJsonCommandspublic <T> T jsonArrPop(String key, Class<T> clazz, Path path)
jsonArrPop in interface RedisJsonCommandspublic List<Object> jsonArrPop(String key, Path2 path, int index)
jsonArrPop in interface RedisJsonCommandspublic Object jsonArrPop(String key, Path path, int index)
jsonArrPop in interface RedisJsonCommandspublic <T> T jsonArrPop(String key, Class<T> clazz, Path path, int index)
jsonArrPop in interface RedisJsonCommandspublic Long jsonArrLen(String key)
jsonArrLen in interface RedisJsonCommandspublic List<Long> jsonArrLen(String key, Path2 path)
jsonArrLen in interface RedisJsonCommandspublic Long jsonArrLen(String key, Path path)
jsonArrLen in interface RedisJsonCommandspublic List<Long> jsonArrTrim(String key, Path2 path, int start, int stop)
jsonArrTrim in interface RedisJsonCommandspublic Long jsonArrTrim(String key, Path path, int start, int stop)
jsonArrTrim in interface RedisJsonCommandspublic String tsCreate(String key)
RedisTimeSeriesCommandsTS.CREATE keytsCreate in interface RedisTimeSeriesCommandspublic String tsCreate(String key, TSCreateParams createParams)
RedisTimeSeriesCommandsTS.CREATE key [RETENTION retentionTime] [ENCODING [UNCOMPRESSED|COMPRESSED]] [CHUNK_SIZE size] [DUPLICATE_POLICY policy] [LABELS label value..]tsCreate in interface RedisTimeSeriesCommandspublic long tsDel(String key, long fromTimestamp, long toTimestamp)
RedisTimeSeriesCommandsTS.DEL key fromTimestamp toTimestamptsDel in interface RedisTimeSeriesCommandspublic String tsAlter(String key, TSAlterParams alterParams)
RedisTimeSeriesCommandsTS.ALTER key [RETENTION retentionTime] [LABELS label value..]tsAlter in interface RedisTimeSeriesCommandspublic long tsAdd(String key, double value)
RedisTimeSeriesCommandsTS.ADD key * valuetsAdd in interface RedisTimeSeriesCommandspublic long tsAdd(String key, long timestamp, double value)
RedisTimeSeriesCommandsTS.ADD key timestamp valuetsAdd in interface RedisTimeSeriesCommandspublic long tsAdd(String key, long timestamp, double value, TSCreateParams createParams)
RedisTimeSeriesCommandsTS.ADD key timestamp value [RETENTION retentionTime] [ENCODING [COMPRESSED|UNCOMPRESSED]] [CHUNK_SIZE size] [ON_DUPLICATE policy] [LABELS label value..]tsAdd in interface RedisTimeSeriesCommandspublic List<TSElement> tsRange(String key, long fromTimestamp, long toTimestamp)
RedisTimeSeriesCommandsTS.RANGE key fromTimestamp toTimestamptsRange in interface RedisTimeSeriesCommandspublic List<TSElement> tsRange(String key, TSRangeParams rangeParams)
RedisTimeSeriesCommandsTS.RANGE key fromTimestamp toTimestamp
[FILTER_BY_TS TS1 TS2 ..] [FILTER_BY_VALUE min max]
[COUNT count] [ALIGN value] [AGGREGATION aggregationType timeBucket]tsRange in interface RedisTimeSeriesCommandspublic List<TSElement> tsRevRange(String key, long fromTimestamp, long toTimestamp)
RedisTimeSeriesCommandsTS.REVRANGE key fromTimestamp toTimestamptsRevRange in interface RedisTimeSeriesCommandspublic List<TSElement> tsRevRange(String key, TSRangeParams rangeParams)
RedisTimeSeriesCommandsTS.REVRANGE key fromTimestamp toTimestamp
[FILTER_BY_TS TS1 TS2 ..] [FILTER_BY_VALUE min max]
[COUNT count] [ALIGN value] [AGGREGATION aggregationType timeBucket]tsRevRange in interface RedisTimeSeriesCommandspublic List<TSKeyedElements> tsMRange(long fromTimestamp, long toTimestamp, String... filters)
RedisTimeSeriesCommandsTS.MRANGE fromTimestamp toTimestamptsMRange in interface RedisTimeSeriesCommandspublic List<TSKeyedElements> tsMRange(TSMRangeParams multiRangeParams)
RedisTimeSeriesCommandsTS.MRANGE fromTimestamp toTimestamp
[FILTER_BY_TS TS1 TS2 ..] [FILTER_BY_VALUE min max]
[WITHLABELS | SELECTED_LABELS label1 ..]
[COUNT count] [ALIGN value]
[AGGREGATION aggregationType timeBucket]
FILTER filter..
[GROUPBY <label> REDUCE <reducer>]tsMRange in interface RedisTimeSeriesCommandspublic List<TSKeyedElements> tsMRevRange(long fromTimestamp, long toTimestamp, String... filters)
RedisTimeSeriesCommandsTS.MREVRANGE fromTimestamp toTimestamptsMRevRange in interface RedisTimeSeriesCommandspublic List<TSKeyedElements> tsMRevRange(TSMRangeParams multiRangeParams)
RedisTimeSeriesCommandsTS.MREVRANGE fromTimestamp toTimestamp
[FILTER_BY_TS TS1 TS2 ..]
[FILTER_BY_VALUE min max]
[WITHLABELS | SELECTED_LABELS label1 ..]
[COUNT count] [ALIGN value]
[AGGREGATION aggregationType timeBucket]
FILTER filter..
[GROUPBY <label> REDUCE <reducer>]tsMRevRange in interface RedisTimeSeriesCommandspublic TSElement tsGet(String key)
RedisTimeSeriesCommandsTS.GET keytsGet in interface RedisTimeSeriesCommandspublic List<TSKeyValue<TSElement>> tsMGet(TSMGetParams multiGetParams, String... filters)
RedisTimeSeriesCommandsTS.MGET [WITHLABELS | SELECTED_LABELS label1 ..] FILTER filter...tsMGet in interface RedisTimeSeriesCommandspublic String tsCreateRule(String sourceKey, String destKey, AggregationType aggregationType, long timeBucket)
RedisTimeSeriesCommandsTS.CREATERULE sourceKey destKey AGGREGATION aggregationType timeBuckettsCreateRule in interface RedisTimeSeriesCommandspublic String tsDeleteRule(String sourceKey, String destKey)
RedisTimeSeriesCommandsTS.DELETERULE sourceKey destKeytsDeleteRule in interface RedisTimeSeriesCommandspublic List<String> tsQueryIndex(String... filters)
RedisTimeSeriesCommandsTS.QUERYINDEX filter...tsQueryIndex in interface RedisTimeSeriesCommandspublic String bfReserve(String key, double errorRate, long capacity)
BloomFilterCommandsBF.RESERVE {key} {error_rate} {capacity}bfReserve in interface BloomFilterCommandspublic String bfReserve(String key, double errorRate, long capacity, BFReserveParams reserveParams)
BloomFilterCommandsBF.RESERVE {key} {error_rate} {capacity} [EXPANSION {expansion}] [NONSCALING]bfReserve in interface BloomFilterCommandspublic boolean bfAdd(String key, String item)
BloomFilterCommandsBF.ADD {key} {item}bfAdd in interface BloomFilterCommandspublic List<Boolean> bfMAdd(String key, String... items)
BloomFilterCommandsBF.MADD {key} {item ...}bfMAdd in interface BloomFilterCommandspublic List<Boolean> bfInsert(String key, String... items)
BloomFilterCommandsBF.INSERT {key} ITEMS {item ...}bfInsert in interface BloomFilterCommandspublic List<Boolean> bfInsert(String key, BFInsertParams insertParams, String... items)
BloomFilterCommandsBF.INSERT {key} [CAPACITY {cap}] [ERROR {error}] [EXPANSION {expansion}] [NOCREATE]
[NONSCALING] ITEMS {item ...}bfInsert in interface BloomFilterCommandspublic boolean bfExists(String key, String item)
BloomFilterCommandsBF.EXISTS {key} {item}bfExists in interface BloomFilterCommandspublic List<Boolean> bfMExists(String key, String... items)
BloomFilterCommandsBF.MEXISTS {key} {item ...}bfMExists in interface BloomFilterCommandspublic Map<String,Object> bfInfo(String key)
bfInfo in interface BloomFilterCommandspublic String cfReserve(String key, long capacity)
CuckooFilterCommandscfReserve in interface CuckooFilterCommandskey - The name of the filterpublic String cfReserve(String key, long capacity, CFReserveParams reserveParams)
CuckooFilterCommandscfReserve in interface CuckooFilterCommandskey - The name of the filterreserveParams - An instance of CFReserveParams containing the optionspublic boolean cfAdd(String key, String item)
CuckooFilterCommandscfAdd in interface CuckooFilterCommandskey - The name of the filteritem - The item to addpublic boolean cfAddNx(String key, String item)
CuckooFilterCommandscfAddNx in interface CuckooFilterCommandskey - The name of the filteritem - The item to addpublic List<Boolean> cfInsert(String key, String... items)
CuckooFilterCommandscfInsert in interface CuckooFilterCommandskey - The name of the filteritems - One or more items to addpublic List<Boolean> cfInsert(String key, CFInsertParams insertParams, String... items)
CuckooFilterCommandscfInsert in interface CuckooFilterCommandskey - The name of the filterinsertParams - An instance of CFInsertParams containing the optionsitems - One or more items to addpublic List<Boolean> cfInsertNx(String key, String... items)
CuckooFilterCommandscfInsertNx in interface CuckooFilterCommandskey - The name of the filteritems - One or more items to addpublic List<Boolean> cfInsertNx(String key, CFInsertParams insertParams, String... items)
CuckooFilterCommandscfInsertNx in interface CuckooFilterCommandskey - The name of the filterinsertParams - An instance of CFInsertParams containing the options
(CAPACITY/NOCREATE)items - One or more items to addpublic boolean cfExists(String key, String item)
CuckooFilterCommandscfExists in interface CuckooFilterCommandskey - The name of the filteritem - The item to check forpublic List<Boolean> cfMExists(String key, String... items)
CuckooFilterCommandsCF.MEXISTS {key} {item ...}cfMExists in interface CuckooFilterCommandskey - The name of the filteritems - Items to check for (non empty sequence)public boolean cfDel(String key, String item)
CuckooFilterCommandscfDel in interface CuckooFilterCommandskey - The name of the filteritem - The item to delete from the filterpublic long cfCount(String key, String item)
CuckooFilterCommandscfCount in interface CuckooFilterCommandskey - The name of the filteritem - The item to countpublic Map<String,Object> cfInfo(String key)
CuckooFilterCommandscfInfo in interface CuckooFilterCommandskey - Name of the filter to restorepublic String cmsInitByDim(String key, long width, long depth)
CountMinSketchCommandscmsInitByDim in interface CountMinSketchCommandskey - The name of the sketchwidth - Number of counter in each array. Reduces the error sizedepth - Number of counter-arrays. Reduces the probability for an error
of a certain size (percentage of total countpublic String cmsInitByProb(String key, double error, double probability)
CountMinSketchCommandscmsInitByProb in interface CountMinSketchCommandskey - The name of the sketch.error - Estimate size of error. The error is a percent of total
counted items. This effects the width of the sketch.probability - The desired probability for inflated count. This should be
a decimal value between 0 and 1. This effects the depth of
the sketch. For example, for a desired false positive rate
of 0.1% (1 in 1000), error_rate should be set to 0.001.
The closer this number is to zero, the greater the memory
consumption per item and the more CPU usage per operation.public List<Long> cmsIncrBy(String key, Map<String,Long> itemIncrements)
CountMinSketchCommandscmsIncrBy in interface CountMinSketchCommandskey - The name of the sketchitemIncrements - a Map of the items to be increased and their integer
incrementpublic List<Long> cmsQuery(String key, String... items)
CountMinSketchCommandscmsQuery in interface CountMinSketchCommandskey - The name of the sketchitems - The items for which to retrieve the countspublic String cmsMerge(String destKey, String... keys)
CountMinSketchCommandscmsMerge in interface CountMinSketchCommandsdestKey - The name of destination sketch. Must be initialized.keys - The sketches to be mergedpublic String cmsMerge(String destKey, Map<String,Long> keysAndWeights)
CountMinSketchCommandscmsMerge in interface CountMinSketchCommandsdestKey - The name of destination sketch. Must be initialized.keysAndWeights - A map of keys and weights used to multiply the sketch.public Map<String,Object> cmsInfo(String key)
CountMinSketchCommandscmsInfo in interface CountMinSketchCommandskey - The name of the sketchpublic String topkReserve(String key, long topk)
TopKFilterCommandsTOPK.RESERVE {key} {topk}topkReserve in interface TopKFilterCommandspublic String topkReserve(String key, long topk, long width, long depth, double decay)
TopKFilterCommandsTOPK.RESERVE {key} {topk} [{width} {depth} {decay}]topkReserve in interface TopKFilterCommandspublic List<String> topkAdd(String key, String... items)
TopKFilterCommandsTOPK.ADD {key} {item ...}topkAdd in interface TopKFilterCommandspublic List<String> topkIncrBy(String key, Map<String,Long> itemIncrements)
TopKFilterCommandsTOPK.INCRBY {key} {item} {increment} [{item} {increment} ...]topkIncrBy in interface TopKFilterCommandsitemIncrements - item and increment pairspublic List<Boolean> topkQuery(String key, String... items)
TopKFilterCommandsTOPK.QUERY {key} {item ...}topkQuery in interface TopKFilterCommandspublic List<Long> topkCount(String key, String... items)
TopKFilterCommandsTOPK.COUNT {key} {item ...}topkCount in interface TopKFilterCommandspublic List<String> topkList(String key)
TopKFilterCommandsTOPK.LIST {key}topkList in interface TopKFilterCommandspublic Map<String,Object> topkInfo(String key)
TopKFilterCommandsTOPK.INFO {key}topkInfo in interface TopKFilterCommandspublic ResultSet graphQuery(String name, String query)
RedisGraphCommandsgraphQuery in interface RedisGraphCommandsname - a graph to perform the query onquery - Cypher querypublic ResultSet graphReadonlyQuery(String name, String query)
RedisGraphCommandsgraphReadonlyQuery in interface RedisGraphCommandsname - a graph to perform the query onquery - Cypher querypublic ResultSet graphQuery(String name, String query, long timeout)
RedisGraphCommandsgraphQuery in interface RedisGraphCommandsname - a graph to perform the query onquery - Cypher querypublic ResultSet graphReadonlyQuery(String name, String query, long timeout)
RedisGraphCommandsgraphReadonlyQuery in interface RedisGraphCommandsname - a graph to perform the query onquery - Cypher querypublic ResultSet graphQuery(String name, String query, Map<String,Object> params)
RedisGraphCommandsgraphQuery in interface RedisGraphCommandsname - a graph to perform the query on.query - Cypher query.params - parameters map.public ResultSet graphReadonlyQuery(String name, String query, Map<String,Object> params)
RedisGraphCommandsgraphReadonlyQuery in interface RedisGraphCommandsname - a graph to perform the query on.query - Cypher query.params - parameters map.public ResultSet graphQuery(String name, String query, Map<String,Object> params, long timeout)
RedisGraphCommandsgraphQuery in interface RedisGraphCommandsname - a graph to perform the query on.query - Cypher query.params - parameters map.public ResultSet graphReadonlyQuery(String name, String query, Map<String,Object> params, long timeout)
RedisGraphCommandsgraphReadonlyQuery in interface RedisGraphCommandsname - a graph to perform the query on.query - Cypher query.params - parameters map.public String graphDelete(String name)
RedisGraphCommandsgraphDelete in interface RedisGraphCommandsname - graph to deletepublic Object sendCommand(ProtocolCommand cmd)
public Object sendCommand(ProtocolCommand cmd, byte[]... args)
public Object sendBlockingCommand(ProtocolCommand cmd, byte[]... args)
public Object sendCommand(ProtocolCommand cmd, String... args)
public Object sendBlockingCommand(ProtocolCommand cmd, String... args)
public Object sendCommand(byte[] sampleKey, ProtocolCommand cmd, byte[]... args)
public Object sendBlockingCommand(byte[] sampleKey, ProtocolCommand cmd, byte[]... args)
public Object sendCommand(String sampleKey, ProtocolCommand cmd, String... args)
public Object sendBlockingCommand(String sampleKey, ProtocolCommand cmd, String... args)
public Object executeCommand(CommandArguments args)
Copyright © 2022. All rights reserved.