public class Jedis extends BinaryJedis implements JedisCommands, MultiKeyCommands, AdvancedJedisCommands, ScriptingCommands, BasicCommands, ClusterCommands, SentinelCommands
BinaryJedis.SetFromList<E>
Modifier and Type | Field and Description |
---|---|
protected Pool<Jedis> |
dataSource |
client, pipeline, transaction
Constructor and Description |
---|
Jedis() |
Jedis(JedisShardInfo shardInfo) |
Jedis(String host) |
Jedis(String host,
int port) |
Jedis(String host,
int port,
int timeout) |
Jedis(String host,
int port,
int connectionTimeout,
int soTimeout) |
Jedis(URI uri) |
Jedis(URI uri,
int timeout) |
Jedis(URI uri,
int connectionTimeout,
int soTimeout) |
Modifier and Type | Method and Description |
---|---|
Long |
append(String key,
String value)
If the key already exists and is a string, this command appends the provided value at the end
of the string.
|
String |
asking() |
Long |
bitcount(String key) |
Long |
bitcount(String key,
long start,
long end) |
Long |
bitop(BitOP op,
String destKey,
String... srcKeys) |
Long |
bitpos(String key,
boolean value) |
Long |
bitpos(String key,
boolean value,
BitPosParams params) |
List<String> |
blpop(int timeout,
String... keys)
BLPOP (and BRPOP) is a blocking list pop primitive.
|
List<String> |
blpop(int timeout,
String key) |
List<String> |
blpop(String... args) |
List<String> |
blpop(String arg)
Deprecated.
unusable command, this command will be removed in 3.0.0.
|
List<String> |
brpop(int timeout,
String... keys)
BLPOP (and BRPOP) is a blocking list pop primitive.
|
List<String> |
brpop(int timeout,
String key) |
List<String> |
brpop(String... args) |
List<String> |
brpop(String arg)
Deprecated.
unusable command, this command will be removed in 3.0.0.
|
String |
brpoplpush(String source,
String destination,
int timeout)
Pop a value from a list, push it to another list and return it; or block until one is available
|
String |
clientKill(String client) |
String |
clientSetname(String name) |
void |
close() |
String |
clusterAddSlots(int... slots) |
Long |
clusterCountKeysInSlot(int slot) |
String |
clusterDelSlots(int... slots) |
String |
clusterFailover() |
String |
clusterFlushSlots() |
String |
clusterForget(String nodeId) |
List<String> |
clusterGetKeysInSlot(int slot,
int count) |
String |
clusterInfo() |
Long |
clusterKeySlot(String key) |
String |
clusterMeet(String ip,
int port) |
String |
clusterNodes() |
String |
clusterReplicate(String nodeId) |
String |
clusterReset(JedisCluster.Reset resetType) |
String |
clusterSaveConfig() |
String |
clusterSetSlotImporting(int slot,
String nodeId) |
String |
clusterSetSlotMigrating(int slot,
String nodeId) |
String |
clusterSetSlotNode(int slot,
String nodeId) |
String |
clusterSetSlotStable(int slot) |
List<String> |
clusterSlaves(String nodeId) |
List<Object> |
clusterSlots() |
List<String> |
configGet(String pattern)
Retrieve the configuration of a running Redis server.
|
String |
configSet(String parameter,
String value)
Alter the configuration of a running Redis server.
|
Long |
decr(String key)
Decrement the number stored at key by one.
|
Long |
decrBy(String key,
long integer)
IDECRBY work just like
INCR but instead to decrement by 1 the decrement
is integer. |
Long |
del(String... keys)
Remove the specified keys.
|
Long |
del(String key) |
byte[] |
dump(String key) |
String |
echo(String string) |
Object |
eval(String script) |
Object |
eval(String script,
int keyCount,
String... params) |
Object |
eval(String script,
List<String> keys,
List<String> args) |
Object |
evalsha(String script) |
Object |
evalsha(String sha1,
int keyCount,
String... params) |
Object |
evalsha(String sha1,
List<String> keys,
List<String> args) |
Boolean |
exists(String key)
Test if the specified key exists.
|
Long |
expire(String key,
int seconds)
Set a timeout on the specified key.
|
Long |
expireAt(String key,
long unixTime)
EXPIREAT works exctly 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 specifing the TTL), it takes an absolute one in the form of a UNIX timestamp (Number of
seconds elapsed since 1 Gen 1970). |
String |
get(String key)
Get the value of the specified key.
|
Boolean |
getbit(String key,
long offset)
Returns the bit value at offset in the string value stored at key
|
protected static String[] |
getParams(List<String> keys,
List<String> args) |
String |
getrange(String key,
long startOffset,
long endOffset) |
String |
getSet(String key,
String value)
GETSET is an atomic set this value and return the old value command.
|
Long |
hdel(String key,
String... fields)
Remove the specified field from an hash stored at key.
|
Boolean |
hexists(String key,
String field)
Test for existence of a specified field in a hash.
|
String |
hget(String key,
String field)
If key holds a hash, retrieve the value associated to the specified field.
|
Map<String,String> |
hgetAll(String key)
Return all the fields and associated values in a hash.
|
Long |
hincrBy(String key,
String field,
long value)
Increment the number stored at field in the hash at key by value.
|
Double |
hincrByFloat(String key,
String field,
double value)
Increment the number stored at field in the hash at key by a double precision floating point
value.
|
Set<String> |
hkeys(String key)
Return all the fields in a hash.
|
Long |
hlen(String key)
Return the number of items in a hash.
|
List<String> |
hmget(String key,
String... fields)
Retrieve the values associated to the specified fields.
|
String |
hmset(String key,
Map<String,String> hash)
Set the respective fields to the respective values.
|
ScanResult<Map.Entry<String,String>> |
hscan(String key,
int cursor)
Deprecated.
|
ScanResult<Map.Entry<String,String>> |
hscan(String key,
int cursor,
ScanParams params)
Deprecated.
|
ScanResult<Map.Entry<String,String>> |
hscan(String key,
String cursor) |
ScanResult<Map.Entry<String,String>> |
hscan(String key,
String cursor,
ScanParams params) |
Long |
hset(String key,
String field,
String value)
Set the specified hash field to the specified value.
|
Long |
hsetnx(String key,
String field,
String value)
Set the specified hash field to the specified value if the field not exists.
|
List<String> |
hvals(String key)
Return all the values in a hash.
|
Long |
incr(String key)
Increment the number stored at key by one.
|
Long |
incrBy(String key,
long integer)
INCRBY work just like
INCR but instead to increment by 1 the increment is
integer. |
Double |
incrByFloat(String key,
double value)
INCRBYFLOAT
|
Set<String> |
keys(String pattern)
Returns all the keys matching the glob-style pattern as space separated strings.
|
String |
lindex(String key,
long index)
Return the specified element of the list stored at the specified key.
|
Long |
linsert(String key,
BinaryClient.LIST_POSITION where,
String pivot,
String value) |
Long |
llen(String key)
Return the length of the list stored at the specified key.
|
String |
lpop(String key)
Atomically return and remove the first (LPOP) or last (RPOP) element of the list.
|
Long |
lpush(String key,
String... strings)
Add the string value to the head (LPUSH) or tail (RPUSH) of the list stored at key.
|
Long |
lpushx(String key,
String... string) |
List<String> |
lrange(String key,
long start,
long end)
Return the specified elements of the list stored at the specified key.
|
Long |
lrem(String key,
long count,
String value)
Remove the first count occurrences of the value element from the list.
|
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(String key,
long start,
long end)
Trim an existing list so that it will contain only the specified range of elements specified.
|
List<String> |
mget(String... keys)
Get the values of all the specified keys.
|
String |
migrate(String host,
int port,
String key,
int destinationDb,
int timeout) |
Long |
move(String key,
int dbIndex)
Move the specified key from the currently selected DB to the specified destination DB.
|
String |
mset(String... keysvalues)
Set the the respective keys to the respective values.
|
Long |
msetnx(String... keysvalues)
Set the the respective keys to the respective values.
|
String |
objectEncoding(String string) |
Long |
objectIdletime(String string) |
Long |
objectRefcount(String string) |
Long |
persist(String key)
Undo a
expire at turning the expire key into a normal key. |
Long |
pexpire(String key,
int milliseconds)
Deprecated.
|
Long |
pexpire(String key,
long milliseconds) |
Long |
pexpireAt(String key,
long millisecondsTimestamp) |
Long |
pfadd(String key,
String... elements) |
long |
pfcount(String... keys) |
long |
pfcount(String key) |
String |
pfmerge(String destkey,
String... sourcekeys) |
String |
psetex(String key,
int milliseconds,
String value)
Deprecated.
|
String |
psetex(String key,
long milliseconds,
String value)
PSETEX works exactly like
setex(String, int, String) }with the sole difference that the expire time is specified in milliseconds instead of seconds. |
void |
psubscribe(JedisPubSub jedisPubSub,
String... patterns) |
Long |
pttl(String key) |
Long |
publish(String channel,
String message) |
List<String> |
pubsubChannels(String pattern) |
Long |
pubsubNumPat() |
Map<String,String> |
pubsubNumSub(String... channels) |
String |
randomKey()
Return a randomly selected key from the currently selected DB.
|
String |
rename(String oldkey,
String newkey)
Atomically renames the key oldkey to newkey.
|
Long |
renamenx(String oldkey,
String newkey)
Rename oldkey into newkey but fails if the destination key newkey already exists.
|
String |
restore(String key,
int ttl,
byte[] serializedValue) |
String |
rpop(String key)
Atomically return and remove the first (LPOP) or last (RPOP) element of the list.
|
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(String key,
String... strings)
Add the string value to the head (LPUSH) or tail (RPUSH) of the list stored at key.
|
Long |
rpushx(String key,
String... string) |
Long |
sadd(String key,
String... members)
Add the specified member to the set value stored at key.
|
ScanResult<String> |
scan(int cursor)
Deprecated.
|
ScanResult<String> |
scan(int cursor,
ScanParams params)
Deprecated.
|
ScanResult<String> |
scan(String cursor) |
ScanResult<String> |
scan(String cursor,
ScanParams params) |
Long |
scard(String key)
Return the set cardinality (number of elements).
|
List<Boolean> |
scriptExists(String... sha1) |
Boolean |
scriptExists(String sha1) |
String |
scriptLoad(String script) |
Set<String> |
sdiff(String... keys)
Return the difference between the Set stored at key1 and all the Sets key2, ..., keyN
|
Long |
sdiffstore(String dstkey,
String... keys)
This command works exactly like
SDIFF but instead of being returned
the resulting set is stored in dstkey. |
String |
sentinelFailover(String masterName) |
List<String> |
sentinelGetMasterAddrByName(String masterName)
redis 127.0.0.1:26381> sentinel get-master-addr-by-name mymaster
1) "127.0.0.1"
2) "6379"
|
List<Map<String,String>> |
sentinelMasters()
redis 127.0.0.1:26381> sentinel masters
1) 1) "name"
2) "mymaster"
3) "ip"
4) "127.0.0.1"
5) "port"
6) "6379"
7) "runid"
8) "93d4d4e6e9c06d0eea36e27f31924ac26576081d"
9) "flags"
10) "master"
11) "pending-commands"
12) "0"
13) "last-ok-ping-reply"
14) "423"
15) "last-ping-reply"
16) "423"
17) "info-refresh"
18) "6107"
19) "num-slaves"
20) "1"
21) "num-other-sentinels"
22) "2"
23) "quorum"
24) "2"
|
String |
sentinelMonitor(String masterName,
String ip,
int port,
int quorum) |
String |
sentinelRemove(String masterName) |
Long |
sentinelReset(String pattern)
redis 127.0.0.1:26381> sentinel reset mymaster
(integer) 1
|
String |
sentinelSet(String masterName,
Map<String,String> parameterMap) |
List<Map<String,String>> |
sentinelSlaves(String masterName)
redis 127.0.0.1:26381> sentinel slaves mymaster
1) 1) "name"
2) "127.0.0.1:6380"
3) "ip"
4) "127.0.0.1"
5) "port"
6) "6380"
7) "runid"
8) "d7f6c0ca7572df9d2f33713df0dbf8c72da7c039"
9) "flags"
10) "slave"
11) "pending-commands"
12) "0"
13) "last-ok-ping-reply"
14) "47"
15) "last-ping-reply"
16) "47"
17) "info-refresh"
18) "657"
19) "master-link-down-time"
20) "0"
21) "master-link-status"
22) "ok"
23) "master-host"
24) "localhost"
25) "master-port"
26) "6379"
27) "slave-priority"
28) "100"
|
String |
set(String key,
String value)
Set the string value as value of the key.
|
String |
set(String key,
String value,
String nxxx) |
String |
set(String key,
String value,
String nxxx,
String expx,
int time) |
String |
set(String key,
String value,
String nxxx,
String expx,
long time)
Set the string value as value of the key.
|
Boolean |
setbit(String key,
long offset,
boolean value)
Sets or clears the bit at offset in the string value stored at key
|
Boolean |
setbit(String key,
long offset,
String value) |
void |
setDataSource(Pool<Jedis> jedisPool) |
String |
setex(String key,
int seconds,
String value)
|
Long |
setnx(String key,
String value)
SETNX works exactly like
SET with the only difference that if the
key already exists no operation is performed. |
Long |
setrange(String key,
long offset,
String value) |
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 |
sinterstore(String dstkey,
String... keys)
This commnad works exactly like
SINTER but instead of being returned
the resulting set is sotred as dstkey. |
Boolean |
sismember(String key,
String member)
Return 1 if member is a member of the set stored at key, otherwise 0 is returned.
|
List<Slowlog> |
slowlogGet() |
List<Slowlog> |
slowlogGet(long entries) |
Set<String> |
smembers(String key)
Return all the members (elements) of the set value stored at key.
|
Long |
smove(String srckey,
String dstkey,
String member)
Move the specifided member from the set at srckey to the set at dstkey.
|
List<String> |
sort(String key)
Sort a Set or a List.
|
List<String> |
sort(String key,
SortingParams sortingParameters)
Sort a Set or a List accordingly to the specified parameters.
|
Long |
sort(String key,
SortingParams sortingParameters,
String dstkey)
Sort a Set or a List accordingly to the specified parameters and store the result at dstkey.
|
Long |
sort(String key,
String dstkey)
Sort a Set or a List and Store the Result at dstkey.
|
String |
spop(String key)
Remove a random element from a Set returning it as return value.
|
Set<String> |
spop(String key,
long count) |
String |
srandmember(String key)
Return a random element from a Set, without removing the element.
|
List<String> |
srandmember(String key,
int count) |
Long |
srem(String key,
String... members)
Remove the specified member from the set value stored at key.
|
ScanResult<String> |
sscan(String key,
int cursor)
Deprecated.
|
ScanResult<String> |
sscan(String key,
int cursor,
ScanParams params)
Deprecated.
|
ScanResult<String> |
sscan(String key,
String cursor) |
ScanResult<String> |
sscan(String key,
String cursor,
ScanParams params) |
Long |
strlen(String key) |
void |
subscribe(JedisPubSub jedisPubSub,
String... channels) |
String |
substr(String key,
int start,
int end)
Return a subset of the string from offset start to offset end (both offsets are inclusive).
|
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(String dstkey,
String... keys)
This command works exactly like
SUNION but instead of being returned
the resulting set is stored as dstkey. |
Long |
ttl(String key)
The TTL command returns the remaining time to live in seconds of a key that has an
EXPIRE set. |
String |
type(String key)
Return the type of the value stored at key in form of a string.
|
String |
watch(String... keys) |
Long |
zadd(String key,
double score,
String member)
Add the specified member having the specifeid score to the sorted set stored at key.
|
Long |
zadd(String key,
Map<String,Double> scoreMembers) |
Long |
zcard(String key)
Return the sorted set cardinality (number of elements).
|
Long |
zcount(String key,
double min,
double max) |
Long |
zcount(String key,
String min,
String max) |
Double |
zincrby(String key,
double score,
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.
|
Long |
zinterstore(String dstkey,
String... sets)
Creates a union or intersection of N sorted sets given by keys k1 through kN, and stores it at
dstkey.
|
Long |
zinterstore(String dstkey,
ZParams params,
String... sets)
Creates a union or intersection of N sorted sets given by keys k1 through kN, and stores it at
dstkey.
|
Long |
zlexcount(String key,
String min,
String max) |
Set<String> |
zrange(String key,
long start,
long end) |
Set<String> |
zrangeByLex(String key,
String min,
String max) |
Set<String> |
zrangeByLex(String key,
String min,
String max,
int offset,
int count) |
Set<String> |
zrangeByScore(String key,
double min,
double max)
Return the 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).
|
Set<String> |
zrangeByScore(String key,
double min,
double max,
int offset,
int count)
Return the 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).
|
Set<String> |
zrangeByScore(String key,
String min,
String max) |
Set<String> |
zrangeByScore(String key,
String min,
String max,
int offset,
int count) |
Set<Tuple> |
zrangeByScoreWithScores(String key,
double min,
double max)
Return the 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).
|
Set<Tuple> |
zrangeByScoreWithScores(String key,
double min,
double max,
int offset,
int count)
Return the 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).
|
Set<Tuple> |
zrangeByScoreWithScores(String key,
String min,
String max) |
Set<Tuple> |
zrangeByScoreWithScores(String key,
String min,
String max,
int offset,
int count) |
Set<Tuple> |
zrangeWithScores(String key,
long start,
long end) |
Long |
zrank(String key,
String member)
Return the rank (or index) or member in the sorted set at key, with scores being ordered from
low to high.
|
Long |
zrem(String key,
String... members)
Remove the specified member from the sorted set value stored at key.
|
Long |
zremrangeByLex(String key,
String min,
String max) |
Long |
zremrangeByRank(String key,
long start,
long end)
Remove all elements in the sorted set at key with rank between start and end.
|
Long |
zremrangeByScore(String key,
double start,
double end)
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 start,
String end) |
Set<String> |
zrevrange(String key,
long start,
long end) |
Set<String> |
zrevrangeByLex(String key,
String max,
String min) |
Set<String> |
zrevrangeByLex(String key,
String max,
String min,
int offset,
int count) |
Set<String> |
zrevrangeByScore(String key,
double max,
double min) |
Set<String> |
zrevrangeByScore(String key,
double max,
double min,
int offset,
int count) |
Set<String> |
zrevrangeByScore(String key,
String max,
String min) |
Set<String> |
zrevrangeByScore(String key,
String max,
String min,
int offset,
int count) |
Set<Tuple> |
zrevrangeByScoreWithScores(String key,
double max,
double min) |
Set<Tuple> |
zrevrangeByScoreWithScores(String key,
double max,
double min,
int offset,
int count) |
Set<Tuple> |
zrevrangeByScoreWithScores(String key,
String max,
String min) |
Set<Tuple> |
zrevrangeByScoreWithScores(String key,
String max,
String min,
int offset,
int count) |
Set<Tuple> |
zrevrangeWithScores(String key,
long start,
long end) |
Long |
zrevrank(String key,
String member)
Return the rank (or index) or member in the sorted set at key, with scores being ordered from
high to low.
|
ScanResult<Tuple> |
zscan(String key,
int cursor)
Deprecated.
|
ScanResult<Tuple> |
zscan(String key,
int cursor,
ScanParams params)
Deprecated.
|
ScanResult<Tuple> |
zscan(String key,
String cursor) |
ScanResult<Tuple> |
zscan(String key,
String cursor,
ScanParams params) |
Double |
zscore(String key,
String member)
Return the score of the specified element of the sorted set at key.
|
Long |
zunionstore(String dstkey,
String... sets)
Creates a union or intersection of N sorted sets given by keys k1 through kN, and stores it at
dstkey.
|
Long |
zunionstore(String dstkey,
ZParams params,
String... sets)
Creates a union or intersection of N sorted sets given by keys k1 through kN, and stores it at
dstkey.
|
append, auth, bgrewriteaof, bgsave, bitcount, bitcount, bitop, bitpos, bitpos, blpop, blpop, blpop, brpop, brpop, brpop, brpoplpush, checkIsInMultiOrPipeline, clientGetname, clientKill, clientList, clientSetname, configGet, configResetStat, configSet, connect, dbSize, debug, decr, decrBy, del, del, disconnect, dump, echo, eval, eval, eval, eval, evalsha, evalsha, evalsha, exists, expire, expireAt, flushAll, flushDB, get, getbit, getClient, getDB, getrange, getSet, hdel, hexists, hget, hgetAll, hincrBy, hincrByFloat, hkeys, hlen, hmget, hmset, hscan, hscan, hset, hsetnx, hvals, incr, incrBy, incrByFloat, info, info, isConnected, keys, lastsave, lindex, linsert, llen, lpop, lpush, lpushx, lrange, lrem, lset, ltrim, mget, migrate, monitor, move, mset, msetnx, multi, multi, objectEncoding, objectIdletime, objectRefcount, persist, pexpire, pexpire, pexpireAt, pfadd, pfcount, pfcount, pfmerge, ping, pipelined, pipelined, psetex, psetex, psubscribe, pttl, publish, quit, randomBinaryKey, rename, renamenx, resetState, restore, rpop, rpoplpush, rpush, rpushx, sadd, save, scan, scan, scard, scriptExists, scriptFlush, scriptKill, scriptLoad, sdiff, sdiffstore, select, set, set, set, set, setbit, setbit, setex, setnx, setrange, shutdown, sinter, sinterstore, sismember, slaveof, slaveofNoOne, slowlogGetBinary, slowlogGetBinary, slowlogLen, slowlogReset, smembers, smove, sort, sort, sort, sort, spop, spop, srandmember, srandmember, srem, sscan, sscan, strlen, subscribe, substr, sunion, sunionstore, sync, time, ttl, type, unwatch, waitReplicas, watch, zadd, zadd, zcard, zcount, zcount, zincrby, zinterstore, zinterstore, zlexcount, zrange, zrangeByLex, zrangeByLex, zrangeByScore, zrangeByScore, zrangeByScore, zrangeByScore, zrangeByScoreWithScores, zrangeByScoreWithScores, zrangeByScoreWithScores, zrangeByScoreWithScores, zrangeWithScores, zrank, zrem, zremrangeByLex, zremrangeByRank, zremrangeByScore, zremrangeByScore, zrevrange, zrevrangeByLex, zrevrangeByLex, zrevrangeByScore, zrevrangeByScore, zrevrangeByScore, zrevrangeByScore, zrevrangeByScoreWithScores, zrevrangeByScoreWithScores, zrevrangeByScoreWithScores, zrevrangeByScoreWithScores, zrevrangeWithScores, zrevrank, zscan, zscan, zscore, zunionstore, zunionstore
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
unwatch
slowlogLen, slowlogReset
auth, bgrewriteaof, bgsave, configResetStat, dbSize, debug, flushAll, flushDB, getDB, info, info, lastsave, ping, quit, save, select, shutdown, slaveof, slaveofNoOne, waitReplicas
public Jedis()
public Jedis(String host)
public Jedis(String host, int port)
public Jedis(String host, int port, int timeout)
public Jedis(String host, int port, int connectionTimeout, int soTimeout)
public Jedis(JedisShardInfo shardInfo)
public Jedis(URI uri)
public Jedis(URI uri, int timeout)
public Jedis(URI uri, int connectionTimeout, int soTimeout)
public String set(String key, String value)
Time complexity: O(1)
set
in interface JedisCommands
key
- value
- public String set(String key, String value, String nxxx, String expx, long time)
set
in interface JedisCommands
key
- value
- nxxx
- NX|XX, NX -- Only set the key if it does not already exist. XX -- Only set the key
if it already exist.expx
- EX|PX, expire time units: EX = seconds; PX = millisecondstime
- expire time in the units of expx
public String get(String key)
Time complexity: O(1)
get
in interface JedisCommands
key
- public Boolean exists(String key)
exists
in interface JedisCommands
key
- public Long del(String... keys)
del
in interface MultiKeyCommands
keys
- public Long del(String key)
del
in interface JedisCommands
public String type(String key)
type
in interface JedisCommands
key
- public Set<String> keys(String pattern)
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 MultiKeyCommands
pattern
- public String randomKey()
Time complexity: O(1)
randomKey
in interface MultiKeyCommands
public String rename(String oldkey, String newkey)
Time complexity: O(1)
rename
in interface MultiKeyCommands
oldkey
- newkey
- public Long renamenx(String oldkey, String newkey)
Time complexity: O(1)
renamenx
in interface MultiKeyCommands
oldkey
- newkey
- public Long expire(String key, int seconds)
Voltile 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 JedisCommands
key
- seconds
- public Long expireAt(String key, long unixTime)
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 specifing 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.
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)
expireAt
in interface JedisCommands
key
- unixTime
- public Long ttl(String key)
EXPIRE
set. This introspection capability allows a Redis client to
check how many seconds a given key will continue to be part of the dataset.ttl
in interface JedisCommands
key
- public Long move(String key, int dbIndex)
move
in interface JedisCommands
key
- dbIndex
- public String getSet(String key, String value)
Time complexity: O(1)
getSet
in interface JedisCommands
key
- value
- public List<String> mget(String... keys)
Time complexity: O(1) for every key
mget
in interface MultiKeyCommands
keys
- public Long setnx(String key, String value)
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 JedisCommands
key
- value
- public String setex(String key, int seconds, String value)
SET
+ EXPIRE
. The operation is
atomic.
Time complexity: O(1)
setex
in interface JedisCommands
key
- seconds
- value
- public String mset(String... keysvalues)
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 client talking to Redis can either see the changes to both A and B at once, or no modification at all.
mset
in interface MultiKeyCommands
keysvalues
- msetnx(String...)
public Long msetnx(String... keysvalues)
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 client talking to Redis can either see the changes to both A and B at once, or no modification at all.
msetnx
in interface MultiKeyCommands
keysvalues
- mset(String...)
public Long decrBy(String key, long integer)
INCR
but instead to decrement by 1 the decrement
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)
decrBy
in interface JedisCommands
key
- integer
- incr(String)
,
decr(String)
,
incrBy(String, long)
public Long decr(String key)
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)
decr
in interface JedisCommands
key
- incr(String)
,
incrBy(String, long)
,
decrBy(String, long)
public Long incrBy(String key, long integer)
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 JedisCommands
key
- integer
- incr(String)
,
decr(String)
,
decrBy(String, long)
public Double incrByFloat(String key, double value)
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 JedisCommands
key
- value
- public Long incr(String key)
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 JedisCommands
key
- incrBy(String, long)
,
decr(String)
,
decrBy(String, long)
public Long append(String key, String value)
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 JedisCommands
key
- value
- public String substr(String key, int start, int end)
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 JedisCommands
key
- start
- end
- public Long hset(String key, String field, String value)
If key does not exist, a new key holding a hash is created.
Time complexity: O(1)
hset
in interface JedisCommands
key
- field
- value
- public String hget(String key, String field)
If the field is not found or the key does not exist, a special 'nil' value is returned.
Time complexity: O(1)
hget
in interface JedisCommands
key
- field
- public Long hsetnx(String key, String field, String value)
hsetnx
in interface JedisCommands
key
- field
- value
- public String hmset(String key, Map<String,String> hash)
If key does not exist, a new key holding a hash is created.
Time complexity: O(N) (with N being the number of fields)
hmset
in interface JedisCommands
key
- hash
- public List<String> hmget(String key, String... fields)
If some of the specified fields do not exist, nil values are returned. Non existing keys are considered like empty hashes.
Time complexity: O(N) (with N being the number of fields)
hmget
in interface JedisCommands
key
- fields
- public Long hincrBy(String key, String field, long value)
The range of values supported by HINCRBY is limited to 64 bit signed integers.
Time complexity: O(1)
hincrBy
in interface JedisCommands
key
- field
- value
- public Double hincrByFloat(String key, String field, double value)
The range of values supported by HINCRBYFLOAT is limited to double precision floating point values.
Time complexity: O(1)
key
- field
- value
- public Boolean hexists(String key, String field)
hexists
in interface JedisCommands
key
- field
- public Long hdel(String key, String... fields)
Time complexity: O(1)
hdel
in interface JedisCommands
key
- fields
- public Long hlen(String key)
Time complexity: O(1)
hlen
in interface JedisCommands
key
- public Set<String> hkeys(String key)
Time complexity: O(N), where N is the total number of entries
hkeys
in interface JedisCommands
key
- public List<String> hvals(String key)
Time complexity: O(N), where N is the total number of entries
hvals
in interface JedisCommands
key
- public Map<String,String> hgetAll(String key)
Time complexity: O(N), where N is the total number of entries
hgetAll
in interface JedisCommands
key
- public Long rpush(String key, String... strings)
Time complexity: O(1)
rpush
in interface JedisCommands
key
- strings
- public Long lpush(String key, String... strings)
Time complexity: O(1)
lpush
in interface JedisCommands
key
- strings
- public Long llen(String key)
Time complexity: O(1)
llen
in interface JedisCommands
key
- public List<String> lrange(String key, long start, long end)
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 JedisCommands
key
- start
- end
- public String ltrim(String key, long start, long end)
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 JedisCommands
key
- start
- end
- public String lindex(String key, long index)
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 JedisCommands
key
- index
- public String lset(String key, long index, String value)
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) (with N being the length of the list), setting the first or last elements of the list is O(1).
lset
in interface JedisCommands
key
- index
- value
- lindex(String, long)
public Long lrem(String key, long count, String value)
Time complexity: O(N) (with N being the length of the list)
lrem
in interface JedisCommands
key
- count
- value
- public String lpop(String key)
If the key does not exist or the list is already empty the special value 'nil' is returned.
lpop
in interface JedisCommands
key
- rpop(String)
public String rpop(String key)
If the key does not exist or the list is already empty the special value 'nil' is returned.
rpop
in interface JedisCommands
key
- lpop(String)
public String rpoplpush(String srckey, String dstkey)
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 pusing it as first element of the list, so it's a "list rotation" command.
Time complexity: O(1)
rpoplpush
in interface MultiKeyCommands
srckey
- dstkey
- public Long sadd(String key, String... members)
Time complexity O(1)
sadd
in interface JedisCommands
key
- members
- public Set<String> smembers(String key)
SINTER
.
Time complexity O(N)
smembers
in interface JedisCommands
key
- public Long srem(String key, String... members)
Time complexity O(1)
srem
in interface JedisCommands
key
- members
- public String spop(String key)
The srandmember(String)
command does a similar work but the returned element is not
removed from the Set.
Time complexity O(1)
spop
in interface JedisCommands
key
- public Set<String> spop(String key, long count)
spop
in interface JedisCommands
public Long smove(String srckey, String dstkey, String member)
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 MultiKeyCommands
srckey
- dstkey
- member
- public Long scard(String key)
scard
in interface JedisCommands
key
- public Boolean sismember(String key, String member)
Time complexity O(1)
sismember
in interface JedisCommands
key
- member
- public Set<String> sinter(String... keys)
LRANGE
the result is sent to the
client 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 MultiKeyCommands
keys
- public Long sinterstore(String dstkey, String... keys)
SINTER
but instead of being returned
the resulting set is sotred 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 MultiKeyCommands
dstkey
- keys
- public Set<String> sunion(String... keys)
LRANGE
the result is sent to the client 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 MultiKeyCommands
keys
- public Long sunionstore(String dstkey, String... keys)
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 MultiKeyCommands
dstkey
- keys
- public Set<String> sdiff(String... 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 MultiKeyCommands
keys
- public Long sdiffstore(String dstkey, String... keys)
SDIFF
but instead of being returned
the resulting set is stored in dstkey.sdiffstore
in interface MultiKeyCommands
dstkey
- keys
- public String srandmember(String key)
The SPOP command does a similar work but the returned element is popped (removed) from the Set.
Time complexity O(1)
srandmember
in interface JedisCommands
key
- public List<String> srandmember(String key, int count)
srandmember
in interface JedisCommands
public Long zadd(String key, double score, String member)
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 JedisCommands
key
- score
- member
- public Long zadd(String key, Map<String,Double> scoreMembers)
zadd
in interface JedisCommands
public Set<String> zrange(String key, long start, long end)
zrange
in interface JedisCommands
public Long zrem(String key, String... members)
Time complexity O(log(N)) with N being the number of elements in the sorted set
zrem
in interface JedisCommands
key
- members
- public Double zincrby(String key, double score, String member)
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 JedisCommands
key
- score
- member
- public Long zrank(String key, String member)
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 JedisCommands
key
- member
- zrevrank(String, String)
public Long zrevrank(String key, String member)
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 JedisCommands
key
- member
- zrank(String, String)
public Set<String> zrevrange(String key, long start, long end)
zrevrange
in interface JedisCommands
public Set<Tuple> zrangeWithScores(String key, long start, long end)
zrangeWithScores
in interface JedisCommands
public Set<Tuple> zrevrangeWithScores(String key, long start, long end)
zrevrangeWithScores
in interface JedisCommands
public Long zcard(String key)
Time complexity O(1)
zcard
in interface JedisCommands
key
- public Double zscore(String key, String member)
Time complexity: O(1)
zscore
in interface JedisCommands
key
- member
- public String watch(String... keys)
watch
in interface MultiKeyCommands
public List<String> sort(String key)
Sort the elements contained in the List, Set, or Sorted Set value 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 JedisCommands
key
- sort(String, String)
,
sort(String, SortingParams)
,
sort(String, SortingParams, String)
public List<String> sort(String key, SortingParams sortingParameters)
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 JedisCommands
key
- sortingParameters
- sort(String)
,
sort(String, SortingParams, String)
public List<String> blpop(int timeout, String... keys)
The following is a description of the exact semantic. We describe BLPOP but the two commands are identical, the only difference is that BLPOP pops the element from the left (head) of the list, and BRPOP pops from the right (tail).
Non blocking behavior
When BLPOP is called, if at least one of the specified keys contain a non empty list, an element is popped from the head of the list and returned to the caller together with the name of the key (BLPOP returns a two elements array, the first element is the key, the second the popped value).
Keys are scanned from left to right, so for instance if you issue BLPOP list1 list2 list3 0 against a dataset where list1 does not exist but list2 and list3 contain non empty lists, BLPOP guarantees to return an element from the list stored at list2 (since it is the first non empty list starting from the left).
Blocking behavior
If none of the specified keys exist or contain non empty lists, BLPOP blocks until some other client performs a LPUSH or an RPUSH operation against one of the lists.
Once new data is present on one of the lists, the client finally returns with the name of the key unblocking it and the popped value.
When blocking, if a non-zero timeout is specified, the client will unblock returning a nil special value if the specified amount of seconds passed without a push operation against at least one of the specified keys.
The timeout argument is interpreted as an integer value. A timeout of zero means instead to block forever.
Multiple clients blocking for the same keys
Multiple clients can block for the same key. They are put into a queue, so the first to be served will be the one that started to wait earlier, in a first-blpopping first-served fashion.
blocking POP inside a MULTI/EXEC transaction
BLPOP and BRPOP can be used with pipelining (sending multiple commands and reading the replies in batch), but it does not make sense to use BLPOP or BRPOP inside a MULTI/EXEC block (a Redis transaction).
The behavior of BLPOP inside MULTI/EXEC when the list is empty is to return a multi-bulk nil reply, exactly what happens when the timeout is reached. If you like science fiction, think at it like if inside MULTI/EXEC the time will flow at infinite speed :)
Time complexity: O(1)
blpop
in interface MultiKeyCommands
timeout
- keys
- When a non-zero timeout is specified, and the BLPOP operation timed out, the return value is a nil multi bulk reply. Most client values will return false or nil accordingly to the programming language used.
brpop(int, String...)
public List<String> blpop(String... args)
blpop
in interface MultiKeyCommands
public List<String> brpop(String... args)
brpop
in interface MultiKeyCommands
@Deprecated public List<String> blpop(String arg)
blpop
in interface JedisCommands
@Deprecated public List<String> brpop(String arg)
brpop
in interface JedisCommands
public Long sort(String key, SortingParams sortingParameters, String dstkey)
sort
in interface MultiKeyCommands
key
- sortingParameters
- dstkey
- sort(String, SortingParams)
,
sort(String)
,
sort(String, String)
public Long sort(String key, String dstkey)
Sort the elements contained in the List, Set, or Sorted Set value at key and store the result at dstkey. 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 MultiKeyCommands
key
- dstkey
- sort(String)
,
sort(String, SortingParams)
,
sort(String, SortingParams, String)
public List<String> brpop(int timeout, String... keys)
The following is a description of the exact semantic. We describe BLPOP but the two commands are identical, the only difference is that BLPOP pops the element from the left (head) of the list, and BRPOP pops from the right (tail).
Non blocking behavior
When BLPOP is called, if at least one of the specified keys contain a non empty list, an element is popped from the head of the list and returned to the caller together with the name of the key (BLPOP returns a two elements array, the first element is the key, the second the popped value).
Keys are scanned from left to right, so for instance if you issue BLPOP list1 list2 list3 0 against a dataset where list1 does not exist but list2 and list3 contain non empty lists, BLPOP guarantees to return an element from the list stored at list2 (since it is the first non empty list starting from the left).
Blocking behavior
If none of the specified keys exist or contain non empty lists, BLPOP blocks until some other client performs a LPUSH or an RPUSH operation against one of the lists.
Once new data is present on one of the lists, the client finally returns with the name of the key unblocking it and the popped value.
When blocking, if a non-zero timeout is specified, the client will unblock returning a nil special value if the specified amount of seconds passed without a push operation against at least one of the specified keys.
The timeout argument is interpreted as an integer value. A timeout of zero means instead to block forever.
Multiple clients blocking for the same keys
Multiple clients can block for the same key. They are put into a queue, so the first to be served will be the one that started to wait earlier, in a first-blpopping first-served fashion.
blocking POP inside a MULTI/EXEC transaction
BLPOP and BRPOP can be used with pipelining (sending multiple commands and reading the replies in batch), but it does not make sense to use BLPOP or BRPOP inside a MULTI/EXEC block (a Redis transaction).
The behavior of BLPOP inside MULTI/EXEC when the list is empty is to return a multi-bulk nil reply, exactly what happens when the timeout is reached. If you like science fiction, think at it like if inside MULTI/EXEC the time will flow at infinite speed :)
Time complexity: O(1)
brpop
in interface MultiKeyCommands
timeout
- keys
- When a non-zero timeout is specified, and the BLPOP operation timed out, the return value is a nil multi bulk reply. Most client values will return false or nil accordingly to the programming language used.
blpop(int, String...)
public Long zcount(String key, double min, double max)
zcount
in interface JedisCommands
public Long zcount(String key, String min, String max)
zcount
in interface JedisCommands
public Set<String> zrangeByScore(String key, double min, double max)
The elements having the same score are returned sorted lexicographically as ASCII strings (this follows from a property of Redis sorted sets and does not involve further computation).
Using the optional LIMIT
it's possible
to get only a range of the matching elements in an SQL-alike way. Note that if offset is large
the commands needs to traverse the list for offset elements and this adds up to the O(M)
figure.
The ZCOUNT
command is similar to
ZRANGEBYSCORE
but instead of returning the
actual elements in the specified interval, it just returns the number of matching elements.
Exclusive intervals and infinity
min and max can be -inf and +inf, so that you are not required to know what's the greatest or smallest element in order to take, for instance, elements "up to a given value".
Also while the interval is for default closed (inclusive) it's possible to specify open intervals prefixing the score with a "(" character, so for instance:
ZRANGEBYSCORE zset (1.3 5
Will return all the values with score > 1.3 and <= 5, while for instance:
ZRANGEBYSCORE zset (5 (10
Will return all the values with score > 5 and < 10 (5 and 10 excluded).
Time complexity:
O(log(N))+O(M) with N being the number of elements in the sorted set and M the number of elements returned by the command, so if M is constant (for instance you always ask for the first ten elements with LIMIT) you can consider it O(log(N))
zrangeByScore
in interface JedisCommands
key
- min
- a double or Double.MIN_VALUE for "-inf"max
- a double or Double.MAX_VALUE for "+inf"zrangeByScore(String, double, double)
,
zrangeByScore(String, double, double, int, int)
,
zrangeByScoreWithScores(String, double, double)
,
zrangeByScoreWithScores(String, String, String)
,
zrangeByScoreWithScores(String, double, double, int, int)
,
zcount(String, double, double)
public Set<String> zrangeByScore(String key, String min, String max)
zrangeByScore
in interface JedisCommands
public Set<String> zrangeByScore(String key, double min, double max, int offset, int count)
The elements having the same score are returned sorted lexicographically as ASCII strings (this follows from a property of Redis sorted sets and does not involve further computation).
Using the optional LIMIT
it's possible
to get only a range of the matching elements in an SQL-alike way. Note that if offset is large
the commands needs to traverse the list for offset elements and this adds up to the O(M)
figure.
The ZCOUNT
command is similar to
ZRANGEBYSCORE
but instead of returning the
actual elements in the specified interval, it just returns the number of matching elements.
Exclusive intervals and infinity
min and max can be -inf and +inf, so that you are not required to know what's the greatest or smallest element in order to take, for instance, elements "up to a given value".
Also while the interval is for default closed (inclusive) it's possible to specify open intervals prefixing the score with a "(" character, so for instance:
ZRANGEBYSCORE zset (1.3 5
Will return all the values with score > 1.3 and <= 5, while for instance:
ZRANGEBYSCORE zset (5 (10
Will return all the values with score > 5 and < 10 (5 and 10 excluded).
Time complexity:
O(log(N))+O(M) with N being the number of elements in the sorted set and M the number of elements returned by the command, so if M is constant (for instance you always ask for the first ten elements with LIMIT) you can consider it O(log(N))
zrangeByScore
in interface JedisCommands
key
- min
- max
- zrangeByScore(String, double, double)
,
zrangeByScore(String, double, double, int, int)
,
zrangeByScoreWithScores(String, double, double)
,
zrangeByScoreWithScores(String, double, double, int, int)
,
zcount(String, double, double)
public Set<String> zrangeByScore(String key, String min, String max, int offset, int count)
zrangeByScore
in interface JedisCommands
public Set<Tuple> zrangeByScoreWithScores(String key, double min, double max)
The elements having the same score are returned sorted lexicographically as ASCII strings (this follows from a property of Redis sorted sets and does not involve further computation).
Using the optional LIMIT
it's possible
to get only a range of the matching elements in an SQL-alike way. Note that if offset is large
the commands needs to traverse the list for offset elements and this adds up to the O(M)
figure.
The ZCOUNT
command is similar to
ZRANGEBYSCORE
but instead of returning the
actual elements in the specified interval, it just returns the number of matching elements.
Exclusive intervals and infinity
min and max can be -inf and +inf, so that you are not required to know what's the greatest or smallest element in order to take, for instance, elements "up to a given value".
Also while the interval is for default closed (inclusive) it's possible to specify open intervals prefixing the score with a "(" character, so for instance:
ZRANGEBYSCORE zset (1.3 5
Will return all the values with score > 1.3 and <= 5, while for instance:
ZRANGEBYSCORE zset (5 (10
Will return all the values with score > 5 and < 10 (5 and 10 excluded).
Time complexity:
O(log(N))+O(M) with N being the number of elements in the sorted set and M the number of elements returned by the command, so if M is constant (for instance you always ask for the first ten elements with LIMIT) you can consider it O(log(N))
zrangeByScoreWithScores
in interface JedisCommands
key
- min
- max
- zrangeByScore(String, double, double)
,
zrangeByScore(String, double, double, int, int)
,
zrangeByScoreWithScores(String, double, double)
,
zrangeByScoreWithScores(String, double, double, int, int)
,
zcount(String, double, double)
public Set<Tuple> zrangeByScoreWithScores(String key, String min, String max)
zrangeByScoreWithScores
in interface JedisCommands
public Set<Tuple> zrangeByScoreWithScores(String key, double min, double max, int offset, int count)
The elements having the same score are returned sorted lexicographically as ASCII strings (this follows from a property of Redis sorted sets and does not involve further computation).
Using the optional LIMIT
it's possible
to get only a range of the matching elements in an SQL-alike way. Note that if offset is large
the commands needs to traverse the list for offset elements and this adds up to the O(M)
figure.
The ZCOUNT
command is similar to
ZRANGEBYSCORE
but instead of returning the
actual elements in the specified interval, it just returns the number of matching elements.
Exclusive intervals and infinity
min and max can be -inf and +inf, so that you are not required to know what's the greatest or smallest element in order to take, for instance, elements "up to a given value".
Also while the interval is for default closed (inclusive) it's possible to specify open intervals prefixing the score with a "(" character, so for instance:
ZRANGEBYSCORE zset (1.3 5
Will return all the values with score > 1.3 and <= 5, while for instance:
ZRANGEBYSCORE zset (5 (10
Will return all the values with score > 5 and < 10 (5 and 10 excluded).
Time complexity:
O(log(N))+O(M) with N being the number of elements in the sorted set and M the number of elements returned by the command, so if M is constant (for instance you always ask for the first ten elements with LIMIT) you can consider it O(log(N))
zrangeByScoreWithScores
in interface JedisCommands
key
- min
- max
- zrangeByScore(String, double, double)
,
zrangeByScore(String, double, double, int, int)
,
zrangeByScoreWithScores(String, double, double)
,
zrangeByScoreWithScores(String, double, double, int, int)
,
zcount(String, double, double)
public Set<Tuple> zrangeByScoreWithScores(String key, String min, String max, int offset, int count)
zrangeByScoreWithScores
in interface JedisCommands
public Set<String> zrevrangeByScore(String key, double max, double min)
zrevrangeByScore
in interface JedisCommands
public Set<String> zrevrangeByScore(String key, String max, String min)
zrevrangeByScore
in interface JedisCommands
public Set<String> zrevrangeByScore(String key, double max, double min, int offset, int count)
zrevrangeByScore
in interface JedisCommands
public Set<Tuple> zrevrangeByScoreWithScores(String key, double max, double min)
zrevrangeByScoreWithScores
in interface JedisCommands
public Set<Tuple> zrevrangeByScoreWithScores(String key, double max, double min, int offset, int count)
zrevrangeByScoreWithScores
in interface JedisCommands
public Set<Tuple> zrevrangeByScoreWithScores(String key, String max, String min, int offset, int count)
zrevrangeByScoreWithScores
in interface JedisCommands
public Set<String> zrevrangeByScore(String key, String max, String min, int offset, int count)
zrevrangeByScore
in interface JedisCommands
public Set<Tuple> zrevrangeByScoreWithScores(String key, String max, String min)
zrevrangeByScoreWithScores
in interface JedisCommands
public Long zremrangeByRank(String key, long start, long end)
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 JedisCommands
public Long zremrangeByScore(String key, double start, double end)
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 JedisCommands
key
- start
- end
- public Long zremrangeByScore(String key, String start, String end)
zremrangeByScore
in interface JedisCommands
public Long zunionstore(String dstkey, String... sets)
As the terms imply, the ZINTERSTORE
command requires an
element to be present in each of the given inputs to be inserted in the result. The
ZUNIONSTORE
command inserts all elements across all
inputs.
Using the WEIGHTS option, it is possible to add weight to each input sorted set. This means that the score of each element in the sorted set is first multiplied by this weight before being passed to the aggregation. When this option is not given, all weights default to 1.
With the AGGREGATE option, it's possible to specify how the results of the union or intersection are aggregated. This option defaults to SUM, where the score of an element is summed across the inputs where it exists. When this option is set to be either MIN or MAX, the resulting set will contain the minimum or maximum score of an element across the inputs where it exists.
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
zunionstore
in interface MultiKeyCommands
dstkey
- sets
- zunionstore(String, String...)
,
zunionstore(String, ZParams, String...)
,
zinterstore(String, String...)
,
zinterstore(String, ZParams, String...)
public Long zunionstore(String dstkey, ZParams params, String... sets)
As the terms imply, the ZINTERSTORE
command requires an
element to be present in each of the given inputs to be inserted in the result. The
ZUNIONSTORE
command inserts all elements across all
inputs.
Using the WEIGHTS option, it is possible to add weight to each input sorted set. This means that the score of each element in the sorted set is first multiplied by this weight before being passed to the aggregation. When this option is not given, all weights default to 1.
With the AGGREGATE option, it's possible to specify how the results of the union or intersection are aggregated. This option defaults to SUM, where the score of an element is summed across the inputs where it exists. When this option is set to be either MIN or MAX, the resulting set will contain the minimum or maximum score of an element across the inputs where it exists.
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
zunionstore
in interface MultiKeyCommands
dstkey
- sets
- params
- zunionstore(String, String...)
,
zunionstore(String, ZParams, String...)
,
zinterstore(String, String...)
,
zinterstore(String, ZParams, String...)
public Long zinterstore(String dstkey, String... sets)
As the terms imply, the ZINTERSTORE
command requires an
element to be present in each of the given inputs to be inserted in the result. The
ZUNIONSTORE
command inserts all elements across all
inputs.
Using the WEIGHTS option, it is possible to add weight to each input sorted set. This means that the score of each element in the sorted set is first multiplied by this weight before being passed to the aggregation. When this option is not given, all weights default to 1.
With the AGGREGATE option, it's possible to specify how the results of the union or intersection are aggregated. This option defaults to SUM, where the score of an element is summed across the inputs where it exists. When this option is set to be either MIN or MAX, the resulting set will contain the minimum or maximum score of an element across the inputs where it exists.
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
zinterstore
in interface MultiKeyCommands
dstkey
- sets
- zunionstore(String, String...)
,
zunionstore(String, ZParams, String...)
,
zinterstore(String, String...)
,
zinterstore(String, ZParams, String...)
public Long zinterstore(String dstkey, ZParams params, String... sets)
As the terms imply, the ZINTERSTORE
command requires an
element to be present in each of the given inputs to be inserted in the result. The
ZUNIONSTORE
command inserts all elements across all
inputs.
Using the WEIGHTS option, it is possible to add weight to each input sorted set. This means that the score of each element in the sorted set is first multiplied by this weight before being passed to the aggregation. When this option is not given, all weights default to 1.
With the AGGREGATE option, it's possible to specify how the results of the union or intersection are aggregated. This option defaults to SUM, where the score of an element is summed across the inputs where it exists. When this option is set to be either MIN or MAX, the resulting set will contain the minimum or maximum score of an element across the inputs where it exists.
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
zinterstore
in interface MultiKeyCommands
dstkey
- sets
- params
- zunionstore(String, String...)
,
zunionstore(String, ZParams, String...)
,
zinterstore(String, String...)
,
zinterstore(String, ZParams, String...)
public Long zlexcount(String key, String min, String max)
zlexcount
in interface JedisCommands
public Set<String> zrangeByLex(String key, String min, String max)
zrangeByLex
in interface JedisCommands
public Set<String> zrangeByLex(String key, String min, String max, int offset, int count)
zrangeByLex
in interface JedisCommands
public Set<String> zrevrangeByLex(String key, String max, String min)
zrevrangeByLex
in interface JedisCommands
public Set<String> zrevrangeByLex(String key, String max, String min, int offset, int count)
zrevrangeByLex
in interface JedisCommands
public Long zremrangeByLex(String key, String min, String max)
zremrangeByLex
in interface JedisCommands
public Long strlen(String key)
strlen
in interface JedisCommands
public Long lpushx(String key, String... string)
lpushx
in interface JedisCommands
public Long persist(String key)
expire
at turning the expire key into a normal key.
Time complexity: O(1)
persist
in interface JedisCommands
key
- public Long rpushx(String key, String... string)
rpushx
in interface JedisCommands
public String echo(String string)
echo
in interface JedisCommands
public Long linsert(String key, BinaryClient.LIST_POSITION where, String pivot, String value)
linsert
in interface JedisCommands
public String brpoplpush(String source, String destination, int timeout)
brpoplpush
in interface MultiKeyCommands
source
- destination
- timeout
- public Boolean setbit(String key, long offset, boolean value)
setbit
in interface JedisCommands
key
- offset
- value
- public Boolean setbit(String key, long offset, String value)
setbit
in interface JedisCommands
public Boolean getbit(String key, long offset)
getbit
in interface JedisCommands
key
- offset
- public Long setrange(String key, long offset, String value)
setrange
in interface JedisCommands
public String getrange(String key, long startOffset, long endOffset)
getrange
in interface JedisCommands
public Long bitpos(String key, boolean value, BitPosParams params)
public List<String> configGet(String pattern)
CONFIG GET returns the current configuration parameters. This sub command only accepts a single argument, that is glob style pattern. All the configuration parameters matching this parameter are reported as a list of key-value pairs.
Example:
$ redis-cli config get '*' 1. "dbfilename" 2. "dump.rdb" 3. "requirepass" 4. (nil) 5. "masterauth" 6. (nil) 7. "maxmemory" 8. "0\n" 9. "appendfsync" 10. "everysec" 11. "save" 12. "3600 1 300 100 60 10000" $ redis-cli config get 'm*' 1. "masterauth" 2. (nil) 3. "maxmemory" 4. "0\n"
configGet
in interface AdvancedJedisCommands
pattern
- public String configSet(String parameter, String value)
The list of configuration parameters supported by CONFIG SET can be obtained issuing a
CONFIG GET *
command.
The configuration set using CONFIG SET is immediately loaded by the Redis server that will start acting as specified starting from the next command.
Parameters value format
The value of the configuration parameter is the same as the one of the same parameter in the Redis configuration file, with the following exceptions:
configSet
in interface AdvancedJedisCommands
parameter
- value
- public Object eval(String script, int keyCount, String... params)
eval
in interface ScriptingCommands
public void subscribe(JedisPubSub jedisPubSub, String... channels)
subscribe
in interface MultiKeyCommands
public Long publish(String channel, String message)
publish
in interface MultiKeyCommands
public void psubscribe(JedisPubSub jedisPubSub, String... patterns)
psubscribe
in interface MultiKeyCommands
public Object eval(String script, List<String> keys, List<String> args)
eval
in interface ScriptingCommands
public Object eval(String script)
eval
in interface ScriptingCommands
public Object evalsha(String script)
evalsha
in interface ScriptingCommands
public Object evalsha(String sha1, List<String> keys, List<String> args)
evalsha
in interface ScriptingCommands
public Object evalsha(String sha1, int keyCount, String... params)
evalsha
in interface ScriptingCommands
public Boolean scriptExists(String sha1)
scriptExists
in interface ScriptingCommands
public List<Boolean> scriptExists(String... sha1)
scriptExists
in interface ScriptingCommands
public String scriptLoad(String script)
scriptLoad
in interface ScriptingCommands
public List<Slowlog> slowlogGet()
slowlogGet
in interface AdvancedJedisCommands
public List<Slowlog> slowlogGet(long entries)
slowlogGet
in interface AdvancedJedisCommands
public Long objectRefcount(String string)
objectRefcount
in interface AdvancedJedisCommands
public String objectEncoding(String string)
objectEncoding
in interface AdvancedJedisCommands
public Long objectIdletime(String string)
objectIdletime
in interface AdvancedJedisCommands
public Long bitcount(String key)
bitcount
in interface JedisCommands
public Long bitcount(String key, long start, long end)
bitcount
in interface JedisCommands
public Long bitop(BitOP op, String destKey, String... srcKeys)
bitop
in interface MultiKeyCommands
public List<Map<String,String>> sentinelMasters()
redis 127.0.0.1:26381> sentinel masters 1) 1) "name" 2) "mymaster" 3) "ip" 4) "127.0.0.1" 5) "port" 6) "6379" 7) "runid" 8) "93d4d4e6e9c06d0eea36e27f31924ac26576081d" 9) "flags" 10) "master" 11) "pending-commands" 12) "0" 13) "last-ok-ping-reply" 14) "423" 15) "last-ping-reply" 16) "423" 17) "info-refresh" 18) "6107" 19) "num-slaves" 20) "1" 21) "num-other-sentinels" 22) "2" 23) "quorum" 24) "2"
sentinelMasters
in interface SentinelCommands
public List<String> sentinelGetMasterAddrByName(String masterName)
redis 127.0.0.1:26381> sentinel get-master-addr-by-name mymaster 1) "127.0.0.1" 2) "6379"
sentinelGetMasterAddrByName
in interface SentinelCommands
masterName
- public Long sentinelReset(String pattern)
redis 127.0.0.1:26381> sentinel reset mymaster (integer) 1
sentinelReset
in interface SentinelCommands
pattern
- public List<Map<String,String>> sentinelSlaves(String masterName)
redis 127.0.0.1:26381> sentinel slaves mymaster 1) 1) "name" 2) "127.0.0.1:6380" 3) "ip" 4) "127.0.0.1" 5) "port" 6) "6380" 7) "runid" 8) "d7f6c0ca7572df9d2f33713df0dbf8c72da7c039" 9) "flags" 10) "slave" 11) "pending-commands" 12) "0" 13) "last-ok-ping-reply" 14) "47" 15) "last-ping-reply" 16) "47" 17) "info-refresh" 18) "657" 19) "master-link-down-time" 20) "0" 21) "master-link-status" 22) "ok" 23) "master-host" 24) "localhost" 25) "master-port" 26) "6379" 27) "slave-priority" 28) "100"
sentinelSlaves
in interface SentinelCommands
masterName
- public String sentinelFailover(String masterName)
sentinelFailover
in interface SentinelCommands
public String sentinelMonitor(String masterName, String ip, int port, int quorum)
sentinelMonitor
in interface SentinelCommands
public String sentinelRemove(String masterName)
sentinelRemove
in interface SentinelCommands
public String sentinelSet(String masterName, Map<String,String> parameterMap)
sentinelSet
in interface SentinelCommands
public byte[] dump(String key)
@Deprecated public Long pexpire(String key, int milliseconds)
public Long pexpire(String key, long milliseconds)
pexpire
in interface BinaryJedisCommands
pexpire
in interface JedisCommands
pexpire
in class BinaryJedis
public Long pexpireAt(String key, long millisecondsTimestamp)
pexpireAt
in interface JedisCommands
@Deprecated public String psetex(String key, int milliseconds, String value)
public String psetex(String key, long milliseconds, String value)
setex(String, int, String)
}with the sole difference that the expire time is specified in milliseconds instead of seconds.
Time complexity: O(1)key
- milliseconds
- value
- @Deprecated public ScanResult<String> scan(int cursor)
scan
in interface MultiKeyCommands
@Deprecated public ScanResult<String> scan(int cursor, ScanParams params)
@Deprecated public ScanResult<Map.Entry<String,String>> hscan(String key, int cursor)
hscan
in interface JedisCommands
@Deprecated public ScanResult<Map.Entry<String,String>> hscan(String key, int cursor, ScanParams params)
@Deprecated public ScanResult<String> sscan(String key, int cursor)
sscan
in interface JedisCommands
@Deprecated public ScanResult<String> sscan(String key, int cursor, ScanParams params)
@Deprecated public ScanResult<Tuple> zscan(String key, int cursor)
zscan
in interface JedisCommands
@Deprecated public ScanResult<Tuple> zscan(String key, int cursor, ScanParams params)
public ScanResult<String> scan(String cursor)
scan
in interface MultiKeyCommands
public ScanResult<String> scan(String cursor, ScanParams params)
public ScanResult<Map.Entry<String,String>> hscan(String key, String cursor)
hscan
in interface JedisCommands
public ScanResult<Map.Entry<String,String>> hscan(String key, String cursor, ScanParams params)
public ScanResult<String> sscan(String key, String cursor)
sscan
in interface JedisCommands
public ScanResult<String> sscan(String key, String cursor, ScanParams params)
public ScanResult<Tuple> zscan(String key, String cursor)
zscan
in interface JedisCommands
public ScanResult<Tuple> zscan(String key, String cursor, ScanParams params)
public String clusterNodes()
clusterNodes
in interface ClusterCommands
public String clusterMeet(String ip, int port)
clusterMeet
in interface ClusterCommands
public String clusterReset(JedisCluster.Reset resetType)
clusterReset
in interface ClusterCommands
public String clusterAddSlots(int... slots)
clusterAddSlots
in interface ClusterCommands
public String clusterDelSlots(int... slots)
clusterDelSlots
in interface ClusterCommands
public String clusterInfo()
clusterInfo
in interface ClusterCommands
public List<String> clusterGetKeysInSlot(int slot, int count)
clusterGetKeysInSlot
in interface ClusterCommands
public String clusterSetSlotNode(int slot, String nodeId)
clusterSetSlotNode
in interface ClusterCommands
public String clusterSetSlotMigrating(int slot, String nodeId)
clusterSetSlotMigrating
in interface ClusterCommands
public String clusterSetSlotImporting(int slot, String nodeId)
clusterSetSlotImporting
in interface ClusterCommands
public String clusterSetSlotStable(int slot)
clusterSetSlotStable
in interface ClusterCommands
public String clusterForget(String nodeId)
clusterForget
in interface ClusterCommands
public String clusterFlushSlots()
clusterFlushSlots
in interface ClusterCommands
public Long clusterKeySlot(String key)
clusterKeySlot
in interface ClusterCommands
public Long clusterCountKeysInSlot(int slot)
clusterCountKeysInSlot
in interface ClusterCommands
public String clusterSaveConfig()
clusterSaveConfig
in interface ClusterCommands
public String clusterReplicate(String nodeId)
clusterReplicate
in interface ClusterCommands
public List<String> clusterSlaves(String nodeId)
clusterSlaves
in interface ClusterCommands
public String clusterFailover()
clusterFailover
in interface ClusterCommands
public List<Object> clusterSlots()
clusterSlots
in interface ClusterCommands
public String asking()
public Long pubsubNumPat()
public void close()
close
in interface Closeable
close
in interface AutoCloseable
close
in class BinaryJedis
public Long pfadd(String key, String... elements)
pfadd
in interface JedisCommands
public long pfcount(String key)
pfcount
in interface JedisCommands
public long pfcount(String... keys)
pfcount
in interface MultiKeyCommands
public String pfmerge(String destkey, String... sourcekeys)
pfmerge
in interface MultiKeyCommands
public List<String> blpop(int timeout, String key)
blpop
in interface JedisCommands
public List<String> brpop(int timeout, String key)
brpop
in interface JedisCommands
Copyright © 2015. All rights reserved.