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(CommandExecutor executor)
The constructor to use a custom
CommandExecutor . |
UnifiedJedis(Connection connection)
The constructor to directly use a
Connection . |
UnifiedJedis(ConnectionProvider provider) |
UnifiedJedis(ConnectionProvider provider,
int maxAttempts,
Duration maxTotalRetriesDuration) |
UnifiedJedis(HostAndPort hostAndPort) |
UnifiedJedis(HostAndPort hostAndPort,
JedisClientConfig clientConfig) |
UnifiedJedis(JedisSocketFactory socketFactory)
The constructor to directly use a custom
JedisSocketFactory . |
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 ...} |
String |
bfLoadChunk(String key,
long iterator,
byte[] data)
BF.LOADCHUNK {key} {iterator} {data} |
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] |
Map.Entry<Long,byte[]> |
bfScanDump(String key,
long iterator)
BF.SCANDUMP {key} {iterator} |
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) |
JedisBroadcast |
broadcast() |
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
|
String |
cfLoadChunk(String key,
long iterator,
byte[] data)
CF.LOADCHUNK Restores a filter previously saved using SCANDUMP.
|
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
|
Map.Entry<Long,byte[]> |
cfScanDump(String key,
long iterator)
CF.SCANDUMP Begins an incremental save of the cuckoo filter.
|
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,
Iterable<SchemaField> schemaFields) |
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,
FTCreateParams createParams,
Iterable<SchemaField> schemaFields) |
String |
ftCreate(String indexName,
IndexOptions indexOptions,
Schema schema) |
String |
ftCursorDel(String indexName,
long cursorId) |
AggregationResult |
ftCursorRead(String indexName,
long cursorId,
int count) |
long |
ftDictAdd(String dictionary,
String... terms) |
long |
ftDictAddBySampleKey(String indexName,
String dictionary,
String... terms) |
long |
ftDictDel(String dictionary,
String... terms) |
long |
ftDictDelBySampleKey(String indexName,
String dictionary,
String... terms) |
Set<String> |
ftDictDump(String dictionary) |
Set<String> |
ftDictDumpBySampleKey(String indexName,
String dictionary) |
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) |
List<String> |
ftList() |
Map.Entry<AggregationResult,Map<String,Object>> |
ftProfileAggregate(String indexName,
FTProfileParams profileParams,
AggregationBuilder aggr) |
Map.Entry<SearchResult,Map<String,Object>> |
ftProfileSearch(String indexName,
FTProfileParams profileParams,
Query query) |
Map.Entry<SearchResult,Map<String,Object>> |
ftProfileSearch(String indexName,
FTProfileParams profileParams,
String query,
FTSearchParams searchParams) |
SearchResult |
ftSearch(byte[] indexName,
Query query) |
SearchResult |
ftSearch(String indexName,
Query query) |
SearchResult |
ftSearch(String indexName,
String query) |
SearchResult |
ftSearch(String indexName,
String query,
FTSearchParams params) |
Map<String,Map<String,Double>> |
ftSpellCheck(String index,
String query) |
Map<String,Map<String,Double>> |
ftSpellCheck(String index,
String query,
FTSpellCheckParams spellCheckParams) |
long |
ftSugAdd(String key,
String string,
double score) |
long |
ftSugAddIncr(String key,
String string,
double score) |
boolean |
ftSugDel(String key,
String string) |
List<String> |
ftSugGet(String key,
String prefix) |
List<String> |
ftSugGet(String key,
String prefix,
boolean fuzzy,
int max) |
List<Tuple> |
ftSugGetWithScores(String key,
String prefix) |
List<Tuple> |
ftSugGetWithScores(String key,
String prefix,
boolean fuzzy,
int max) |
long |
ftSugLen(String key) |
Map<String,List<String>> |
ftSynDump(String indexName) |
String |
ftSynUpdate(String indexName,
String synonymGroupId,
String... terms) |
Set<String> |
ftTagVals(String indexName,
String fieldName) |
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.
|
Map<String,Object> |
graphConfigGet(String configName) |
String |
graphConfigSet(String configName,
Object value) |
String |
graphDelete(String name)
Deletes the entire graph
|
List<String> |
graphExplain(String graphName,
String query)
Constructs a query execution plan but does not run it.
|
List<String> |
graphList()
Lists all graph keys in the keyspace.
|
List<String> |
graphProfile(String graphName,
String query)
Executes a query and produces an execution plan augmented with metrics for each operation's execution.
|
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.
|
List<List<String>> |
graphSlowlog(String graphName)
Returns a list containing up to 10 of the slowest queries issued against the given graph ID.
|
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 |
jsonDebugMemory(String key) |
long |
jsonDebugMemory(String key,
Path path) |
List<Long> |
jsonDebugMemory(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) |
String |
jsonGetAsPlainString(String key,
Path path) |
List<org.json.JSONArray> |
jsonMGet(Path2 path,
String... keys) |
<T> List<T> |
jsonMGet(Path path,
Class<T> clazz,
String... keys) |
org.json.JSONArray |
jsonNumIncrBy(String key,
Path2 path,
double value) |
double |
jsonNumIncrBy(String key,
Path path,
double value) |
List<String> |
jsonObjKeys(String key) |
List<String> |
jsonObjKeys(String key,
Path path) |
List<List<String>> |
jsonObjKeys(String key,
Path2 path) |
Long |
jsonObjLen(String key) |
Long |
jsonObjLen(String key,
Path path) |
List<Long> |
jsonObjLen(String key,
Path2 path) |
List<Object> |
jsonResp(String key) |
List<Object> |
jsonResp(String key,
Path path) |
List<List<Object>> |
jsonResp(String key,
Path2 path) |
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) |
String |
jsonSetWithPlainString(String key,
Path path,
String string) |
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) |
Object |
pipelined() |
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)
|
byte[] |
setGet(byte[] key,
byte[] value,
SetParams params)
WARNING:
SetParams.get() MUST NOT be used with this method. |
String |
setGet(String key,
String value,
SetParams params)
WARNING:
SetParams.get() MUST NOT be used with this method. |
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. |
String |
tdigestAdd(String key,
double... values)
TDIGEST.ADD key value weight [ value weight ...] |
List<Double> |
tdigestByRank(String key,
long... ranks) |
List<Double> |
tdigestByRevRank(String key,
long... ranks) |
List<Double> |
tdigestCDF(String key,
double... values)
TDIGEST.CDF key value [value ...] |
String |
tdigestCreate(String key)
TDIGEST.CREATE key |
String |
tdigestCreate(String key,
int compression)
TDIGEST.CREATE key [compression] |
Map<String,Object> |
tdigestInfo(String key)
TDIGEST.INFO key |
double |
tdigestMax(String key)
TDIGEST.MAX key |
String |
tdigestMerge(String destinationKey,
String... sourceKeys)
TDIGEST.MERGE destination-key numkeys source-key [source-key ...] |
String |
tdigestMerge(TDigestMergeParams mergeParams,
String destinationKey,
String... sourceKeys)
TDIGEST.MERGE destination-key numkeys source-key [source-key ...]
[COMPRESSION compression] [OVERRIDE] |
double |
tdigestMin(String key)
TDIGEST.MIN key |
List<Double> |
tdigestQuantile(String key,
double... quantiles)
TDIGEST.QUANTILE key quantile [quantile ...] |
List<Long> |
tdigestRank(String key,
double... values) |
String |
tdigestReset(String key)
TDIGEST.RESET key |
List<Long> |
tdigestRevRank(String key,
double... values) |
double |
tdigestTrimmedMean(String key,
double lowCutQuantile,
double highCutQuantile)
TDIGEST.TRIMMED_MEAN key low_cut_quantile high_cut_quantile |
List<String> |
topkAdd(String key,
String... items)
TOPK.ADD {key} {item ...} |
List<Long> |
topkCount(String key,
String... items)
Deprecated.
|
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 |
String |
tsCreateRule(String sourceKey,
String destKey,
AggregationType aggregationType,
long bucketDuration,
long alignTimestamp)
TS.CREATERULE sourceKey destKey AGGREGATION aggregationType bucketDuration [alignTimestamp] |
long |
tsDecrBy(String key,
double value) |
long |
tsDecrBy(String key,
double value,
long timestamp) |
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 |
TSElement |
tsGet(String key,
TSGetParams getParams)
TS.GET key [LATEST] |
long |
tsIncrBy(String key,
double value) |
long |
tsIncrBy(String key,
double value,
long timestamp) |
TSInfo |
tsInfo(String key) |
TSInfo |
tsInfoDebug(String key) |
List<Long> |
tsMAdd(Map.Entry<String,TSElement>... entries)
TS.MADD key timestamp value [key timestamp value ...] |
List<TSKeyValue<TSElement>> |
tsMGet(TSMGetParams multiGetParams,
String... filters)
TS.MGET [LATEST] [ WITHLABELS | SELECTED_LABELS label...] FILTER filter... |
List<TSKeyedElements> |
tsMRange(long fromTimestamp,
long toTimestamp,
String... filters)
TS.MRANGE fromTimestamp toTimestamp FILTER filter... |
List<TSKeyedElements> |
tsMRange(TSMRangeParams multiRangeParams)
{@code TS.MRANGE fromTimestamp toTimestamp
[LATEST]
[FILTER_BY_TS ts...]
[FILTER_BY_VALUE min max]
[WITHLABELS | SELECTED_LABELS label...]
[COUNT count]
[[ALIGN value] AGGREGATION aggregator bucketDuration [BUCKETTIMESTAMP bt] [EMPTY]]
FILTER filter...
|
List<TSKeyedElements> |
tsMRevRange(long fromTimestamp,
long toTimestamp,
String... filters)
TS.MREVRANGE fromTimestamp toTimestamp FILTER filter... |
List<TSKeyedElements> |
tsMRevRange(TSMRangeParams multiRangeParams)
{@code TS.MREVRANGE fromTimestamp toTimestamp
[LATEST]
[FILTER_BY_TS TS...]
[FILTER_BY_VALUE min max]
[WITHLABELS | SELECTED_LABELS label...]
[COUNT count]
[[ALIGN value] AGGREGATION aggregator bucketDuration [BUCKETTIMESTAMP bt] [EMPTY]]
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
[LATEST]
[FILTER_BY_TS ts...]
[FILTER_BY_VALUE min max]
[COUNT count]
[[ALIGN value] AGGREGATION aggregator bucketDuration [BUCKETTIMESTAMP bt] [EMPTY]] |
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
[LATEST]
[FILTER_BY_TS TS...]
[FILTER_BY_VALUE min max]
[COUNT count]
[[ALIGN value] AGGREGATION aggregator bucketDuration [BUCKETTIMESTAMP bt] [EMPTY]] |
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, wait
hscan
sscan
zscan
xadd
hscan
sscan
zscan
xadd
ftAlter, ftAlter, ftCreate, ftCreate, ftCreate, ftSearch
jsonMGet, jsonMGet, jsonSet, jsonSet, jsonSetLegacy, jsonSetLegacy, jsonSetWithEscape, jsonSetWithEscape
cmsIncrBy
protected 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)
JedisSocketFactory
.
WARNING: Using this constructor means a NullPointerException
will be occurred if
provider
is accessed.
public UnifiedJedis(Connection connection)
Connection
.
WARNING: Using this constructor means a NullPointerException
will be occurred if
provider
is accessed.
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 UnifiedJedis(CommandExecutor executor)
CommandExecutor
.
WARNING: Using this constructor means a NullPointerException
will be occurred if
provider
is accessed.
public void close()
close
in interface AutoCloseable
public final <T> T executeCommand(CommandObject<T> commandObject)
public boolean exists(String key)
KeyCommands
Time complexity: O(1)
exists
in interface KeyCommands
true
if the key exists, false
otherwisepublic long exists(String... keys)
KeyCommands
Time complexity: O(N)
exists
in interface KeyCommands
keys
.public long persist(String key)
KeyCommands
persist
in interface KeyCommands
public String type(String key)
KeyCommands
Time complexity: O(1)
type
in interface KeyCommands
public boolean exists(byte[] key)
exists
in interface KeyBinaryCommands
public long exists(byte[]... keys)
exists
in interface KeyBinaryCommands
public long persist(byte[] key)
persist
in interface KeyBinaryCommands
public String type(byte[] key)
type
in interface KeyBinaryCommands
public byte[] dump(String key)
KeyCommands
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.
dump
in interface KeyCommands
public String restore(String key, long ttl, byte[] serializedValue)
KeyCommands
DUMP
).
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 KeyCommands
ttl
- 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)
KeyCommands
DUMP
).
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 KeyCommands
ttl
- If ttl is 0 the key is created without any expire, otherwise the specified expire
time (in milliseconds) is set.params
- RestoreParams
public byte[] dump(byte[] key)
dump
in interface KeyBinaryCommands
public String restore(byte[] key, long ttl, byte[] serializedValue)
restore
in interface KeyBinaryCommands
public String restore(byte[] key, long ttl, byte[] serializedValue, RestoreParams params)
restore
in interface KeyBinaryCommands
public long expire(String key, long seconds)
KeyCommands
Volatile 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 KeyCommands
seconds
- time to expirepublic long expire(String key, long seconds, ExpiryOption expiryOption)
KeyCommands
EXPIRE
but with optional expiry setting.expire
in interface KeyCommands
seconds
- time to expireexpiryOption
- can be NX, XX, GT or LTKeyCommands.expire(String, long)
public long pexpire(String key, long milliseconds)
KeyCommands
EXPIRE
but the time
to live of the key is specified in milliseconds instead of seconds.
Time complexity: O(1)
pexpire
in interface KeyCommands
milliseconds
- time to expirepublic long pexpire(String key, long milliseconds, ExpiryOption expiryOption)
KeyCommands
EXPIRE
but with optional expiry setting.pexpire
in interface KeyCommands
milliseconds
- time to expireexpiryOption
- can be NX, XX, GT or LTKeyCommands.pexpire(String, long)
public long expireTime(String key)
KeyCommands
The 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 KeyCommands
public long pexpireTime(String key)
KeyCommands
EXPIRETIME
but returns the absolute Unix expiration
timestamp in milliseconds instead of seconds.
Time complexity: O(1)
pexpireTime
in interface KeyCommands
KeyCommands.expireTime(String)
public long expireAt(String key, long unixTime)
KeyCommands
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).
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 KeyCommands
unixTime
- time to expirepublic long expireAt(String key, long unixTime, ExpiryOption expiryOption)
KeyCommands
expireAt
in interface KeyCommands
unixTime
- time to expireexpiryOption
- can be NX, XX, GT or LTKeyCommands.expireAt(String, long)
public long pexpireAt(String key, long millisecondsTimestamp)
KeyCommands
EXPIREAT
but
Unix time at which the key will expire is specified in milliseconds instead of seconds.
Time complexity: O(1)
pexpireAt
in interface KeyCommands
millisecondsTimestamp
- time to expirepublic long pexpireAt(String key, long millisecondsTimestamp, ExpiryOption expiryOption)
KeyCommands
pexpireAt
in interface KeyCommands
millisecondsTimestamp
- time to expireexpiryOption
- can be NX, XX, GT or LTKeyCommands.pexpireAt(String, long)
public long expire(byte[] key, long seconds)
expire
in interface KeyBinaryCommands
public long expire(byte[] key, long seconds, ExpiryOption expiryOption)
expire
in interface KeyBinaryCommands
public long pexpire(byte[] key, long milliseconds)
pexpire
in interface KeyBinaryCommands
public long pexpire(byte[] key, long milliseconds, ExpiryOption expiryOption)
pexpire
in interface KeyBinaryCommands
public long expireTime(byte[] key)
expireTime
in interface KeyBinaryCommands
public long pexpireTime(byte[] key)
pexpireTime
in interface KeyBinaryCommands
public long expireAt(byte[] key, long unixTime)
expireAt
in interface KeyBinaryCommands
public long expireAt(byte[] key, long unixTime, ExpiryOption expiryOption)
expireAt
in interface KeyBinaryCommands
public long pexpireAt(byte[] key, long millisecondsTimestamp)
pexpireAt
in interface KeyBinaryCommands
public long pexpireAt(byte[] key, long millisecondsTimestamp, ExpiryOption expiryOption)
pexpireAt
in interface KeyBinaryCommands
public long ttl(String key)
KeyCommands
EXPIRE
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 KeyCommands
public long pttl(String key)
KeyCommands
EXPIRE
set.
Time complexity: O(1)
pttl
in interface KeyCommands
public long touch(String key)
KeyCommands
Time complexity: O(N) where N is the number of keys that will be touched.
touch
in interface KeyCommands
public long touch(String... keys)
KeyCommands
Time complexity: O(N) where N is the number of keys that will be touched.
touch
in interface KeyCommands
public long ttl(byte[] key)
ttl
in interface KeyBinaryCommands
public long pttl(byte[] key)
pttl
in interface KeyBinaryCommands
public long touch(byte[] key)
touch
in interface KeyBinaryCommands
public long touch(byte[]... keys)
touch
in interface KeyBinaryCommands
public List<String> sort(String key)
KeyCommands
Sort 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 KeyCommands
KeyCommands.sort(String, SortingParams)
public List<String> sort(String key, SortingParams sortingParams)
KeyCommands
examples:
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 KeyCommands
sortingParams
- SortingParams
public long sort(String key, String dstkey)
KeyCommands
SORT
but store the result in dstkey
.sort
in interface KeyCommands
KeyCommands.sort(String)
public long sort(String key, SortingParams sortingParams, String dstkey)
KeyCommands
SORT
but store the result in dstkey
.sort
in interface KeyCommands
sortingParams
- SortingParams
KeyCommands.sort(String, SortingParams)
public List<String> sortReadonly(String key, SortingParams sortingParams)
KeyCommands
SORT
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 KeyCommands
key
- the key to sortsortingParams
- SortingParams
public List<byte[]> sort(byte[] key)
sort
in interface KeyBinaryCommands
public List<byte[]> sort(byte[] key, SortingParams sortingParams)
sort
in interface KeyBinaryCommands
public long sort(byte[] key, byte[] dstkey)
sort
in interface KeyBinaryCommands
public List<byte[]> sortReadonly(byte[] key, SortingParams sortingParams)
sortReadonly
in interface KeyBinaryCommands
public long sort(byte[] key, SortingParams sortingParams, byte[] dstkey)
sort
in interface KeyBinaryCommands
public long del(String key)
KeyCommands
Time complexity: O(1)
del
in interface KeyCommands
public long del(String... keys)
KeyCommands
Time complexity: O(N)
del
in interface KeyCommands
public long unlink(String key)
KeyCommands
DEL
: 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 KeyCommands
public long unlink(String... keys)
KeyCommands
SORT
but can be used with multiple keys.unlink
in interface KeyCommands
KeyCommands.unlink(String)
public long del(byte[] key)
del
in interface KeyBinaryCommands
public long del(byte[]... keys)
del
in interface KeyBinaryCommands
public long unlink(byte[] key)
unlink
in interface KeyBinaryCommands
public long unlink(byte[]... keys)
unlink
in interface KeyBinaryCommands
public Long memoryUsage(String key)
KeyCommands
Time complexity: O(1)
memoryUsage
in interface KeyCommands
public Long memoryUsage(String key, int samples)
KeyCommands
Time complexity: O(1)
memoryUsage
in interface KeyCommands
samples
- 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 KeyBinaryCommands
public Long memoryUsage(byte[] key, int samples)
memoryUsage
in interface KeyBinaryCommands
public boolean copy(String srcKey, String dstKey, boolean replace)
KeyCommands
copy
in interface KeyCommands
srcKey
- 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)
KeyCommands
oldkey
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 KeyCommands
public long renamenx(String oldkey, String newkey)
KeyCommands
Time complexity: O(1)
renamenx
in interface KeyCommands
public boolean copy(byte[] srcKey, byte[] dstKey, boolean replace)
copy
in interface KeyBinaryCommands
public String rename(byte[] oldkey, byte[] newkey)
rename
in interface KeyBinaryCommands
public long renamenx(byte[] oldkey, byte[] newkey)
renamenx
in interface KeyBinaryCommands
public long dbSize()
public Set<String> keys(String pattern)
KeyCommands
Note 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 KeyCommands
public ScanResult<String> scan(String cursor)
scan
in interface KeyCommands
public ScanResult<String> scan(String cursor, ScanParams params)
scan
in interface KeyCommands
public ScanResult<String> scan(String cursor, ScanParams params, String type)
scan
in interface KeyCommands
public Set<byte[]> keys(byte[] pattern)
keys
in interface KeyBinaryCommands
public ScanResult<byte[]> scan(byte[] cursor)
scan
in interface KeyBinaryCommands
public ScanResult<byte[]> scan(byte[] cursor, ScanParams params)
scan
in interface KeyBinaryCommands
public ScanResult<byte[]> scan(byte[] cursor, ScanParams params, byte[] type)
scan
in interface KeyBinaryCommands
public String randomKey()
KeyCommands
Time complexity: O(1)
randomKey
in interface KeyCommands
nil
when the database is emptypublic byte[] randomBinaryKey()
randomBinaryKey
in interface KeyBinaryCommands
public String set(String key, String value)
StringCommands
Time complexity: O(1)
set
in interface StringCommands
public String set(String key, String value, SetParams params)
StringCommands
Time complexity: O(1)<
set
in interface StringCommands
params
- SetParams
OK
if SET
was executed correctly, or null
if the SET
operation was not performed because the user specified the NX or XX option
but the condition was not met.public String get(String key)
StringCommands
Time complexity: O(1)
get
in interface StringCommands
public String setGet(String key, String value, SetParams params)
StringCommands
SetParams.get()
MUST NOT be used with this method.setGet
in interface StringCommands
public String getDel(String key)
StringCommands
Time complexity: O(1)
getDel
in interface StringCommands
public String getEx(String key, GetExParams params)
StringCommands
GET
,
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 StringCommands
params
- GetExParams
public String set(byte[] key, byte[] value)
set
in interface StringBinaryCommands
public String set(byte[] key, byte[] value, SetParams params)
set
in interface StringBinaryCommands
public byte[] get(byte[] key)
get
in interface StringBinaryCommands
public byte[] setGet(byte[] key, byte[] value, SetParams params)
StringBinaryCommands
SetParams.get()
MUST NOT be used with this method.setGet
in interface StringBinaryCommands
public byte[] getDel(byte[] key)
getDel
in interface StringBinaryCommands
public byte[] getEx(byte[] key, GetExParams params)
getEx
in interface StringBinaryCommands
public boolean setbit(String key, long offset, boolean value)
StringCommands
Time complexity: O(1)
setbit
in interface StringCommands
public boolean getbit(String key, long offset)
StringCommands
Time complexity: O(1)
getbit
in interface StringCommands
public long setrange(String key, long offset, String value)
StringCommands
Time complexity: O(1)
setrange
in interface StringCommands
public String getrange(String key, long startOffset, long endOffset)
StringCommands
Time complexity: O(N) where N is the length of the returned string
getrange
in interface StringCommands
public boolean setbit(byte[] key, long offset, boolean value)
setbit
in interface StringBinaryCommands
public boolean getbit(byte[] key, long offset)
getbit
in interface StringBinaryCommands
public long setrange(byte[] key, long offset, byte[] value)
setrange
in interface StringBinaryCommands
public byte[] getrange(byte[] key, long startOffset, long endOffset)
getrange
in interface StringBinaryCommands
public String getSet(String key, String value)
StringCommands
Time complexity: O(1)
getSet
in interface StringCommands
public long setnx(String key, String value)
StringCommands
SET
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 StringCommands
public String setex(String key, long seconds, String value)
StringCommands
SET
+ EXPIRE
.
The operation is atomic.
Time complexity: O(1)
setex
in interface StringCommands
public String psetex(String key, long milliseconds, String value)
StringCommands
SETEX
with the sole difference
that the expire time is specified in milliseconds instead of seconds.
Time complexity: O(1)
psetex
in interface StringCommands
public byte[] getSet(byte[] key, byte[] value)
getSet
in interface StringBinaryCommands
public long setnx(byte[] key, byte[] value)
setnx
in interface StringBinaryCommands
public String setex(byte[] key, long seconds, byte[] value)
setex
in interface StringBinaryCommands
public String psetex(byte[] key, long milliseconds, byte[] value)
psetex
in interface StringBinaryCommands
public long incr(String key)
StringCommands
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)
incr
in interface StringCommands
key
- the key to incrementpublic long incrBy(String key, long increment)
StringCommands
INCR
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 StringCommands
key
- the key to incrementincrement
- the value to increment bypublic double incrByFloat(String key, double increment)
StringCommands
StringCommands.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 StringCommands
key
- the key to incrementincrement
- the value to increment bypublic long decr(String key)
StringCommands
DECR 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 StringCommands
key
- the key to decrementpublic long decrBy(String key, long decrement)
StringCommands
DECR
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 StringCommands
key
- the key to decrementdecrement
- the value to decrement bypublic long incr(byte[] key)
incr
in interface StringBinaryCommands
public long incrBy(byte[] key, long increment)
incrBy
in interface StringBinaryCommands
public double incrByFloat(byte[] key, double increment)
incrByFloat
in interface StringBinaryCommands
public long decr(byte[] key)
decr
in interface StringBinaryCommands
public long decrBy(byte[] key, long decrement)
decrBy
in interface StringBinaryCommands
public List<String> mget(String... keys)
StringCommands
Time complexity: O(1) for every key
mget
in interface StringCommands
public String mset(String... keysvalues)
StringCommands
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.
mset
in interface StringCommands
keysvalues
- pairs of keys and their values
e.g mset("foo", "foovalue", "bar", "barvalue")public long msetnx(String... keysvalues)
StringCommands
MSET
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 StringCommands
keysvalues
- pairs of keys and their values
e.g msetnx("foo", "foovalue", "bar", "barvalue")public List<byte[]> mget(byte[]... keys)
mget
in interface StringBinaryCommands
public String mset(byte[]... keysvalues)
mset
in interface StringBinaryCommands
public long msetnx(byte[]... keysvalues)
msetnx
in interface StringBinaryCommands
public long append(String key, String value)
StringCommands
Time 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 StringCommands
key
- the key to append tovalue
- the value to appendpublic String substr(String key, int start, int end)
StringCommands
The 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 StringCommands
public long strlen(String key)
StringCommands
strlen
in interface StringCommands
public long append(byte[] key, byte[] value)
append
in interface StringBinaryCommands
public byte[] substr(byte[] key, int start, int end)
substr
in interface StringBinaryCommands
public long strlen(byte[] key)
strlen
in interface StringBinaryCommands
public long bitcount(String key)
StringCommands
bitcount
in interface StringCommands
public long bitcount(String key, long start, long end)
StringCommands
Like 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 StringCommands
start
- byte start indexend
- byte end indexpublic long bitcount(String key, long start, long end, BitCountOption option)
bitcount
in interface StringCommands
start
- byte start indexend
- byte end indexoption
- indicate BYTE or BITStringCommands.bitcount(String, long, long)
public long bitpos(String key, boolean value)
StringCommands
bitpos
in interface StringCommands
value
- the bit valuepublic long bitpos(String key, boolean value, BitPosParams params)
StringCommands
bitpos
in interface StringCommands
value
- the bit valueparams
- BitPosParams
public long bitcount(byte[] key)
bitcount
in interface StringBinaryCommands
public long bitcount(byte[] key, long start, long end)
bitcount
in interface StringBinaryCommands
public long bitcount(byte[] key, long start, long end, BitCountOption option)
bitcount
in interface StringBinaryCommands
public long bitpos(byte[] key, boolean value)
bitpos
in interface StringBinaryCommands
public long bitpos(byte[] key, boolean value, BitPosParams params)
bitpos
in interface StringBinaryCommands
public List<Long> bitfield(String key, String... arguments)
StringCommands
bitfield
in interface StringCommands
arguments
- may be used with optional argumentspublic List<Long> bitfieldReadonly(String key, String... arguments)
StringCommands
BITFIELD
bitfieldReadonly
in interface StringCommands
public List<Long> bitfield(byte[] key, byte[]... arguments)
bitfield
in interface StringBinaryCommands
public List<Long> bitfieldReadonly(byte[] key, byte[]... arguments)
bitfieldReadonly
in interface StringBinaryCommands
public long bitop(BitOP op, String destKey, String... srcKeys)
StringCommands
bitop
in interface StringCommands
op
- can be AND, OR, XOR or NOTpublic long bitop(BitOP op, byte[] destKey, byte[]... srcKeys)
bitop
in interface StringBinaryCommands
public LCSMatchResult strAlgoLCSKeys(String keyA, String keyB, StrAlgoLCSParams params)
StringCommands
strAlgoLCSKeys
in interface StringCommands
public LCSMatchResult strAlgoLCSKeys(byte[] keyA, byte[] keyB, StrAlgoLCSParams params)
strAlgoLCSKeys
in interface StringBinaryCommands
public LCSMatchResult lcs(String keyA, String keyB, LCSParams params)
StringCommands
lcs
in interface StringCommands
public LCSMatchResult lcs(byte[] keyA, byte[] keyB, LCSParams params)
StringBinaryCommands
lcs
in interface StringBinaryCommands
public long rpush(String key, String... string)
ListCommands
Time complexity: O(1)
rpush
in interface ListCommands
string
- data to pushpublic long lpush(String key, String... string)
ListCommands
Time complexity: O(1)
lpush
in interface ListCommands
string
- data to pushpublic long llen(String key)
ListCommands
Time complexity: O(1)
llen
in interface ListCommands
public List<String> lrange(String key, long start, long stop)
ListCommands
For 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 ListCommands
public String ltrim(String key, long start, long stop)
ListCommands
For 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 ListCommands
public String lindex(String key, long index)
ListCommands
If 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 ListCommands
public long rpush(byte[] key, byte[]... args)
rpush
in interface ListBinaryCommands
public long lpush(byte[] key, byte[]... args)
lpush
in interface ListBinaryCommands
public long llen(byte[] key)
llen
in interface ListBinaryCommands
public List<byte[]> lrange(byte[] key, long start, long stop)
lrange
in interface ListBinaryCommands
public String ltrim(byte[] key, long start, long stop)
ltrim
in interface ListBinaryCommands
public byte[] lindex(byte[] key, long index)
lindex
in interface ListBinaryCommands
public String lset(String key, long index, String value)
ListCommands
Out 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 ListCommands
public long lrem(String key, long count, String value)
ListCommands
Time complexity: O(N) (with N being the length of the list)
lrem
in interface ListCommands
public String lpop(String key)
ListCommands
If the key does not exist or the list is already empty the special value 'nil' is returned.
lpop
in interface ListCommands
public List<String> lpop(String key, int count)
ListCommands
lpop
in interface ListCommands
public String lset(byte[] key, long index, byte[] value)
lset
in interface ListBinaryCommands
public long lrem(byte[] key, long count, byte[] value)
lrem
in interface ListBinaryCommands
public byte[] lpop(byte[] key)
lpop
in interface ListBinaryCommands
public List<byte[]> lpop(byte[] key, int count)
lpop
in interface ListBinaryCommands
public Long lpos(String key, String element)
ListCommands
Time complexity: O(N) where N is the number of elements in the list
lpos
in interface ListCommands
public Long lpos(String key, String element, LPosParams params)
ListCommands
Maxlen 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 ListCommands
params
- LPosParams
public List<Long> lpos(String key, String element, LPosParams params, long count)
ListCommands
Time complexity: O(N) where N is the number of elements in the list
lpos
in interface ListCommands
params
- LPosParams
public Long lpos(byte[] key, byte[] element)
lpos
in interface ListBinaryCommands
public Long lpos(byte[] key, byte[] element, LPosParams params)
lpos
in interface ListBinaryCommands
public List<Long> lpos(byte[] key, byte[] element, LPosParams params, long count)
lpos
in interface ListBinaryCommands
public String rpop(String key)
ListCommands
rpop
in interface ListCommands
public List<String> rpop(String key, int count)
ListCommands
rpop
in interface ListCommands
count
- return up to count elementspublic byte[] rpop(byte[] key)
rpop
in interface ListBinaryCommands
public List<byte[]> rpop(byte[] key, int count)
rpop
in interface ListBinaryCommands
public long linsert(String key, ListPosition where, String pivot, String value)
ListCommands
When key does not exist, it is considered an empty list and no operation is performed.
linsert
in interface ListCommands
where
- can be BEFORE or AFTERpivot
- reference valuevalue
- the valuepublic long lpushx(String key, String... strings)
ListCommands
LPUSH
, no operation will be performed when key
does not yet exist.lpushx
in interface ListCommands
strings
- the strings to pushpublic long rpushx(String key, String... strings)
ListCommands
RPUSH
, no operation will be performed when key
does not yet exist.rpushx
in interface ListCommands
strings
- the strings to pushpublic long linsert(byte[] key, ListPosition where, byte[] pivot, byte[] value)
linsert
in interface ListBinaryCommands
public long lpushx(byte[] key, byte[]... args)
lpushx
in interface ListBinaryCommands
public long rpushx(byte[] key, byte[]... args)
rpushx
in interface ListBinaryCommands
public List<String> blpop(int timeout, String key)
blpop
in interface ListCommands
ListCommands.blpop(int, String...)
public KeyedListElement blpop(double timeout, String key)
blpop
in interface ListCommands
ListCommands.blpop(double, String...)
public List<String> brpop(int timeout, String key)
brpop
in interface ListCommands
ListCommands.brpop(int, String...)
public KeyedListElement brpop(double timeout, String key)
brpop
in interface ListCommands
ListCommands.brpop(double, String...)
public List<String> blpop(int timeout, String... keys)
ListCommands
ListCommands.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 ListCommands
timeout
- 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)
ListCommands
ListCommands.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 ListCommands
timeout
- 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)
ListCommands
ListCommands.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 ListCommands
timeout
- 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)
ListCommands
ListCommands.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 ListCommands
timeout
- 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 ListBinaryCommands
public List<byte[]> blpop(double timeout, byte[]... keys)
blpop
in interface ListBinaryCommands
public List<byte[]> brpop(int timeout, byte[]... keys)
brpop
in interface ListBinaryCommands
public List<byte[]> brpop(double timeout, byte[]... keys)
brpop
in interface ListBinaryCommands
public String rpoplpush(String srckey, String dstkey)
ListCommands
If 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 ListCommands
public String brpoplpush(String source, String destination, int timeout)
ListCommands
ListCommands.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 ListCommands
timeout
- 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 ListBinaryCommands
public byte[] brpoplpush(byte[] source, byte[] destination, int timeout)
brpoplpush
in interface ListBinaryCommands
public String lmove(String srcKey, String dstKey, ListDirection from, ListDirection to)
ListCommands
lmove
in interface ListCommands
from
- can be LEFT or RIGHTto
- can be LEFT or RIGHTpublic String blmove(String srcKey, String dstKey, ListDirection from, ListDirection to, double timeout)
ListCommands
blmove
in interface ListCommands
from
- 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 ListBinaryCommands
public byte[] blmove(byte[] srcKey, byte[] dstKey, ListDirection from, ListDirection to, double timeout)
blmove
in interface ListBinaryCommands
public KeyValue<String,List<String>> lmpop(ListDirection direction, String... keys)
lmpop
in interface ListCommands
public KeyValue<String,List<String>> lmpop(ListDirection direction, int count, String... keys)
lmpop
in interface ListCommands
public KeyValue<String,List<String>> blmpop(long timeout, ListDirection direction, String... keys)
blmpop
in interface ListCommands
public KeyValue<String,List<String>> blmpop(long timeout, ListDirection direction, int count, String... keys)
blmpop
in interface ListCommands
public KeyValue<byte[],List<byte[]>> lmpop(ListDirection direction, byte[]... keys)
lmpop
in interface ListBinaryCommands
public KeyValue<byte[],List<byte[]>> lmpop(ListDirection direction, int count, byte[]... keys)
lmpop
in interface ListBinaryCommands
public KeyValue<byte[],List<byte[]>> blmpop(long timeout, ListDirection direction, byte[]... keys)
blmpop
in interface ListBinaryCommands
public KeyValue<byte[],List<byte[]>> blmpop(long timeout, ListDirection direction, int count, byte[]... keys)
blmpop
in interface ListBinaryCommands
public long hset(String key, String field, String value)
hset
in interface HashCommands
public long hset(String key, Map<String,String> hash)
hset
in interface HashCommands
public String hget(String key, String field)
hget
in interface HashCommands
public long hsetnx(String key, String field, String value)
hsetnx
in interface HashCommands
public String hmset(String key, Map<String,String> hash)
hmset
in interface HashCommands
public List<String> hmget(String key, String... fields)
hmget
in interface HashCommands
public long hset(byte[] key, byte[] field, byte[] value)
hset
in interface HashBinaryCommands
public long hset(byte[] key, Map<byte[],byte[]> hash)
hset
in interface HashBinaryCommands
public byte[] hget(byte[] key, byte[] field)
hget
in interface HashBinaryCommands
public long hsetnx(byte[] key, byte[] field, byte[] value)
hsetnx
in interface HashBinaryCommands
public String hmset(byte[] key, Map<byte[],byte[]> hash)
hmset
in interface HashBinaryCommands
public List<byte[]> hmget(byte[] key, byte[]... fields)
hmget
in interface HashBinaryCommands
public long hincrBy(String key, String field, long value)
hincrBy
in interface HashCommands
public double hincrByFloat(String key, String field, double value)
hincrByFloat
in interface HashCommands
public boolean hexists(String key, String field)
hexists
in interface HashCommands
public long hdel(String key, String... field)
hdel
in interface HashCommands
public long hlen(String key)
hlen
in interface HashCommands
public long hincrBy(byte[] key, byte[] field, long value)
hincrBy
in interface HashBinaryCommands
public double hincrByFloat(byte[] key, byte[] field, double value)
hincrByFloat
in interface HashBinaryCommands
public boolean hexists(byte[] key, byte[] field)
hexists
in interface HashBinaryCommands
public long hdel(byte[] key, byte[]... field)
hdel
in interface HashBinaryCommands
public long hlen(byte[] key)
hlen
in interface HashBinaryCommands
public Set<String> hkeys(String key)
hkeys
in interface HashCommands
public List<String> hvals(String key)
hvals
in interface HashCommands
public Map<String,String> hgetAll(String key)
hgetAll
in interface HashCommands
public Set<byte[]> hkeys(byte[] key)
hkeys
in interface HashBinaryCommands
public List<byte[]> hvals(byte[] key)
hvals
in interface HashBinaryCommands
public Map<byte[],byte[]> hgetAll(byte[] key)
hgetAll
in interface HashBinaryCommands
public String hrandfield(String key)
hrandfield
in interface HashCommands
public List<String> hrandfield(String key, long count)
hrandfield
in interface HashCommands
public Map<String,String> hrandfieldWithValues(String key, long count)
hrandfieldWithValues
in interface HashCommands
public ScanResult<Map.Entry<String,String>> hscan(String key, String cursor, ScanParams params)
hscan
in interface HashCommands
public long hstrlen(String key, String field)
hstrlen
in interface HashCommands
public byte[] hrandfield(byte[] key)
hrandfield
in interface HashBinaryCommands
public List<byte[]> hrandfield(byte[] key, long count)
hrandfield
in interface HashBinaryCommands
public Map<byte[],byte[]> hrandfieldWithValues(byte[] key, long count)
hrandfieldWithValues
in interface HashBinaryCommands
public ScanResult<Map.Entry<byte[],byte[]>> hscan(byte[] key, byte[] cursor, ScanParams params)
hscan
in interface HashBinaryCommands
public long hstrlen(byte[] key, byte[] field)
hstrlen
in interface HashBinaryCommands
public long sadd(String key, String... members)
SetCommands
Time complexity O(1)
sadd
in interface SetCommands
public Set<String> smembers(String key)
SetCommands
SINTER
.
Time complexity O(N)
smembers
in interface SetCommands
public long srem(String key, String... members)
SetCommands
Time complexity O(1)
srem
in interface SetCommands
public 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 SetCommands
public Set<String> spop(String key, long count)
SetCommands
SetCommands.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 SetCommands
public long scard(String key)
SetCommands
scard
in interface SetCommands
public boolean sismember(String key, String member)
SetCommands
Time complexity O(1)
sismember
in interface SetCommands
true
if the element is a member of the set, false
otherwisepublic List<Boolean> smismember(String key, String... members)
SetCommands
Time complexity O(N) where N is the number of elements being checked for membership
smismember
in interface SetCommands
public long sadd(byte[] key, byte[]... members)
sadd
in interface SetBinaryCommands
public Set<byte[]> smembers(byte[] key)
smembers
in interface SetBinaryCommands
public long srem(byte[] key, byte[]... members)
srem
in interface SetBinaryCommands
public byte[] spop(byte[] key)
spop
in interface SetBinaryCommands
public Set<byte[]> spop(byte[] key, long count)
spop
in interface SetBinaryCommands
public long scard(byte[] key)
scard
in interface SetBinaryCommands
public boolean sismember(byte[] key, byte[] member)
sismember
in interface SetBinaryCommands
public List<Boolean> smismember(byte[] key, byte[]... members)
smismember
in interface SetBinaryCommands
public 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 SetCommands
public 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 SetCommands
count
- 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 SetCommands
public byte[] srandmember(byte[] key)
srandmember
in interface SetBinaryCommands
public List<byte[]> srandmember(byte[] key, int count)
srandmember
in interface SetBinaryCommands
public ScanResult<byte[]> sscan(byte[] key, byte[] cursor, ScanParams params)
sscan
in interface SetBinaryCommands
public Set<String> sdiff(String... keys)
SetCommands
keys
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 SetCommands
keys
- group of setspublic long sdiffstore(String dstkey, String... keys)
SetCommands
SDIFF
but instead of being
returned the resulting set is stored in dstkey.sdiffstore
in interface SetCommands
keys
- group of setspublic Set<String> sinter(String... keys)
SetCommands
LRANGE
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 SetCommands
keys
- group of setspublic long sinterstore(String dstkey, String... keys)
SetCommands
SINTER
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 SetCommands
keys
- group of setspublic long sintercard(String... keys)
SetCommands
SINTER
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 SetCommands
keys
- group of setspublic long sintercard(int limit, String... keys)
SetCommands
SINTER
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 SetCommands
limit
- 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)
SetCommands
LRANGE
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 SetCommands
keys
- group of setspublic long sunionstore(String dstkey, String... keys)
SetCommands
SUNION
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 SetCommands
keys
- group of setspublic long smove(String srckey, String dstkey, String member)
SetCommands
If 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 SetCommands
public Set<byte[]> sdiff(byte[]... keys)
sdiff
in interface SetBinaryCommands
public long sdiffstore(byte[] dstkey, byte[]... keys)
sdiffstore
in interface SetBinaryCommands
public Set<byte[]> sinter(byte[]... keys)
sinter
in interface SetBinaryCommands
public long sinterstore(byte[] dstkey, byte[]... keys)
sinterstore
in interface SetBinaryCommands
public long sintercard(byte[]... keys)
SetBinaryCommands
SINTER
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 SetBinaryCommands
public long sintercard(int limit, byte[]... keys)
SetBinaryCommands
SINTER
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 SetBinaryCommands
limit
- 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 SetBinaryCommands
public long sunionstore(byte[] dstkey, byte[]... keys)
sunionstore
in interface SetBinaryCommands
public long smove(byte[] srckey, byte[] dstkey, byte[] member)
smove
in interface SetBinaryCommands
public long zadd(String key, double score, String member)
SortedSetCommands
The 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 SortedSetCommands
public long zadd(String key, double score, String member, ZAddParams params)
SortedSetCommands
ZADD
but can be used with optional params.zadd
in interface SortedSetCommands
params
- ZAddParams
SortedSetCommands.zadd(String, double, String)
public long zadd(String key, Map<String,Double> scoreMembers)
SortedSetCommands
ZADD
but for multiple members.zadd
in interface SortedSetCommands
SortedSetCommands.zadd(String, double, String)
public long zadd(String key, Map<String,Double> scoreMembers, ZAddParams params)
SortedSetCommands
ZADD
but can be used with optional params,
and fits for multiple members.zadd
in interface SortedSetCommands
params
- ZAddParams
SortedSetCommands.zadd(String, double, String)
public Double zaddIncr(String key, double score, String member, ZAddParams params)
SortedSetCommands
The 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 SortedSetCommands
params
- ZAddParams
public long zadd(byte[] key, double score, byte[] member)
zadd
in interface SortedSetBinaryCommands
public long zadd(byte[] key, double score, byte[] member, ZAddParams params)
zadd
in interface SortedSetBinaryCommands
public long zadd(byte[] key, Map<byte[],Double> scoreMembers)
zadd
in interface SortedSetBinaryCommands
public long zadd(byte[] key, Map<byte[],Double> scoreMembers, ZAddParams params)
zadd
in interface SortedSetBinaryCommands
public Double zaddIncr(byte[] key, double score, byte[] member, ZAddParams params)
zaddIncr
in interface SortedSetBinaryCommands
public long zrem(String key, String... members)
SortedSetCommands
Time complexity O(log(N)) with N being the number of elements in the sorted set
zrem
in interface SortedSetCommands
public double zincrby(String key, double increment, String member)
SortedSetCommands
The 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 SortedSetCommands
public Double zincrby(String key, double increment, String member, ZIncrByParams params)
SortedSetCommands
ZINCRBY
but can be used with optionals params.zincrby
in interface SortedSetCommands
params
- ZIncrByParams
SortedSetCommands.zincrby(String, double, String)
public Long zrank(String key, String member)
SortedSetCommands
When 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 SortedSetCommands
public Long zrevrank(String key, String member)
SortedSetCommands
When 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 SortedSetCommands
public long zrem(byte[] key, byte[]... members)
zrem
in interface SortedSetBinaryCommands
public double zincrby(byte[] key, double increment, byte[] member)
zincrby
in interface SortedSetBinaryCommands
public Double zincrby(byte[] key, double increment, byte[] member, ZIncrByParams params)
zincrby
in interface SortedSetBinaryCommands
public Long zrank(byte[] key, byte[] member)
zrank
in interface SortedSetBinaryCommands
public Long zrevrank(byte[] key, byte[] member)
zrevrank
in interface SortedSetBinaryCommands
public String zrandmember(String key)
SortedSetCommands
Time complexity O(N) where N is the number of elements returned
zrandmember
in interface SortedSetCommands
public List<String> zrandmember(String key, long count)
SortedSetCommands
ZCARD
), whichever is lower.
Time complexity O(N) where N is the number of elements returned
zrandmember
in interface SortedSetCommands
count
- choose up to count elementspublic List<Tuple> zrandmemberWithScores(String key, long count)
SortedSetCommands
ZRANDMEMBER
but the replay will
include the scores with the result.zrandmemberWithScores
in interface SortedSetCommands
count
- choose up to count elementsSortedSetCommands.zrandmember(String, long)
public long zcard(String key)
SortedSetCommands
Time complexity O(1)
zcard
in interface SortedSetCommands
public Double zscore(String key, String member)
SortedSetCommands
Time complexity O(1)
zscore
in interface SortedSetCommands
public List<Double> zmscore(String key, String... members)
SortedSetCommands
Time complexity O(N) where N is the number of members being requested
zmscore
in interface SortedSetCommands
public byte[] zrandmember(byte[] key)
zrandmember
in interface SortedSetBinaryCommands
public List<byte[]> zrandmember(byte[] key, long count)
zrandmember
in interface SortedSetBinaryCommands
public List<Tuple> zrandmemberWithScores(byte[] key, long count)
zrandmemberWithScores
in interface SortedSetBinaryCommands
public long zcard(byte[] key)
zcard
in interface SortedSetBinaryCommands
public Double zscore(byte[] key, byte[] member)
zscore
in interface SortedSetBinaryCommands
public List<Double> zmscore(byte[] key, byte[]... members)
zmscore
in interface SortedSetBinaryCommands
public Tuple zpopmax(String key)
SortedSetCommands
Time complexity O(log(N)) with N being the number of elements in the sorted set
zpopmax
in interface SortedSetCommands
public List<Tuple> zpopmax(String key, int count)
SortedSetCommands
Time 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 SortedSetCommands
count
- the number of elements to poppublic Tuple zpopmin(String key)
SortedSetCommands
Time complexity O(log(N)) with N being the number of elements in the sorted set
zpopmin
in interface SortedSetCommands
public List<Tuple> zpopmin(String key, int count)
SortedSetCommands
Time 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 SortedSetCommands
count
- the number of elements to poppublic long zcount(String key, double min, double max)
SortedSetCommands
Time complexity O(log(N)) with N being the number of elements in the sorted set.
zcount
in interface SortedSetCommands
key
- the key to querymin
- minimum scoremax
- maximum scorepublic long zcount(String key, String min, String max)
SortedSetCommands
ZCOUNT
but with exclusive range.zcount
in interface SortedSetCommands
SortedSetCommands.zcount(String, double, double)
public Tuple zpopmax(byte[] key)
zpopmax
in interface SortedSetBinaryCommands
public List<Tuple> zpopmax(byte[] key, int count)
zpopmax
in interface SortedSetBinaryCommands
public Tuple zpopmin(byte[] key)
zpopmin
in interface SortedSetBinaryCommands
public List<Tuple> zpopmin(byte[] key, int count)
zpopmin
in interface SortedSetBinaryCommands
public long zcount(byte[] key, double min, double max)
zcount
in interface SortedSetBinaryCommands
public long zcount(byte[] key, byte[] min, byte[] max)
zcount
in interface SortedSetBinaryCommands
public List<String> zrange(String key, long start, long stop)
SortedSetCommands
Time 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 SortedSetCommands
key
- the key to querystart
- the minimum indexstop
- the maximum indexpublic List<String> zrevrange(String key, long start, long stop)
SortedSetCommands
Time 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 SortedSetCommands
key
- the key to querystart
- the minimum indexstop
- the maximum indexpublic List<Tuple> zrangeWithScores(String key, long start, long stop)
SortedSetCommands
zrangeWithScores
in interface SortedSetCommands
key
- the key to querystart
- the minimum indexstop
- the maximum indexpublic List<Tuple> zrevrangeWithScores(String key, long start, long stop)
SortedSetCommands
ZREVRANGE
but the reply will
include the scores of the returned elements.zrevrangeWithScores
in interface SortedSetCommands
key
- the key to querystart
- the minimum indexstop
- the maximum indexSortedSetCommands.zrevrange(String, long, long)
public List<String> zrange(String key, ZRangeParams zRangeParams)
SortedSetCommands
ZRANGE
but can be used with additional params.zrange
in interface SortedSetCommands
key
- the key to queryzRangeParams
- ZRangeParams
SortedSetCommands.zrange(String, long, long)
public List<Tuple> zrangeWithScores(String key, ZRangeParams zRangeParams)
SortedSetCommands
ZRANGE
but can be used with additional params.zrangeWithScores
in interface SortedSetCommands
key
- the key to queryzRangeParams
- ZRangeParams
SortedSetCommands.zrangeWithScores(String, long, long)
public long zrangestore(String dest, String src, ZRangeParams zRangeParams)
SortedSetCommands
ZRANGE
but stores the result in dest
.zrangestore
in interface SortedSetCommands
dest
- the storing keysrc
- the key to queryzRangeParams
- ZRangeParams
SortedSetCommands.zrange(String, ZRangeParams)
public List<String> zrangeByScore(String key, double min, double max)
SortedSetCommands
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.
zrangeByScore
in interface SortedSetCommands
key
- the key to querymin
- minimum scoremax
- maximum scorepublic List<String> zrangeByScore(String key, String min, String max)
SortedSetCommands
ZRANGE
but with exclusive range.zrangeByScore
in interface SortedSetCommands
SortedSetCommands.zrangeByScore(String, double, double)
public List<String> zrevrangeByScore(String key, double max, double min)
SortedSetCommands
The 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 SortedSetCommands
key
- the key to querymax
- maximum scoremin
- minimum scorepublic List<String> zrangeByScore(String key, double min, double max, int offset, int count)
SortedSetCommands
ZRANGE
but with exclusive range.zrangeByScore
in interface SortedSetCommands
key
- 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)
SortedSetCommands
ZREVRANGE
but with exclusive range.zrevrangeByScore
in interface SortedSetCommands
SortedSetCommands.zrevrangeByScore(String, double, double)
public List<String> zrangeByScore(String key, String min, String max, int offset, int count)
SortedSetCommands
ZRANGE
but with limit option,zrangeByScore
in interface SortedSetCommands
key
- 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)
SortedSetCommands
ZRANGE
but with limit option,zrevrangeByScore
in interface SortedSetCommands
key
- 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)
SortedSetCommands
ZRANGE
but return with scores.zrangeByScoreWithScores
in interface SortedSetCommands
key
- 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)
SortedSetCommands
ZREVRANGE
but return with scores.zrevrangeByScoreWithScores
in interface SortedSetCommands
key
- 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)
SortedSetCommands
ZRANGE
but with limit option,
and return with scores.zrangeByScoreWithScores
in interface SortedSetCommands
key
- 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)
SortedSetCommands
ZREVRANGE
but with limit option,zrevrangeByScore
in interface SortedSetCommands
key
- 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)
SortedSetCommands
ZRANGE
but with exclusive range,
and return with scores.zrangeByScoreWithScores
in interface SortedSetCommands
SortedSetCommands.zrangeByScore(String, double, double)
public List<Tuple> zrevrangeByScoreWithScores(String key, String max, String min)
SortedSetCommands
ZREVRANGE
but with exclusive range,
and return with scores.zrevrangeByScoreWithScores
in interface SortedSetCommands
SortedSetCommands.zrevrangeByScore(String, double, double)
public List<Tuple> zrangeByScoreWithScores(String key, String min, String max, int offset, int count)
SortedSetCommands
ZRANGE
but with exclusive range,
with limit options and return with scores.zrangeByScoreWithScores
in interface SortedSetCommands
key
- 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)
SortedSetCommands
ZREVRANGE
but with
limit options and return with scores.zrevrangeByScoreWithScores
in interface SortedSetCommands
key
- 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)
SortedSetCommands
ZREVRANGE
but with
exclusive range, with limit options and return with scores.zrevrangeByScoreWithScores
in interface SortedSetCommands
key
- 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 SortedSetBinaryCommands
public List<byte[]> zrevrange(byte[] key, long start, long stop)
zrevrange
in interface SortedSetBinaryCommands
public List<Tuple> zrangeWithScores(byte[] key, long start, long stop)
zrangeWithScores
in interface SortedSetBinaryCommands
public List<Tuple> zrevrangeWithScores(byte[] key, long start, long stop)
zrevrangeWithScores
in interface SortedSetBinaryCommands
public List<byte[]> zrange(byte[] key, ZRangeParams zRangeParams)
zrange
in interface SortedSetBinaryCommands
public List<Tuple> zrangeWithScores(byte[] key, ZRangeParams zRangeParams)
zrangeWithScores
in interface SortedSetBinaryCommands
public long zrangestore(byte[] dest, byte[] src, ZRangeParams zRangeParams)
zrangestore
in interface SortedSetBinaryCommands
public List<byte[]> zrangeByScore(byte[] key, double min, double max)
zrangeByScore
in interface SortedSetBinaryCommands
public List<byte[]> zrangeByScore(byte[] key, byte[] min, byte[] max)
zrangeByScore
in interface SortedSetBinaryCommands
public List<byte[]> zrevrangeByScore(byte[] key, double max, double min)
zrevrangeByScore
in interface SortedSetBinaryCommands
public List<byte[]> zrangeByScore(byte[] key, double min, double max, int offset, int count)
zrangeByScore
in interface SortedSetBinaryCommands
public List<byte[]> zrevrangeByScore(byte[] key, byte[] max, byte[] min)
zrevrangeByScore
in interface SortedSetBinaryCommands
public List<byte[]> zrangeByScore(byte[] key, byte[] min, byte[] max, int offset, int count)
zrangeByScore
in interface SortedSetBinaryCommands
public List<byte[]> zrevrangeByScore(byte[] key, double max, double min, int offset, int count)
zrevrangeByScore
in interface SortedSetBinaryCommands
public List<Tuple> zrangeByScoreWithScores(byte[] key, double min, double max)
zrangeByScoreWithScores
in interface SortedSetBinaryCommands
public List<Tuple> zrevrangeByScoreWithScores(byte[] key, double max, double min)
zrevrangeByScoreWithScores
in interface SortedSetBinaryCommands
public List<Tuple> zrangeByScoreWithScores(byte[] key, double min, double max, int offset, int count)
zrangeByScoreWithScores
in interface SortedSetBinaryCommands
public List<byte[]> zrevrangeByScore(byte[] key, byte[] max, byte[] min, int offset, int count)
zrevrangeByScore
in interface SortedSetBinaryCommands
public List<Tuple> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max)
zrangeByScoreWithScores
in interface SortedSetBinaryCommands
public List<Tuple> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min)
zrevrangeByScoreWithScores
in interface SortedSetBinaryCommands
public List<Tuple> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max, int offset, int count)
zrangeByScoreWithScores
in interface SortedSetBinaryCommands
public List<Tuple> zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset, int count)
zrevrangeByScoreWithScores
in interface SortedSetBinaryCommands
public List<Tuple> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min, int offset, int count)
zrevrangeByScoreWithScores
in interface SortedSetBinaryCommands
public long zremrangeByRank(String key, long start, long stop)
SortedSetCommands
Time 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 SortedSetCommands
public long zremrangeByScore(String key, double min, double max)
SortedSetCommands
Time 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 SortedSetCommands
min
- minimum score to removemax
- maximum score to removepublic long zremrangeByScore(String key, String min, String max)
SortedSetCommands
ZREMRANGE
but with limit option.zremrangeByScore
in interface SortedSetCommands
SortedSetCommands.zremrangeByScore(String, double, double)
public long zremrangeByRank(byte[] key, long start, long stop)
zremrangeByRank
in interface SortedSetBinaryCommands
public long zremrangeByScore(byte[] key, double min, double max)
zremrangeByScore
in interface SortedSetBinaryCommands
public long zremrangeByScore(byte[] key, byte[] min, byte[] max)
zremrangeByScore
in interface SortedSetBinaryCommands
public long zlexcount(String key, String min, String max)
SortedSetCommands
Time complexity O(log(N)) with N being the number of elements in the sorted set.
zlexcount
in interface SortedSetCommands
min
- minimum valuemax
- maximum valuepublic List<String> zrangeByLex(String key, String min, String max)
SortedSetCommands
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.
zrangeByLex
in interface SortedSetCommands
min
- minimum valuemax
- maximum valuepublic List<String> zrangeByLex(String key, String min, String max, int offset, int count)
SortedSetCommands
ZRANGE
but with limit option.zrangeByLex
in interface SortedSetCommands
min
- 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)
SortedSetCommands
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.
zrevrangeByLex
in interface SortedSetCommands
max
- maximum valuemin
- minimum valuepublic List<String> zrevrangeByLex(String key, String max, String min, int offset, int count)
SortedSetCommands
ZRANGE
but with limit option.zrevrangeByLex
in interface SortedSetCommands
max
- 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)
SortedSetCommands
Time 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 SortedSetCommands
min
- minimum value to removemax
- maximum value to removepublic long zlexcount(byte[] key, byte[] min, byte[] max)
zlexcount
in interface SortedSetBinaryCommands
public List<byte[]> zrangeByLex(byte[] key, byte[] min, byte[] max)
zrangeByLex
in interface SortedSetBinaryCommands
public List<byte[]> zrangeByLex(byte[] key, byte[] min, byte[] max, int offset, int count)
zrangeByLex
in interface SortedSetBinaryCommands
public List<byte[]> zrevrangeByLex(byte[] key, byte[] max, byte[] min)
zrevrangeByLex
in interface SortedSetBinaryCommands
public List<byte[]> zrevrangeByLex(byte[] key, byte[] max, byte[] min, int offset, int count)
zrevrangeByLex
in interface SortedSetBinaryCommands
public long zremrangeByLex(byte[] key, byte[] min, byte[] max)
zremrangeByLex
in interface SortedSetBinaryCommands
public ScanResult<Tuple> zscan(String key, String cursor, ScanParams params)
zscan
in interface SortedSetCommands
public ScanResult<Tuple> zscan(byte[] key, byte[] cursor, ScanParams params)
zscan
in interface SortedSetBinaryCommands
public KeyedZSetElement bzpopmax(double timeout, String... keys)
SortedSetCommands
ZPOPMAX
bzpopmax
in interface SortedSetCommands
timeout
- 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)
SortedSetCommands
ZPOPMIN
bzpopmin
in interface SortedSetCommands
timeout
- 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 SortedSetBinaryCommands
public List<byte[]> bzpopmin(double timeout, byte[]... keys)
bzpopmin
in interface SortedSetBinaryCommands
public Set<String> zdiff(String... keys)
SortedSetCommands
Time 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 SortedSetCommands
keys
- group of setspublic Set<Tuple> zdiffWithScores(String... keys)
SortedSetCommands
zdiffWithScores
in interface SortedSetCommands
keys
- group of setspublic long zdiffStore(String dstkey, String... keys)
SortedSetCommands
zdiffStore
in interface SortedSetCommands
keys
- group of setspublic Set<byte[]> zdiff(byte[]... keys)
zdiff
in interface SortedSetBinaryCommands
public Set<Tuple> zdiffWithScores(byte[]... keys)
zdiffWithScores
in interface SortedSetBinaryCommands
public long zdiffStore(byte[] dstkey, byte[]... keys)
zdiffStore
in interface SortedSetBinaryCommands
public long zinterstore(String dstkey, String... sets)
SortedSetCommands
zinterstore
in interface SortedSetCommands
sets
- group of setspublic long zinterstore(String dstkey, ZParams params, String... sets)
SortedSetCommands
zinterstore
in interface SortedSetCommands
params
- ZParams
sets
- group of setspublic Set<String> zinter(ZParams params, String... keys)
SortedSetCommands
Time 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 SortedSetCommands
params
- ZParams
keys
- group of setspublic Set<Tuple> zinterWithScores(ZParams params, String... keys)
SortedSetCommands
zinterWithScores
in interface SortedSetCommands
params
- ZParams
keys
- group of setspublic long zinterstore(byte[] dstkey, byte[]... sets)
zinterstore
in interface SortedSetBinaryCommands
public long zinterstore(byte[] dstkey, ZParams params, byte[]... sets)
zinterstore
in interface SortedSetBinaryCommands
public long zintercard(byte[]... keys)
SortedSetBinaryCommands
ZINTER
, 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 SortedSetBinaryCommands
keys
- group of setsSortedSetBinaryCommands#zinter(ZParams, byte[]...)
public long zintercard(long limit, byte[]... keys)
SortedSetBinaryCommands
ZINTER
, 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 SortedSetBinaryCommands
limit
- 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)
SortedSetCommands
ZINTER
, 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 SortedSetCommands
keys
- group of setsSortedSetCommands.zinter(ZParams, String...)
public long zintercard(long limit, String... keys)
SortedSetCommands
ZINTER
, 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 SortedSetCommands
limit
- 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 SortedSetBinaryCommands
public Set<Tuple> zinterWithScores(ZParams params, byte[]... keys)
zinterWithScores
in interface SortedSetBinaryCommands
public Set<String> zunion(ZParams params, String... keys)
SortedSetCommands
Time 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 SortedSetCommands
params
- ZParams
keys
- group of setspublic Set<Tuple> zunionWithScores(ZParams params, String... keys)
SortedSetCommands
zunionWithScores
in interface SortedSetCommands
params
- ZParams
keys
- group of setspublic long zunionstore(String dstkey, String... sets)
SortedSetCommands
zunionstore
in interface SortedSetCommands
sets
- group of setspublic long zunionstore(String dstkey, ZParams params, String... sets)
SortedSetCommands
zunionstore
in interface SortedSetCommands
params
- ZParams
sets
- group of setspublic Set<byte[]> zunion(ZParams params, byte[]... keys)
zunion
in interface SortedSetBinaryCommands
public Set<Tuple> zunionWithScores(ZParams params, byte[]... keys)
zunionWithScores
in interface SortedSetBinaryCommands
public long zunionstore(byte[] dstkey, byte[]... sets)
zunionstore
in interface SortedSetBinaryCommands
public long zunionstore(byte[] dstkey, ZParams params, byte[]... sets)
zunionstore
in interface SortedSetBinaryCommands
public KeyValue<String,List<Tuple>> zmpop(SortedSetOption option, String... keys)
zmpop
in interface SortedSetCommands
public KeyValue<String,List<Tuple>> zmpop(SortedSetOption option, int count, String... keys)
zmpop
in interface SortedSetCommands
public KeyValue<String,List<Tuple>> bzmpop(long timeout, SortedSetOption option, String... keys)
bzmpop
in interface SortedSetCommands
public KeyValue<String,List<Tuple>> bzmpop(long timeout, SortedSetOption option, int count, String... keys)
bzmpop
in interface SortedSetCommands
public KeyValue<byte[],List<Tuple>> zmpop(SortedSetOption option, byte[]... keys)
zmpop
in interface SortedSetBinaryCommands
public KeyValue<byte[],List<Tuple>> zmpop(SortedSetOption option, int count, byte[]... keys)
zmpop
in interface SortedSetBinaryCommands
public KeyValue<byte[],List<Tuple>> bzmpop(long timeout, SortedSetOption option, byte[]... keys)
bzmpop
in interface SortedSetBinaryCommands
public KeyValue<byte[],List<Tuple>> bzmpop(long timeout, SortedSetOption option, int count, byte[]... keys)
bzmpop
in interface SortedSetBinaryCommands
public long geoadd(String key, double longitude, double latitude, String member)
GeoCommands
Time complexity: O(log(N)) where N is the number of elements in the sorted set.
geoadd
in interface GeoCommands
public long geoadd(String key, Map<String,GeoCoordinate> memberCoordinateMap)
GeoCommands
Time complexity: O(log(N)) for each item added, where N is the number of elements in the sorted set.
geoadd
in interface GeoCommands
memberCoordinateMap
- Members names with their geo coordinatespublic long geoadd(String key, GeoAddParams params, Map<String,GeoCoordinate> memberCoordinateMap)
GeoCommands
Time complexity: O(log(N)) for each item added
geoadd
in interface GeoCommands
params
- Additional optionsmemberCoordinateMap
- Members names with their geo coordinatespublic Double geodist(String key, String member1, String member2)
GeoCommands
Time complexity: O(log(N))
geodist
in interface GeoCommands
public Double geodist(String key, String member1, String member2, GeoUnit unit)
GeoCommands
Time complexity: O(log(N))
geodist
in interface GeoCommands
unit
- can be M, KM, MI or FT can M, KM, MI or FTpublic List<String> geohash(String key, String... members)
GeoCommands
Time complexity: O(log(N)) for each member requested
geohash
in interface GeoCommands
public List<GeoCoordinate> geopos(String key, String... members)
GeoCommands
Time complexity: O(N) where N is the number of members requested.
geopos
in interface GeoCommands
public long geoadd(byte[] key, double longitude, double latitude, byte[] member)
geoadd
in interface GeoBinaryCommands
public long geoadd(byte[] key, Map<byte[],GeoCoordinate> memberCoordinateMap)
geoadd
in interface GeoBinaryCommands
public long geoadd(byte[] key, GeoAddParams params, Map<byte[],GeoCoordinate> memberCoordinateMap)
geoadd
in interface GeoBinaryCommands
public Double geodist(byte[] key, byte[] member1, byte[] member2)
geodist
in interface GeoBinaryCommands
public Double geodist(byte[] key, byte[] member1, byte[] member2, GeoUnit unit)
geodist
in interface GeoBinaryCommands
public List<byte[]> geohash(byte[] key, byte[]... members)
geohash
in interface GeoBinaryCommands
public List<GeoCoordinate> geopos(byte[] key, byte[]... members)
geopos
in interface GeoBinaryCommands
public List<GeoRadiusResponse> georadius(String key, double longitude, double latitude, double radius, GeoUnit unit)
GeoCommands
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 GeoCommands
longitude
- 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)
GeoCommands
GEORADIUS
,
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 GeoCommands
longitude
- 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)
GeoCommands
GeoRadiusParam
:
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 GeoCommands
longitude
- of the center pointlatitude
- of the center pointradius
- of the areaunit
- can be M, KM, MI or FTparam
- GeoRadiusParam
public List<GeoRadiusResponse> georadiusReadonly(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
GeoCommands
GEORADIUS
,
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 GeoCommands
longitude
- of the center pointlatitude
- of the center pointradius
- of the areaunit
- can be M, KM, MI or FTparam
- GeoRadiusParam
GeoCommands.georadius(String, double, double, double, GeoUnit, GeoRadiusParam)
public List<GeoRadiusResponse> georadiusByMember(String key, String member, double radius, GeoUnit unit)
GeoCommands
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.
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 GeoCommands
member
- 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)
GeoCommands
GEORADIUSBYMEMBER
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 GeoCommands
member
- 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)
GeoCommands
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.
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 GeoCommands
member
- represents the center of the arearadius
- of the areaunit
- can be M, KM, MI or FTparam
- GeoRadiusParam
public List<GeoRadiusResponse> georadiusByMemberReadonly(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param)
GeoCommands
GEORADIUSBYMEMBER
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 GeoCommands
member
- represents the center of the arearadius
- of the areaunit
- can be M, KM, MI or FTparam
- GeoRadiusParam
public long georadiusStore(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam)
GeoCommands
GEORADIUS
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 GeoCommands
longitude
- of the center pointlatitude
- of the center pointradius
- of the areaunit
- can be M, KM, MI or FTparam
- GeoRadiusParam
storeParam
- GeoRadiusStoreParam
public long georadiusByMemberStore(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam)
GeoCommands
GEORADIUSBYMEMBER
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 GeoCommands
member
- represents the center of the arearadius
- of the areaunit
- can be M, KM, MI or FTparam
- GeoRadiusParam
storeParam
- GeoRadiusStoreParam
public 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 GeoCommands
member
- 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 GeoCommands
coord
- 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)
GeoCommands
The 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 GeoCommands
member
- 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)
GeoCommands
The 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 GeoCommands
coord
- 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)
GeoCommands
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 GeoCommands
params
- GeoSearchParam
public long geosearchStore(String dest, String src, String member, double radius, GeoUnit unit)
GeoCommands
GEOSEARCH
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 GeoCommands
src
- 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)
GeoCommands
GEOSEARCH
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 GeoCommands
coord
- 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)
GeoCommands
GEOSEARCH
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 GeoCommands
member
- 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)
GeoCommands
GEOSEARCH
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 GeoCommands
coord
- 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)
GeoCommands
GEOSEARCH
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 GeoCommands
params
- GeoSearchParam
public long geosearchStoreStoreDist(String dest, String src, GeoSearchParam params)
GeoCommands
GEOSEARCHSTORE
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 GeoCommands
params
- GeoSearchParam
public List<GeoRadiusResponse> georadius(byte[] key, double longitude, double latitude, double radius, GeoUnit unit)
georadius
in interface GeoBinaryCommands
public List<GeoRadiusResponse> georadiusReadonly(byte[] key, double longitude, double latitude, double radius, GeoUnit unit)
georadiusReadonly
in interface GeoBinaryCommands
public List<GeoRadiusResponse> georadius(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
georadius
in interface GeoBinaryCommands
public List<GeoRadiusResponse> georadiusReadonly(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
georadiusReadonly
in interface GeoBinaryCommands
public List<GeoRadiusResponse> georadiusByMember(byte[] key, byte[] member, double radius, GeoUnit unit)
georadiusByMember
in interface GeoBinaryCommands
public List<GeoRadiusResponse> georadiusByMemberReadonly(byte[] key, byte[] member, double radius, GeoUnit unit)
georadiusByMemberReadonly
in interface GeoBinaryCommands
public List<GeoRadiusResponse> georadiusByMember(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param)
georadiusByMember
in interface GeoBinaryCommands
public List<GeoRadiusResponse> georadiusByMemberReadonly(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param)
georadiusByMemberReadonly
in interface GeoBinaryCommands
public long georadiusStore(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam)
georadiusStore
in interface GeoBinaryCommands
public long georadiusByMemberStore(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam)
georadiusByMemberStore
in interface GeoBinaryCommands
public List<GeoRadiusResponse> geosearch(byte[] key, byte[] member, double radius, GeoUnit unit)
geosearch
in interface GeoBinaryCommands
public List<GeoRadiusResponse> geosearch(byte[] key, GeoCoordinate coord, double radius, GeoUnit unit)
geosearch
in interface GeoBinaryCommands
public List<GeoRadiusResponse> geosearch(byte[] key, byte[] member, double width, double height, GeoUnit unit)
geosearch
in interface GeoBinaryCommands
public List<GeoRadiusResponse> geosearch(byte[] key, GeoCoordinate coord, double width, double height, GeoUnit unit)
geosearch
in interface GeoBinaryCommands
public List<GeoRadiusResponse> geosearch(byte[] key, GeoSearchParam params)
geosearch
in interface GeoBinaryCommands
public long geosearchStore(byte[] dest, byte[] src, byte[] member, double radius, GeoUnit unit)
geosearchStore
in interface GeoBinaryCommands
public long geosearchStore(byte[] dest, byte[] src, GeoCoordinate coord, double radius, GeoUnit unit)
geosearchStore
in interface GeoBinaryCommands
public long geosearchStore(byte[] dest, byte[] src, byte[] member, double width, double height, GeoUnit unit)
geosearchStore
in interface GeoBinaryCommands
public long geosearchStore(byte[] dest, byte[] src, GeoCoordinate coord, double width, double height, GeoUnit unit)
geosearchStore
in interface GeoBinaryCommands
public long geosearchStore(byte[] dest, byte[] src, GeoSearchParam params)
geosearchStore
in interface GeoBinaryCommands
public long geosearchStoreStoreDist(byte[] dest, byte[] src, GeoSearchParam params)
geosearchStoreStoreDist
in interface GeoBinaryCommands
public long pfadd(String key, String... elements)
pfadd
in interface HyperLogLogCommands
public String pfmerge(String destkey, String... sourcekeys)
pfmerge
in interface HyperLogLogCommands
public long pfcount(String key)
pfcount
in interface HyperLogLogCommands
public long pfcount(String... keys)
pfcount
in interface HyperLogLogCommands
public long pfadd(byte[] key, byte[]... elements)
pfadd
in interface HyperLogLogBinaryCommands
public String pfmerge(byte[] destkey, byte[]... sourcekeys)
pfmerge
in interface HyperLogLogBinaryCommands
public long pfcount(byte[] key)
pfcount
in interface HyperLogLogBinaryCommands
public long pfcount(byte[]... keys)
pfcount
in interface HyperLogLogBinaryCommands
public StreamEntryID xadd(String key, StreamEntryID id, Map<String,String> hash)
StreamCommands
xadd
in interface StreamCommands
public StreamEntryID xadd(String key, XAddParams params, Map<String,String> hash)
xadd
in interface StreamCommands
public long xlen(String key)
StreamCommands
xlen
in interface StreamCommands
public List<StreamEntry> xrange(String key, StreamEntryID start, StreamEntryID end)
StreamCommands
xrange
in interface StreamCommands
start
- 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)
StreamCommands
xrange
in interface StreamCommands
start
- 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)
StreamCommands
xrevrange
in interface StreamCommands
end
- 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)
StreamCommands
xrevrange
in interface StreamCommands
end
- 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 StreamCommands
public List<StreamEntry> xrange(String key, String start, String end, int count)
xrange
in interface StreamCommands
public List<StreamEntry> xrevrange(String key, String end, String start)
xrevrange
in interface StreamCommands
public List<StreamEntry> xrevrange(String key, String end, String start, int count)
xrevrange
in interface StreamCommands
public long xack(String key, String group, StreamEntryID... ids)
StreamCommands
xack
in interface StreamCommands
public String xgroupCreate(String key, String groupName, StreamEntryID id, boolean makeStream)
StreamCommands
xgroupCreate
in interface StreamCommands
public String xgroupSetID(String key, String groupName, StreamEntryID id)
StreamCommands
xgroupSetID
in interface StreamCommands
public long xgroupDestroy(String key, String groupName)
StreamCommands
xgroupDestroy
in interface StreamCommands
public boolean xgroupCreateConsumer(String key, String groupName, String consumerName)
StreamCommands
xgroupCreateConsumer
in interface StreamCommands
public long xgroupDelConsumer(String key, String groupName, String consumerName)
StreamCommands
xgroupDelConsumer
in interface StreamCommands
public StreamPendingSummary xpending(String key, String groupName)
StreamCommands
xpending
in interface StreamCommands
public List<StreamPendingEntry> xpending(String key, String groupName, StreamEntryID start, StreamEntryID end, int count, String consumerName)
StreamCommands
xpending
in interface StreamCommands
public List<StreamPendingEntry> xpending(String key, String groupName, XPendingParams params)
StreamCommands
xpending
in interface StreamCommands
public long xdel(String key, StreamEntryID... ids)
StreamCommands
xdel
in interface StreamCommands
public long xtrim(String key, long maxLen, boolean approximate)
StreamCommands
xtrim
in interface StreamCommands
public long xtrim(String key, XTrimParams params)
StreamCommands
xtrim
in interface StreamCommands
public List<StreamEntry> xclaim(String key, String group, String consumerName, long minIdleTime, XClaimParams params, StreamEntryID... ids)
StreamCommands
xclaim
in interface StreamCommands
public List<StreamEntryID> xclaimJustId(String key, String group, String consumerName, long minIdleTime, XClaimParams params, StreamEntryID... ids)
StreamCommands
xclaimJustId
in interface StreamCommands
public Map.Entry<StreamEntryID,List<StreamEntry>> xautoclaim(String key, String group, String consumerName, long minIdleTime, StreamEntryID start, XAutoClaimParams params)
StreamCommands
xautoclaim
in interface StreamCommands
key
- 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
- XAutoClaimParams
public Map.Entry<StreamEntryID,List<StreamEntryID>> xautoclaimJustId(String key, String group, String consumerName, long minIdleTime, StreamEntryID start, XAutoClaimParams params)
StreamCommands
xautoclaimJustId
in interface StreamCommands
key
- 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
- XAutoClaimParams
public StreamInfo xinfoStream(String key)
StreamCommands
xinfoStream
in interface StreamCommands
key
- Stream nameStreamInfo
that contains information about the streampublic StreamFullInfo xinfoStreamFull(String key)
StreamCommands
xinfoStreamFull
in interface StreamCommands
key
- Stream nameStreamFullInfo
that contains information about the streampublic StreamFullInfo xinfoStreamFull(String key, int count)
StreamCommands
xinfoStreamFull
in interface StreamCommands
key
- Stream namecount
- stream info countStreamFullInfo
that contains information about the stream@Deprecated public List<StreamGroupInfo> xinfoGroup(String key)
xinfoGroup
in interface StreamCommands
public List<StreamGroupInfo> xinfoGroups(String key)
StreamCommands
xinfoGroups
in interface StreamCommands
key
- Stream nameStreamGroupInfo
containing information about groupspublic List<StreamConsumersInfo> xinfoConsumers(String key, String group)
StreamCommands
xinfoConsumers
in interface StreamCommands
key
- 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)
StreamCommands
xread
in interface StreamCommands
public List<Map.Entry<String,List<StreamEntry>>> xreadGroup(String groupName, String consumer, XReadGroupParams xReadGroupParams, Map<String,StreamEntryID> streams)
StreamCommands
xreadGroup
in interface StreamCommands
public byte[] xadd(byte[] key, XAddParams params, Map<byte[],byte[]> hash)
xadd
in interface StreamBinaryCommands
public long xlen(byte[] key)
xlen
in interface StreamBinaryCommands
public List<byte[]> xrange(byte[] key, byte[] start, byte[] end)
xrange
in interface StreamBinaryCommands
public List<byte[]> xrange(byte[] key, byte[] start, byte[] end, int count)
xrange
in interface StreamBinaryCommands
public List<byte[]> xrevrange(byte[] key, byte[] end, byte[] start)
xrevrange
in interface StreamBinaryCommands
public List<byte[]> xrevrange(byte[] key, byte[] end, byte[] start, int count)
xrevrange
in interface StreamBinaryCommands
public long xack(byte[] key, byte[] group, byte[]... ids)
xack
in interface StreamBinaryCommands
public String xgroupCreate(byte[] key, byte[] groupName, byte[] id, boolean makeStream)
xgroupCreate
in interface StreamBinaryCommands
public String xgroupSetID(byte[] key, byte[] groupName, byte[] id)
xgroupSetID
in interface StreamBinaryCommands
public long xgroupDestroy(byte[] key, byte[] groupName)
xgroupDestroy
in interface StreamBinaryCommands
public boolean xgroupCreateConsumer(byte[] key, byte[] groupName, byte[] consumerName)
xgroupCreateConsumer
in interface StreamBinaryCommands
public long xgroupDelConsumer(byte[] key, byte[] groupName, byte[] consumerName)
xgroupDelConsumer
in interface StreamBinaryCommands
public long xdel(byte[] key, byte[]... ids)
xdel
in interface StreamBinaryCommands
public long xtrim(byte[] key, long maxLen, boolean approximateLength)
xtrim
in interface StreamBinaryCommands
public long xtrim(byte[] key, XTrimParams params)
xtrim
in interface StreamBinaryCommands
public Object xpending(byte[] key, byte[] groupName)
xpending
in interface StreamBinaryCommands
public List<Object> xpending(byte[] key, byte[] groupName, byte[] start, byte[] end, int count, byte[] consumerName)
xpending
in interface StreamBinaryCommands
public List<Object> xpending(byte[] key, byte[] groupName, XPendingParams params)
xpending
in interface StreamBinaryCommands
public List<byte[]> xclaim(byte[] key, byte[] group, byte[] consumerName, long minIdleTime, XClaimParams params, byte[]... ids)
xclaim
in interface StreamBinaryCommands
public List<byte[]> xclaimJustId(byte[] key, byte[] group, byte[] consumerName, long minIdleTime, XClaimParams params, byte[]... ids)
xclaimJustId
in interface StreamBinaryCommands
public List<Object> xautoclaim(byte[] key, byte[] groupName, byte[] consumerName, long minIdleTime, byte[] start, XAutoClaimParams params)
xautoclaim
in interface StreamBinaryCommands
public List<Object> xautoclaimJustId(byte[] key, byte[] groupName, byte[] consumerName, long minIdleTime, byte[] start, XAutoClaimParams params)
xautoclaimJustId
in interface StreamBinaryCommands
public Object xinfoStream(byte[] key)
xinfoStream
in interface StreamBinaryCommands
public Object xinfoStreamFull(byte[] key)
StreamBinaryCommands
xinfoStreamFull
in interface StreamBinaryCommands
key
- Stream namepublic Object xinfoStreamFull(byte[] key, int count)
StreamBinaryCommands
xinfoStreamFull
in interface StreamBinaryCommands
key
- Stream namecount
- stream info count@Deprecated public List<Object> xinfoGroup(byte[] key)
xinfoGroup
in interface StreamBinaryCommands
public List<Object> xinfoGroups(byte[] key)
xinfoGroups
in interface StreamBinaryCommands
public List<Object> xinfoConsumers(byte[] key, byte[] group)
xinfoConsumers
in interface StreamBinaryCommands
public List<byte[]> xread(XReadParams xReadParams, Map.Entry<byte[],byte[]>... streams)
xread
in interface StreamBinaryCommands
public List<byte[]> xreadGroup(byte[] groupName, byte[] consumer, XReadGroupParams xReadGroupParams, Map.Entry<byte[],byte[]>... streams)
xreadGroup
in interface StreamBinaryCommands
public Object eval(String script)
ScriptingKeyCommands
eval
in interface ScriptingKeyCommands
script
- 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)
ScriptingKeyCommands
eval
in interface ScriptingKeyCommands
script
- 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)
ScriptingKeyCommands
eval
in interface ScriptingKeyCommands
script
- 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)
ScriptingKeyCommands
EVAL
evalReadonly
in interface ScriptingKeyCommands
script
- 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)
ScriptingKeyCommands
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 ScriptingKeyCommands
sha1
- the scriptScriptingKeyCommands.eval(String)
public Object evalsha(String sha1, int keyCount, String... params)
ScriptingKeyCommands
ScriptingKeyCommands.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 ScriptingKeyCommands
sha1
- the scriptScriptingKeyCommands.eval(String, int, String...)
public Object evalsha(String sha1, List<String> keys, List<String> args)
ScriptingKeyCommands
ScriptingKeyCommands.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 ScriptingKeyCommands
sha1
- the scriptScriptingKeyCommands.eval(String, List, List)
public Object evalshaReadonly(String sha1, List<String> keys, List<String> args)
ScriptingKeyCommands
EVAL
evalshaReadonly
in interface ScriptingKeyCommands
sha1
- the scriptScriptingKeyCommands.evalsha(String, List, List)
public Object eval(byte[] script)
eval
in interface ScriptingKeyBinaryCommands
public Object eval(byte[] script, int keyCount, byte[]... params)
eval
in interface ScriptingKeyBinaryCommands
public Object eval(byte[] script, List<byte[]> keys, List<byte[]> args)
eval
in interface ScriptingKeyBinaryCommands
public Object evalReadonly(byte[] script, List<byte[]> keys, List<byte[]> args)
evalReadonly
in interface ScriptingKeyBinaryCommands
public Object evalsha(byte[] sha1)
evalsha
in interface ScriptingKeyBinaryCommands
public Object evalsha(byte[] sha1, int keyCount, byte[]... params)
evalsha
in interface ScriptingKeyBinaryCommands
public Object evalsha(byte[] sha1, List<byte[]> keys, List<byte[]> args)
evalsha
in interface ScriptingKeyBinaryCommands
public Object evalshaReadonly(byte[] sha1, List<byte[]> keys, List<byte[]> args)
evalshaReadonly
in interface ScriptingKeyBinaryCommands
public Object fcall(String name, List<String> keys, List<String> args)
FunctionCommands
fcall
in interface FunctionCommands
public Object fcallReadonly(String name, List<String> keys, List<String> args)
FunctionCommands
FCALL
command that cannot execute commands that modify data.fcallReadonly
in interface FunctionCommands
public String functionDelete(String libraryName)
FunctionCommands
functionDelete
in interface FunctionCommands
public String functionFlush()
FunctionCommands
functionFlush
in interface FunctionBinaryCommands
functionFlush
in interface FunctionCommands
public String functionFlush(FlushMode mode)
FunctionCommands
functionFlush
in interface FunctionBinaryCommands
functionFlush
in interface FunctionCommands
mode
- ASYNC: Asynchronously flush the libraries, SYNC: Synchronously flush the libraries.public String functionKill()
FunctionCommands
functionKill
in interface FunctionBinaryCommands
functionKill
in interface FunctionCommands
public List<LibraryInfo> functionList()
FunctionCommands
functionList
in interface FunctionCommands
LibraryInfo
public List<LibraryInfo> functionList(String libraryNamePattern)
FunctionCommands
functionList
in interface FunctionCommands
libraryNamePattern
- a pattern for matching library namesLibraryInfo
public List<LibraryInfo> functionListWithCode()
FunctionCommands
FUNCTION LIST
but include the
libraries source implementation in the reply.functionListWithCode
in interface FunctionCommands
LibraryInfo
FunctionCommands.functionList()
public List<LibraryInfo> functionListWithCode(String libraryNamePattern)
FunctionCommands
FUNCTION LIST
but include the
libraries source implementation in the reply.functionListWithCode
in interface FunctionCommands
libraryNamePattern
- a pattern for matching library namesLibraryInfo
FunctionCommands.functionList(String)
public String functionLoad(String functionCode)
FunctionCommands
functionLoad
in interface FunctionCommands
functionCode
- 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)
FunctionCommands
functionLoadReplace
in interface FunctionCommands
functionCode
- the source codepublic FunctionStats functionStats()
FunctionCommands
functionStats
in interface FunctionCommands
FunctionStats
public Object fcall(byte[] name, List<byte[]> keys, List<byte[]> args)
FunctionBinaryCommands
fcall
in interface FunctionBinaryCommands
public Object fcallReadonly(byte[] name, List<byte[]> keys, List<byte[]> args)
fcallReadonly
in interface FunctionBinaryCommands
public String functionDelete(byte[] libraryName)
FunctionBinaryCommands
functionDelete
in interface FunctionBinaryCommands
public byte[] functionDump()
FunctionCommands
FUNCTION RESTORE
command.functionDump
in interface FunctionBinaryCommands
functionDump
in interface FunctionCommands
public List<Object> functionListBinary()
FunctionBinaryCommands
functionListBinary
in interface FunctionBinaryCommands
LibraryInfo
public List<Object> functionList(byte[] libraryNamePattern)
FunctionBinaryCommands
functionList
in interface FunctionBinaryCommands
libraryNamePattern
- a pattern for matching library namesLibraryInfo
public List<Object> functionListWithCodeBinary()
FunctionBinaryCommands
FUNCTION LIST
but include the
libraries source implementation in the reply.functionListWithCodeBinary
in interface FunctionBinaryCommands
LibraryInfo
FunctionCommands.functionList()
public List<Object> functionListWithCode(byte[] libraryNamePattern)
FunctionBinaryCommands
FUNCTION LIST
but include the
libraries source implementation in the reply.functionListWithCode
in interface FunctionBinaryCommands
libraryNamePattern
- a pattern for matching library namesLibraryInfo
FunctionBinaryCommands.functionList(byte[])
public String functionLoad(byte[] functionCode)
FunctionBinaryCommands
functionLoad
in interface FunctionBinaryCommands
functionCode
- 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)
FunctionBinaryCommands
functionLoadReplace
in interface FunctionBinaryCommands
functionCode
- the source codepublic String functionRestore(byte[] serializedValue)
FunctionCommands
functionRestore
in interface FunctionBinaryCommands
functionRestore
in interface FunctionCommands
serializedValue
- the serialized payloadpublic String functionRestore(byte[] serializedValue, FunctionRestorePolicy policy)
FunctionCommands
functionRestore
in interface FunctionBinaryCommands
functionRestore
in interface FunctionCommands
serializedValue
- the serialized payloadpolicy
- can be FLUSH, APPEND or REPLACE
public Object functionStatsBinary()
FunctionBinaryCommands
functionStatsBinary
in interface FunctionBinaryCommands
FunctionStats
public Long objectRefcount(String key)
KeyCommands
Time complexity: O(1)
objectRefcount
in interface KeyCommands
public String objectEncoding(String key)
KeyCommands
Time complexity: O(1)
objectEncoding
in interface KeyCommands
public Long objectIdletime(String key)
KeyCommands
Time complexity: O(1)
objectIdletime
in interface KeyCommands
public Long objectFreq(String key)
KeyCommands
Time complexity: O(1)
objectFreq
in interface KeyCommands
public Long objectRefcount(byte[] key)
objectRefcount
in interface KeyBinaryCommands
public byte[] objectEncoding(byte[] key)
objectEncoding
in interface KeyBinaryCommands
public Long objectIdletime(byte[] key)
objectIdletime
in interface KeyBinaryCommands
public Long objectFreq(byte[] key)
objectFreq
in interface KeyBinaryCommands
public String migrate(String host, int port, String key, int timeout)
KeyCommands
migrate
in interface KeyCommands
timeout
- 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)
KeyCommands
migrate
in interface KeyCommands
timeout
- the maximum idle time in any moment of the communication with the
destination instance in milliseconds.params
- MigrateParams
public String migrate(String host, int port, byte[] key, int timeout)
migrate
in interface KeyBinaryCommands
public String migrate(String host, int port, int timeout, MigrateParams params, byte[]... keys)
migrate
in interface KeyBinaryCommands
public long waitReplicas(String sampleKey, int replicas, long timeout)
waitReplicas
in interface SampleKeyedCommands
public long waitReplicas(byte[] sampleKey, int replicas, long timeout)
waitReplicas
in interface SampleBinaryKeyedCommands
public Object eval(String script, String sampleKey)
eval
in interface SampleKeyedCommands
public Object evalsha(String sha1, String sampleKey)
evalsha
in interface SampleKeyedCommands
public Object eval(byte[] script, byte[] sampleKey)
eval
in interface SampleBinaryKeyedCommands
public Object evalsha(byte[] sha1, byte[] sampleKey)
evalsha
in interface SampleBinaryKeyedCommands
public Boolean scriptExists(String sha1, String sampleKey)
scriptExists
in interface SampleKeyedCommands
public List<Boolean> scriptExists(String sampleKey, String... sha1s)
scriptExists
in interface SampleKeyedCommands
public Boolean scriptExists(byte[] sha1, byte[] sampleKey)
scriptExists
in interface SampleBinaryKeyedCommands
public List<Boolean> scriptExists(byte[] sampleKey, byte[]... sha1s)
scriptExists
in interface SampleBinaryKeyedCommands
public String scriptLoad(String script, String sampleKey)
scriptLoad
in interface SampleKeyedCommands
public String scriptFlush(String sampleKey)
scriptFlush
in interface SampleKeyedCommands
public String scriptFlush(String sampleKey, FlushMode flushMode)
scriptFlush
in interface SampleKeyedCommands
public String scriptKill(String sampleKey)
scriptKill
in interface SampleKeyedCommands
public byte[] scriptLoad(byte[] script, byte[] sampleKey)
scriptLoad
in interface SampleBinaryKeyedCommands
public String scriptFlush(byte[] sampleKey)
scriptFlush
in interface SampleBinaryKeyedCommands
public String scriptFlush(byte[] sampleKey, FlushMode flushMode)
scriptFlush
in interface SampleBinaryKeyedCommands
public String scriptKill(byte[] sampleKey)
scriptKill
in interface SampleBinaryKeyedCommands
public 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 RediSearchCommands
public String ftCreate(String indexName, FTCreateParams createParams, Iterable<SchemaField> schemaFields)
ftCreate
in interface RediSearchCommands
public String ftAlter(String indexName, Schema schema)
ftAlter
in interface RediSearchCommands
public String ftAlter(String indexName, Iterable<SchemaField> schemaFields)
ftAlter
in interface RediSearchCommands
public SearchResult ftSearch(String indexName, String query)
ftSearch
in interface RediSearchCommands
public SearchResult ftSearch(String indexName, String query, FTSearchParams params)
ftSearch
in interface RediSearchCommands
public SearchResult ftSearch(String indexName, Query query)
ftSearch
in interface RediSearchCommands
public SearchResult ftSearch(byte[] indexName, Query query)
ftSearch
in interface RediSearchCommands
public String ftExplain(String indexName, Query query)
ftExplain
in interface RediSearchCommands
public List<String> ftExplainCLI(String indexName, Query query)
ftExplainCLI
in interface RediSearchCommands
public AggregationResult ftAggregate(String indexName, AggregationBuilder aggr)
ftAggregate
in interface RediSearchCommands
public AggregationResult ftCursorRead(String indexName, long cursorId, int count)
ftCursorRead
in interface RediSearchCommands
public String ftCursorDel(String indexName, long cursorId)
ftCursorDel
in interface RediSearchCommands
public Map.Entry<AggregationResult,Map<String,Object>> ftProfileAggregate(String indexName, FTProfileParams profileParams, AggregationBuilder aggr)
ftProfileAggregate
in interface RediSearchCommands
public Map.Entry<SearchResult,Map<String,Object>> ftProfileSearch(String indexName, FTProfileParams profileParams, Query query)
ftProfileSearch
in interface RediSearchCommands
public Map.Entry<SearchResult,Map<String,Object>> ftProfileSearch(String indexName, FTProfileParams profileParams, String query, FTSearchParams searchParams)
ftProfileSearch
in interface RediSearchCommands
public String ftDropIndex(String indexName)
ftDropIndex
in interface RediSearchCommands
public String ftDropIndexDD(String indexName)
ftDropIndexDD
in interface RediSearchCommands
public String ftSynUpdate(String indexName, String synonymGroupId, String... terms)
ftSynUpdate
in interface RediSearchCommands
public Map<String,List<String>> ftSynDump(String indexName)
ftSynDump
in interface RediSearchCommands
public long ftDictAdd(String dictionary, String... terms)
ftDictAdd
in interface RediSearchCommands
public long ftDictDel(String dictionary, String... terms)
ftDictDel
in interface RediSearchCommands
public Set<String> ftDictDump(String dictionary)
ftDictDump
in interface RediSearchCommands
public long ftDictAddBySampleKey(String indexName, String dictionary, String... terms)
ftDictAddBySampleKey
in interface RediSearchCommands
public long ftDictDelBySampleKey(String indexName, String dictionary, String... terms)
ftDictDelBySampleKey
in interface RediSearchCommands
public Set<String> ftDictDumpBySampleKey(String indexName, String dictionary)
ftDictDumpBySampleKey
in interface RediSearchCommands
public Map<String,Map<String,Double>> ftSpellCheck(String index, String query)
ftSpellCheck
in interface RediSearchCommands
public Map<String,Map<String,Double>> ftSpellCheck(String index, String query, FTSpellCheckParams spellCheckParams)
ftSpellCheck
in interface RediSearchCommands
public Map<String,Object> ftInfo(String indexName)
ftInfo
in interface RediSearchCommands
public Set<String> ftTagVals(String indexName, String fieldName)
ftTagVals
in interface RediSearchCommands
public String ftAliasAdd(String aliasName, String indexName)
ftAliasAdd
in interface RediSearchCommands
public String ftAliasUpdate(String aliasName, String indexName)
ftAliasUpdate
in interface RediSearchCommands
public String ftAliasDel(String aliasName)
ftAliasDel
in interface RediSearchCommands
public Map<String,String> ftConfigGet(String option)
ftConfigGet
in interface RediSearchCommands
public Map<String,String> ftConfigGet(String indexName, String option)
ftConfigGet
in interface RediSearchCommands
public String ftConfigSet(String option, String value)
ftConfigSet
in interface RediSearchCommands
public String ftConfigSet(String indexName, String option, String value)
ftConfigSet
in interface RediSearchCommands
public long ftSugAdd(String key, String string, double score)
ftSugAdd
in interface RediSearchCommands
public long ftSugAddIncr(String key, String string, double score)
ftSugAddIncr
in interface RediSearchCommands
public List<String> ftSugGet(String key, String prefix)
ftSugGet
in interface RediSearchCommands
public List<String> ftSugGet(String key, String prefix, boolean fuzzy, int max)
ftSugGet
in interface RediSearchCommands
public List<Tuple> ftSugGetWithScores(String key, String prefix)
ftSugGetWithScores
in interface RediSearchCommands
public List<Tuple> ftSugGetWithScores(String key, String prefix, boolean fuzzy, int max)
ftSugGetWithScores
in interface RediSearchCommands
public boolean ftSugDel(String key, String string)
ftSugDel
in interface RediSearchCommands
public long ftSugLen(String key)
ftSugLen
in interface RediSearchCommands
public List<String> ftList()
ftList
in interface RediSearchCommands
public String jsonSet(String key, Path2 path, Object object)
jsonSet
in interface RedisJsonCommands
public String jsonSetWithEscape(String key, Path2 path, Object object)
jsonSetWithEscape
in interface RedisJsonCommands
public String jsonSet(String key, Path path, Object pojo)
jsonSet
in interface RedisJsonCommands
public String jsonSetWithPlainString(String key, Path path, String string)
jsonSetWithPlainString
in interface RedisJsonCommands
public String jsonSet(String key, Path2 path, Object pojo, JsonSetParams params)
jsonSet
in interface RedisJsonCommands
public String jsonSetWithEscape(String key, Path2 path, Object pojo, JsonSetParams params)
jsonSetWithEscape
in interface RedisJsonCommands
public String jsonSet(String key, Path path, Object pojo, JsonSetParams params)
jsonSet
in interface RedisJsonCommands
public Object jsonGet(String key)
jsonGet
in interface RedisJsonCommands
public <T> T jsonGet(String key, Class<T> clazz)
jsonGet
in interface RedisJsonCommands
public Object jsonGet(String key, Path2... paths)
jsonGet
in interface RedisJsonCommands
public Object jsonGet(String key, Path... paths)
jsonGet
in interface RedisJsonCommands
public String jsonGetAsPlainString(String key, Path path)
jsonGetAsPlainString
in interface RedisJsonCommands
public <T> T jsonGet(String key, Class<T> clazz, Path... paths)
jsonGet
in interface RedisJsonCommands
public List<org.json.JSONArray> jsonMGet(Path2 path, String... keys)
jsonMGet
in interface RedisJsonCommands
public <T> List<T> jsonMGet(Path path, Class<T> clazz, String... keys)
jsonMGet
in interface RedisJsonCommands
public long jsonDel(String key)
jsonDel
in interface RedisJsonCommands
public long jsonDel(String key, Path2 path)
jsonDel
in interface RedisJsonCommands
public long jsonDel(String key, Path path)
jsonDel
in interface RedisJsonCommands
public long jsonClear(String key)
jsonClear
in interface RedisJsonCommands
public long jsonClear(String key, Path2 path)
jsonClear
in interface RedisJsonCommands
public long jsonClear(String key, Path path)
jsonClear
in interface RedisJsonCommands
public List<Boolean> jsonToggle(String key, Path2 path)
jsonToggle
in interface RedisJsonCommands
public String jsonToggle(String key, Path path)
jsonToggle
in interface RedisJsonCommands
public Class<?> jsonType(String key)
jsonType
in interface RedisJsonCommands
public List<Class<?>> jsonType(String key, Path2 path)
jsonType
in interface RedisJsonCommands
public Class<?> jsonType(String key, Path path)
jsonType
in interface RedisJsonCommands
public long jsonStrAppend(String key, Object string)
jsonStrAppend
in interface RedisJsonCommands
public List<Long> jsonStrAppend(String key, Path2 path, Object string)
jsonStrAppend
in interface RedisJsonCommands
public long jsonStrAppend(String key, Path path, Object string)
jsonStrAppend
in interface RedisJsonCommands
public Long jsonStrLen(String key)
jsonStrLen
in interface RedisJsonCommands
public List<Long> jsonStrLen(String key, Path2 path)
jsonStrLen
in interface RedisJsonCommands
public Long jsonStrLen(String key, Path path)
jsonStrLen
in interface RedisJsonCommands
public org.json.JSONArray jsonNumIncrBy(String key, Path2 path, double value)
jsonNumIncrBy
in interface RedisJsonCommands
public double jsonNumIncrBy(String key, Path path, double value)
jsonNumIncrBy
in interface RedisJsonCommands
public List<Long> jsonArrAppend(String key, Path2 path, Object... objects)
jsonArrAppend
in interface RedisJsonCommands
public List<Long> jsonArrAppendWithEscape(String key, Path2 path, Object... objects)
jsonArrAppendWithEscape
in interface RedisJsonCommands
public Long jsonArrAppend(String key, Path path, Object... pojos)
jsonArrAppend
in interface RedisJsonCommands
public List<Long> jsonArrIndex(String key, Path2 path, Object scalar)
jsonArrIndex
in interface RedisJsonCommands
public List<Long> jsonArrIndexWithEscape(String key, Path2 path, Object scalar)
jsonArrIndexWithEscape
in interface RedisJsonCommands
public long jsonArrIndex(String key, Path path, Object scalar)
jsonArrIndex
in interface RedisJsonCommands
public List<Long> jsonArrInsert(String key, Path2 path, int index, Object... objects)
jsonArrInsert
in interface RedisJsonCommands
public List<Long> jsonArrInsertWithEscape(String key, Path2 path, int index, Object... objects)
jsonArrInsertWithEscape
in interface RedisJsonCommands
public long jsonArrInsert(String key, Path path, int index, Object... pojos)
jsonArrInsert
in interface RedisJsonCommands
public Object jsonArrPop(String key)
jsonArrPop
in interface RedisJsonCommands
public <T> T jsonArrPop(String key, Class<T> clazz)
jsonArrPop
in interface RedisJsonCommands
public List<Object> jsonArrPop(String key, Path2 path)
jsonArrPop
in interface RedisJsonCommands
public Object jsonArrPop(String key, Path path)
jsonArrPop
in interface RedisJsonCommands
public <T> T jsonArrPop(String key, Class<T> clazz, Path path)
jsonArrPop
in interface RedisJsonCommands
public List<Object> jsonArrPop(String key, Path2 path, int index)
jsonArrPop
in interface RedisJsonCommands
public Object jsonArrPop(String key, Path path, int index)
jsonArrPop
in interface RedisJsonCommands
public <T> T jsonArrPop(String key, Class<T> clazz, Path path, int index)
jsonArrPop
in interface RedisJsonCommands
public Long jsonArrLen(String key)
jsonArrLen
in interface RedisJsonCommands
public List<Long> jsonArrLen(String key, Path2 path)
jsonArrLen
in interface RedisJsonCommands
public Long jsonArrLen(String key, Path path)
jsonArrLen
in interface RedisJsonCommands
public List<Long> jsonArrTrim(String key, Path2 path, int start, int stop)
jsonArrTrim
in interface RedisJsonCommands
public Long jsonArrTrim(String key, Path path, int start, int stop)
jsonArrTrim
in interface RedisJsonCommands
public Long jsonObjLen(String key)
jsonObjLen
in interface RedisJsonCommands
public Long jsonObjLen(String key, Path path)
jsonObjLen
in interface RedisJsonCommands
public List<Long> jsonObjLen(String key, Path2 path)
jsonObjLen
in interface RedisJsonCommands
public List<String> jsonObjKeys(String key)
jsonObjKeys
in interface RedisJsonCommands
public List<String> jsonObjKeys(String key, Path path)
jsonObjKeys
in interface RedisJsonCommands
public List<List<String>> jsonObjKeys(String key, Path2 path)
jsonObjKeys
in interface RedisJsonCommands
public long jsonDebugMemory(String key)
jsonDebugMemory
in interface RedisJsonCommands
public long jsonDebugMemory(String key, Path path)
jsonDebugMemory
in interface RedisJsonCommands
public List<Long> jsonDebugMemory(String key, Path2 path)
jsonDebugMemory
in interface RedisJsonCommands
public List<Object> jsonResp(String key)
jsonResp
in interface RedisJsonCommands
public List<Object> jsonResp(String key, Path path)
jsonResp
in interface RedisJsonCommands
public List<List<Object>> jsonResp(String key, Path2 path)
jsonResp
in interface RedisJsonCommands
public String tsCreate(String key)
RedisTimeSeriesCommands
TS.CREATE key
tsCreate
in interface RedisTimeSeriesCommands
public String tsCreate(String key, TSCreateParams createParams)
RedisTimeSeriesCommands
TS.CREATE key [RETENTION retentionTime] [ENCODING [UNCOMPRESSED|COMPRESSED]] [CHUNK_SIZE size] [DUPLICATE_POLICY policy] [LABELS label value..]
tsCreate
in interface RedisTimeSeriesCommands
public long tsDel(String key, long fromTimestamp, long toTimestamp)
RedisTimeSeriesCommands
TS.DEL key fromTimestamp toTimestamp
tsDel
in interface RedisTimeSeriesCommands
public String tsAlter(String key, TSAlterParams alterParams)
RedisTimeSeriesCommands
TS.ALTER key [RETENTION retentionTime] [LABELS label value..]
tsAlter
in interface RedisTimeSeriesCommands
public long tsAdd(String key, double value)
RedisTimeSeriesCommands
TS.ADD key * value
tsAdd
in interface RedisTimeSeriesCommands
public long tsAdd(String key, long timestamp, double value)
RedisTimeSeriesCommands
TS.ADD key timestamp value
tsAdd
in interface RedisTimeSeriesCommands
public long tsAdd(String key, long timestamp, double value, TSCreateParams createParams)
RedisTimeSeriesCommands
TS.ADD key timestamp value [RETENTION retentionTime] [ENCODING [COMPRESSED|UNCOMPRESSED]] [CHUNK_SIZE size] [ON_DUPLICATE policy] [LABELS label value..]
tsAdd
in interface RedisTimeSeriesCommands
public List<Long> tsMAdd(Map.Entry<String,TSElement>... entries)
RedisTimeSeriesCommands
TS.MADD key timestamp value [key timestamp value ...]
tsMAdd
in interface RedisTimeSeriesCommands
entries
- key, timestamp, valuepublic long tsIncrBy(String key, double value)
tsIncrBy
in interface RedisTimeSeriesCommands
public long tsIncrBy(String key, double value, long timestamp)
tsIncrBy
in interface RedisTimeSeriesCommands
public long tsDecrBy(String key, double value)
tsDecrBy
in interface RedisTimeSeriesCommands
public long tsDecrBy(String key, double value, long timestamp)
tsDecrBy
in interface RedisTimeSeriesCommands
public List<TSElement> tsRange(String key, long fromTimestamp, long toTimestamp)
RedisTimeSeriesCommands
TS.RANGE key fromTimestamp toTimestamp
tsRange
in interface RedisTimeSeriesCommands
public List<TSElement> tsRange(String key, TSRangeParams rangeParams)
RedisTimeSeriesCommands
TS.RANGE key fromTimestamp toTimestamp
[LATEST]
[FILTER_BY_TS ts...]
[FILTER_BY_VALUE min max]
[COUNT count]
[[ALIGN value] AGGREGATION aggregator bucketDuration [BUCKETTIMESTAMP bt] [EMPTY]]
tsRange
in interface RedisTimeSeriesCommands
public List<TSElement> tsRevRange(String key, long fromTimestamp, long toTimestamp)
RedisTimeSeriesCommands
TS.REVRANGE key fromTimestamp toTimestamp
tsRevRange
in interface RedisTimeSeriesCommands
public List<TSElement> tsRevRange(String key, TSRangeParams rangeParams)
RedisTimeSeriesCommands
TS.REVRANGE key fromTimestamp toTimestamp
[LATEST]
[FILTER_BY_TS TS...]
[FILTER_BY_VALUE min max]
[COUNT count]
[[ALIGN value] AGGREGATION aggregator bucketDuration [BUCKETTIMESTAMP bt] [EMPTY]]
tsRevRange
in interface RedisTimeSeriesCommands
public List<TSKeyedElements> tsMRange(long fromTimestamp, long toTimestamp, String... filters)
RedisTimeSeriesCommands
TS.MRANGE fromTimestamp toTimestamp FILTER filter...
tsMRange
in interface RedisTimeSeriesCommands
public List<TSKeyedElements> tsMRange(TSMRangeParams multiRangeParams)
RedisTimeSeriesCommands
TS.MRANGE fromTimestamp toTimestamp
[LATEST]
[FILTER_BY_TS ts...]
[FILTER_BY_VALUE min max]
[WITHLABELS | SELECTED_LABELS label...]
[COUNT count]
[[ALIGN value] AGGREGATION aggregator bucketDuration [BUCKETTIMESTAMP bt] [EMPTY]]
FILTER filter...
[GROUPBY label REDUCE reducer]
tsMRange
in interface RedisTimeSeriesCommands
public List<TSKeyedElements> tsMRevRange(long fromTimestamp, long toTimestamp, String... filters)
RedisTimeSeriesCommands
TS.MREVRANGE fromTimestamp toTimestamp FILTER filter...
tsMRevRange
in interface RedisTimeSeriesCommands
public List<TSKeyedElements> tsMRevRange(TSMRangeParams multiRangeParams)
RedisTimeSeriesCommands
TS.MREVRANGE fromTimestamp toTimestamp
[LATEST]
[FILTER_BY_TS TS...]
[FILTER_BY_VALUE min max]
[WITHLABELS | SELECTED_LABELS label...]
[COUNT count]
[[ALIGN value] AGGREGATION aggregator bucketDuration [BUCKETTIMESTAMP bt] [EMPTY]]
FILTER filter...
[GROUPBY label REDUCE reducer]
tsMRevRange
in interface RedisTimeSeriesCommands
public TSElement tsGet(String key)
RedisTimeSeriesCommands
TS.GET key
tsGet
in interface RedisTimeSeriesCommands
key
- the keypublic TSElement tsGet(String key, TSGetParams getParams)
RedisTimeSeriesCommands
TS.GET key [LATEST]
tsGet
in interface RedisTimeSeriesCommands
key
- the keygetParams
- optional argumentspublic List<TSKeyValue<TSElement>> tsMGet(TSMGetParams multiGetParams, String... filters)
RedisTimeSeriesCommands
TS.MGET [LATEST] [ WITHLABELS | SELECTED_LABELS label...] FILTER filter...
tsMGet
in interface RedisTimeSeriesCommands
multiGetParams
- optional argumentsfilters
- secondary indexespublic String tsCreateRule(String sourceKey, String destKey, AggregationType aggregationType, long timeBucket)
RedisTimeSeriesCommands
TS.CREATERULE sourceKey destKey AGGREGATION aggregationType timeBucket
tsCreateRule
in interface RedisTimeSeriesCommands
public String tsCreateRule(String sourceKey, String destKey, AggregationType aggregationType, long bucketDuration, long alignTimestamp)
RedisTimeSeriesCommands
TS.CREATERULE sourceKey destKey AGGREGATION aggregationType bucketDuration [alignTimestamp]
tsCreateRule
in interface RedisTimeSeriesCommands
public String tsDeleteRule(String sourceKey, String destKey)
RedisTimeSeriesCommands
TS.DELETERULE sourceKey destKey
tsDeleteRule
in interface RedisTimeSeriesCommands
public List<String> tsQueryIndex(String... filters)
RedisTimeSeriesCommands
TS.QUERYINDEX filter...
tsQueryIndex
in interface RedisTimeSeriesCommands
public TSInfo tsInfo(String key)
tsInfo
in interface RedisTimeSeriesCommands
public TSInfo tsInfoDebug(String key)
tsInfoDebug
in interface RedisTimeSeriesCommands
public String bfReserve(String key, double errorRate, long capacity)
BloomFilterCommands
BF.RESERVE {key} {error_rate} {capacity}
bfReserve
in interface BloomFilterCommands
public String bfReserve(String key, double errorRate, long capacity, BFReserveParams reserveParams)
BloomFilterCommands
BF.RESERVE {key} {error_rate} {capacity} [EXPANSION {expansion}] [NONSCALING]
bfReserve
in interface BloomFilterCommands
public boolean bfAdd(String key, String item)
BloomFilterCommands
BF.ADD {key} {item}
bfAdd
in interface BloomFilterCommands
public List<Boolean> bfMAdd(String key, String... items)
BloomFilterCommands
BF.MADD {key} {item ...}
bfMAdd
in interface BloomFilterCommands
public List<Boolean> bfInsert(String key, String... items)
BloomFilterCommands
BF.INSERT {key} ITEMS {item ...}
bfInsert
in interface BloomFilterCommands
public List<Boolean> bfInsert(String key, BFInsertParams insertParams, String... items)
BloomFilterCommands
BF.INSERT {key} [CAPACITY {cap}] [ERROR {error}] [EXPANSION {expansion}] [NOCREATE]
[NONSCALING] ITEMS {item ...}
bfInsert
in interface BloomFilterCommands
public boolean bfExists(String key, String item)
BloomFilterCommands
BF.EXISTS {key} {item}
bfExists
in interface BloomFilterCommands
public List<Boolean> bfMExists(String key, String... items)
BloomFilterCommands
BF.MEXISTS {key} {item ...}
bfMExists
in interface BloomFilterCommands
public Map.Entry<Long,byte[]> bfScanDump(String key, long iterator)
BloomFilterCommands
BF.SCANDUMP {key} {iterator}
bfScanDump
in interface BloomFilterCommands
public String bfLoadChunk(String key, long iterator, byte[] data)
BloomFilterCommands
BF.LOADCHUNK {key} {iterator} {data}
bfLoadChunk
in interface BloomFilterCommands
public Map<String,Object> bfInfo(String key)
bfInfo
in interface BloomFilterCommands
public String cfReserve(String key, long capacity)
CuckooFilterCommands
cfReserve
in interface CuckooFilterCommands
key
- The name of the filterpublic String cfReserve(String key, long capacity, CFReserveParams reserveParams)
CuckooFilterCommands
cfReserve
in interface CuckooFilterCommands
key
- The name of the filterreserveParams
- An instance of CFReserveParams containing the optionspublic boolean cfAdd(String key, String item)
CuckooFilterCommands
cfAdd
in interface CuckooFilterCommands
key
- The name of the filteritem
- The item to addpublic boolean cfAddNx(String key, String item)
CuckooFilterCommands
cfAddNx
in interface CuckooFilterCommands
key
- The name of the filteritem
- The item to addpublic List<Boolean> cfInsert(String key, String... items)
CuckooFilterCommands
cfInsert
in interface CuckooFilterCommands
key
- The name of the filteritems
- One or more items to addpublic List<Boolean> cfInsert(String key, CFInsertParams insertParams, String... items)
CuckooFilterCommands
cfInsert
in interface CuckooFilterCommands
key
- 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)
CuckooFilterCommands
cfInsertNx
in interface CuckooFilterCommands
key
- The name of the filteritems
- One or more items to addpublic List<Boolean> cfInsertNx(String key, CFInsertParams insertParams, String... items)
CuckooFilterCommands
cfInsertNx
in interface CuckooFilterCommands
key
- 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)
CuckooFilterCommands
cfExists
in interface CuckooFilterCommands
key
- The name of the filteritem
- The item to check forpublic List<Boolean> cfMExists(String key, String... items)
CuckooFilterCommands
CF.MEXISTS {key} {item ...}
cfMExists
in interface CuckooFilterCommands
key
- The name of the filteritems
- Items to check for (non empty sequence)public boolean cfDel(String key, String item)
CuckooFilterCommands
cfDel
in interface CuckooFilterCommands
key
- The name of the filteritem
- The item to delete from the filterpublic long cfCount(String key, String item)
CuckooFilterCommands
cfCount
in interface CuckooFilterCommands
key
- The name of the filteritem
- The item to countpublic Map.Entry<Long,byte[]> cfScanDump(String key, long iterator)
CuckooFilterCommands
cfScanDump
in interface CuckooFilterCommands
key
- Name of the filteriterator
- This is either 0, or the iterator from a previous invocation
of this commandpublic String cfLoadChunk(String key, long iterator, byte[] data)
CuckooFilterCommands
cfLoadChunk
in interface CuckooFilterCommands
key
- Name of the filter to restoreiterator
- Iterator from CF.SCANDUMPdata
- Data from CF.SCANDUMPpublic Map<String,Object> cfInfo(String key)
CuckooFilterCommands
cfInfo
in interface CuckooFilterCommands
key
- Name of the filter to restorepublic String cmsInitByDim(String key, long width, long depth)
CountMinSketchCommands
cmsInitByDim
in interface CountMinSketchCommands
key
- 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)
CountMinSketchCommands
cmsInitByProb
in interface CountMinSketchCommands
key
- 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)
CountMinSketchCommands
cmsIncrBy
in interface CountMinSketchCommands
key
- The name of the sketchitemIncrements
- a Map of the items to be increased and their integer
incrementpublic List<Long> cmsQuery(String key, String... items)
CountMinSketchCommands
cmsQuery
in interface CountMinSketchCommands
key
- The name of the sketchitems
- The items for which to retrieve the countspublic String cmsMerge(String destKey, String... keys)
CountMinSketchCommands
cmsMerge
in interface CountMinSketchCommands
destKey
- The name of destination sketch. Must be initialized.keys
- The sketches to be mergedpublic String cmsMerge(String destKey, Map<String,Long> keysAndWeights)
CountMinSketchCommands
cmsMerge
in interface CountMinSketchCommands
destKey
- 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)
CountMinSketchCommands
cmsInfo
in interface CountMinSketchCommands
key
- The name of the sketchpublic String topkReserve(String key, long topk)
TopKFilterCommands
TOPK.RESERVE {key} {topk}
topkReserve
in interface TopKFilterCommands
public String topkReserve(String key, long topk, long width, long depth, double decay)
TopKFilterCommands
TOPK.RESERVE {key} {topk} [{width} {depth} {decay}]
topkReserve
in interface TopKFilterCommands
public List<String> topkAdd(String key, String... items)
TopKFilterCommands
TOPK.ADD {key} {item ...}
topkAdd
in interface TopKFilterCommands
public List<String> topkIncrBy(String key, Map<String,Long> itemIncrements)
TopKFilterCommands
TOPK.INCRBY {key} {item} {increment} [{item} {increment} ...]
topkIncrBy
in interface TopKFilterCommands
itemIncrements
- item and increment pairspublic List<Boolean> topkQuery(String key, String... items)
TopKFilterCommands
TOPK.QUERY {key} {item ...}
topkQuery
in interface TopKFilterCommands
@Deprecated public List<Long> topkCount(String key, String... items)
TopKFilterCommands
TOPK.COUNT {key} {item ...}
topkCount
in interface TopKFilterCommands
public List<String> topkList(String key)
TopKFilterCommands
TOPK.LIST {key}
topkList
in interface TopKFilterCommands
public Map<String,Object> topkInfo(String key)
TopKFilterCommands
TOPK.INFO {key}
topkInfo
in interface TopKFilterCommands
public String tdigestCreate(String key)
TDigestSketchCommands
TDIGEST.CREATE key
tdigestCreate
in interface TDigestSketchCommands
key
- The name of the sketch (a t-digest data structure)public String tdigestCreate(String key, int compression)
TDigestSketchCommands
TDIGEST.CREATE key [compression]
tdigestCreate
in interface TDigestSketchCommands
key
- The name of the sketch (a t-digest data structure)compression
- The compression parameter. 100 is a common value for normal uses. 1000 is extremely large.public String tdigestReset(String key)
TDigestSketchCommands
TDIGEST.RESET key
tdigestReset
in interface TDigestSketchCommands
key
- The name of the sketch (a t-digest data structure)public String tdigestMerge(String destinationKey, String... sourceKeys)
TDigestSketchCommands
TDIGEST.MERGE destination-key numkeys source-key [source-key ...]
tdigestMerge
in interface TDigestSketchCommands
destinationKey
- Sketch to copy observation values to (a t-digest data structure)sourceKeys
- Sketch(es) to copy observation values from (a t-digest data structure)public String tdigestMerge(TDigestMergeParams mergeParams, String destinationKey, String... sourceKeys)
TDigestSketchCommands
TDIGEST.MERGE destination-key numkeys source-key [source-key ...]
[COMPRESSION compression] [OVERRIDE]
tdigestMerge
in interface TDigestSketchCommands
mergeParams
- compression and override optionsdestinationKey
- Sketch to copy observation values to (a t-digest data structure)sourceKeys
- Sketch(es) to copy observation values from (a t-digest data structure)public Map<String,Object> tdigestInfo(String key)
TDigestSketchCommands
TDIGEST.INFO key
tdigestInfo
in interface TDigestSketchCommands
key
- The name of the sketch (a t-digest data structure)public String tdigestAdd(String key, double... values)
TDigestSketchCommands
TDIGEST.ADD key value weight [ value weight ...]
tdigestAdd
in interface TDigestSketchCommands
key
- The name of the sketch (a t-digest data structure)values
- The value of the observation (floating-point)public List<Double> tdigestCDF(String key, double... values)
TDigestSketchCommands
TDIGEST.CDF key value [value ...]
tdigestCDF
in interface TDigestSketchCommands
key
- The name of the sketch (a t-digest data structure)values
- upper limit of observation value, for which the fraction of all observations added which are ≤ valuepublic List<Double> tdigestQuantile(String key, double... quantiles)
TDigestSketchCommands
TDIGEST.QUANTILE key quantile [quantile ...]
tdigestQuantile
in interface TDigestSketchCommands
key
- The name of the sketch (a t-digest data structure)quantiles
- The desired fraction(s) (between 0 and 1 inclusively)public double tdigestMin(String key)
TDigestSketchCommands
TDIGEST.MIN key
tdigestMin
in interface TDigestSketchCommands
key
- The name of the sketch (a t-digest data structure)public double tdigestMax(String key)
TDigestSketchCommands
TDIGEST.MAX key
tdigestMax
in interface TDigestSketchCommands
key
- The name of the sketch (a t-digest data structure)public double tdigestTrimmedMean(String key, double lowCutQuantile, double highCutQuantile)
TDigestSketchCommands
TDIGEST.TRIMMED_MEAN key low_cut_quantile high_cut_quantile
tdigestTrimmedMean
in interface TDigestSketchCommands
key
- The name of the sketch (a t-digest data structure)lowCutQuantile
- Exclude observation values lower than this quantilehighCutQuantile
- Exclude observation values higher than this quantilepublic List<Long> tdigestRank(String key, double... values)
tdigestRank
in interface TDigestSketchCommands
public List<Long> tdigestRevRank(String key, double... values)
tdigestRevRank
in interface TDigestSketchCommands
public List<Double> tdigestByRank(String key, long... ranks)
tdigestByRank
in interface TDigestSketchCommands
public List<Double> tdigestByRevRank(String key, long... ranks)
tdigestByRevRank
in interface TDigestSketchCommands
public ResultSet graphQuery(String name, String query)
RedisGraphCommands
graphQuery
in interface RedisGraphCommands
name
- a graph to perform the query onquery
- Cypher querypublic ResultSet graphReadonlyQuery(String name, String query)
RedisGraphCommands
graphReadonlyQuery
in interface RedisGraphCommands
name
- a graph to perform the query onquery
- Cypher querypublic ResultSet graphQuery(String name, String query, long timeout)
RedisGraphCommands
graphQuery
in interface RedisGraphCommands
name
- a graph to perform the query onquery
- Cypher querypublic ResultSet graphReadonlyQuery(String name, String query, long timeout)
RedisGraphCommands
graphReadonlyQuery
in interface RedisGraphCommands
name
- a graph to perform the query onquery
- Cypher querypublic ResultSet graphQuery(String name, String query, Map<String,Object> params)
RedisGraphCommands
graphQuery
in interface RedisGraphCommands
name
- a graph to perform the query on.query
- Cypher query.params
- parameters map.public ResultSet graphReadonlyQuery(String name, String query, Map<String,Object> params)
RedisGraphCommands
graphReadonlyQuery
in interface RedisGraphCommands
name
- 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)
RedisGraphCommands
graphQuery
in interface RedisGraphCommands
name
- 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)
RedisGraphCommands
graphReadonlyQuery
in interface RedisGraphCommands
name
- a graph to perform the query on.query
- Cypher query.params
- parameters map.public String graphDelete(String name)
RedisGraphCommands
graphDelete
in interface RedisGraphCommands
name
- graph to deletepublic List<String> graphList()
RedisGraphCommands
graphList
in interface RedisGraphCommands
public List<String> graphProfile(String graphName, String query)
RedisGraphCommands
graphProfile
in interface RedisGraphCommands
public List<String> graphExplain(String graphName, String query)
RedisGraphCommands
graphExplain
in interface RedisGraphCommands
public List<List<String>> graphSlowlog(String graphName)
RedisGraphCommands
graphSlowlog
in interface RedisGraphCommands
public String graphConfigSet(String configName, Object value)
graphConfigSet
in interface RedisGraphCommands
public Map<String,Object> graphConfigGet(String configName)
graphConfigGet
in interface RedisGraphCommands
public JedisBroadcast broadcast()
public Object pipelined()
public 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.