public class BinaryJedis extends Object implements BasicCommands, BinaryJedisCommands, MultiKeyBinaryCommands, AdvancedBinaryJedisCommands, BinaryScriptingCommands, Closeable
| Constructor and Description |
|---|
BinaryJedis() |
BinaryJedis(JedisShardInfo shardInfo) |
BinaryJedis(String host) |
BinaryJedis(String host,
int port) |
BinaryJedis(String host,
int port,
int timeout) |
BinaryJedis(String host,
int port,
int connectionTimeout,
int soTimeout) |
BinaryJedis(URI uri) |
BinaryJedis(URI uri,
int timeout) |
BinaryJedis(URI uri,
int connectionTimeout,
int soTimeout) |
| Modifier and Type | Method and Description |
|---|---|
Long |
append(byte[] key,
byte[] value)
If the key already exists and is a string, this command appends the provided value at the end
of the string.
|
String |
auth(String password)
Request for authentication in a password protected Redis server.
|
String |
bgrewriteaof()
Rewrite the append only file in background when it gets too big.
|
String |
bgsave()
Asynchronously save the DB on disk.
|
Long |
bitcount(byte[] key) |
Long |
bitcount(byte[] key,
long start,
long end) |
Long |
bitop(BitOP op,
byte[] destKey,
byte[]... srcKeys) |
Long |
bitpos(byte[] key,
boolean value) |
Long |
bitpos(byte[] key,
boolean value,
BitPosParams params) |
List<byte[]> |
blpop(byte[]... args) |
List<byte[]> |
blpop(byte[] arg)
Deprecated.
unusable command, this command will be removed in 3.0.0.
|
List<byte[]> |
blpop(int timeout,
byte[]... keys)
BLPOP (and BRPOP) is a blocking list pop primitive.
|
List<byte[]> |
brpop(byte[]... args) |
List<byte[]> |
brpop(byte[] arg)
Deprecated.
unusable command, this command will be removed in 3.0.0.
|
List<byte[]> |
brpop(int timeout,
byte[]... keys)
BLPOP (and BRPOP) is a blocking list pop primitive.
|
byte[] |
brpoplpush(byte[] source,
byte[] destination,
int timeout)
Pop a value from a list, push it to another list and return it; or block until one is available
|
String |
clientGetname() |
String |
clientKill(byte[] client) |
String |
clientList() |
String |
clientSetname(byte[] name) |
void |
close() |
List<byte[]> |
configGet(byte[] pattern)
Retrieve the configuration of a running Redis server.
|
String |
configResetStat()
Reset the stats returned by INFO
|
byte[] |
configSet(byte[] parameter,
byte[] value)
Alter the configuration of a running Redis server.
|
void |
connect() |
Long |
dbSize()
Return the number of keys in the currently selected database.
|
String |
debug(DebugParams params) |
Long |
decr(byte[] key)
Decrement the number stored at key by one.
|
Long |
decrBy(byte[] key,
long integer)
DECRBY work just like
INCR but instead to decrement by 1 the decrement is
integer. |
Long |
del(byte[]... keys)
Remove the specified keys.
|
Long |
del(byte[] key) |
void |
disconnect() |
byte[] |
dump(byte[] key) |
byte[] |
echo(byte[] string) |
Object |
eval(byte[] script) |
Object |
eval(byte[] script,
byte[] keyCount,
byte[]... params) |
Object |
eval(byte[] script,
int keyCount,
byte[]... params) |
Object |
eval(byte[] script,
List<byte[]> keys,
List<byte[]> args)
Evaluates scripts using the Lua interpreter built into Redis starting from version 2.6.0.
|
Object |
evalsha(byte[] sha1) |
Object |
evalsha(byte[] sha1,
int keyCount,
byte[]... params) |
Object |
evalsha(byte[] sha1,
List<byte[]> keys,
List<byte[]> args) |
Boolean |
exists(byte[] key)
Test if the specified key exists.
|
Long |
expire(byte[] key,
int seconds)
Set a timeout on the specified key.
|
Long |
expireAt(byte[] 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 |
flushAll()
Delete all the keys of all the existing databases, not just the currently selected one.
|
String |
flushDB()
Delete all the keys of the currently selected DB.
|
byte[] |
get(byte[] key)
Get the value of the specified key.
|
Boolean |
getbit(byte[] key,
long offset)
Returns the bit value at offset in the string value stored at key
|
Client |
getClient() |
int |
getDB() |
byte[] |
getrange(byte[] key,
long startOffset,
long endOffset) |
byte[] |
getSet(byte[] key,
byte[] value)
GETSET is an atomic set this value and return the old value command.
|
Long |
hdel(byte[] key,
byte[]... fields)
Remove the specified field from an hash stored at key.
|
Boolean |
hexists(byte[] key,
byte[] field)
Test for existence of a specified field in a hash.
|
byte[] |
hget(byte[] key,
byte[] field)
If key holds a hash, retrieve the value associated to the specified field.
|
Map<byte[],byte[]> |
hgetAll(byte[] key)
Return all the fields and associated values in a hash.
|
Long |
hincrBy(byte[] key,
byte[] field,
long value)
Increment the number stored at field in the hash at key by value.
|
Double |
hincrByFloat(byte[] key,
byte[] field,
double value)
Increment the number stored at field in the hash at key by a double precision floating point
value.
|
Set<byte[]> |
hkeys(byte[] key)
Return all the fields in a hash.
|
Long |
hlen(byte[] key)
Return the number of items in a hash.
|
List<byte[]> |
hmget(byte[] key,
byte[]... fields)
Retrieve the values associated to the specified fields.
|
String |
hmset(byte[] key,
Map<byte[],byte[]> hash)
Set the respective fields to the respective values.
|
ScanResult<Map.Entry<byte[],byte[]>> |
hscan(byte[] key,
byte[] cursor) |
ScanResult<Map.Entry<byte[],byte[]>> |
hscan(byte[] key,
byte[] cursor,
ScanParams params) |
Long |
hset(byte[] key,
byte[] field,
byte[] value)
Set the specified hash field to the specified value.
|
Long |
hsetnx(byte[] key,
byte[] field,
byte[] value)
Set the specified hash field to the specified value if the field not exists.
|
List<byte[]> |
hvals(byte[] key)
Return all the values in a hash.
|
Long |
incr(byte[] key)
Increment the number stored at key by one.
|
Long |
incrBy(byte[] key,
long integer)
INCRBY work just like
INCR but instead to increment by 1 the increment is
integer. |
Double |
incrByFloat(byte[] key,
double integer)
INCRBYFLOAT work just like
incrBy(byte[], long) INCRBY} but increments by floats
instead of integers. |
String |
info()
Provide information and statistics about the server.
|
String |
info(String section) |
boolean |
isConnected() |
Set<byte[]> |
keys(byte[] pattern)
Returns all the keys matching the glob-style pattern as space separated strings.
|
Long |
lastsave()
Return the UNIX time stamp of the last successfully saving of the dataset on disk.
|
byte[] |
lindex(byte[] key,
long index)
Return the specified element of the list stored at the specified key.
|
Long |
linsert(byte[] key,
BinaryClient.LIST_POSITION where,
byte[] pivot,
byte[] value) |
Long |
llen(byte[] key)
Return the length of the list stored at the specified key.
|
byte[] |
lpop(byte[] key)
Atomically return and remove the first (LPOP) or last (RPOP) element of the list.
|
Long |
lpush(byte[] key,
byte[]... strings)
Add the string value to the head (LPUSH) or tail (RPUSH) of the list stored at key.
|
Long |
lpushx(byte[] key,
byte[]... string) |
List<byte[]> |
lrange(byte[] key,
long start,
long end)
Return the specified elements of the list stored at the specified key.
|
Long |
lrem(byte[] key,
long count,
byte[] value)
Remove the first count occurrences of the value element from the list.
|
String |
lset(byte[] key,
long index,
byte[] value)
Set a new value as the element at index position of the List at key.
|
String |
ltrim(byte[] key,
long start,
long end)
Trim an existing list so that it will contain only the specified range of elements specified.
|
List<byte[]> |
mget(byte[]... keys)
Get the values of all the specified keys.
|
String |
migrate(byte[] host,
int port,
byte[] key,
int destinationDb,
int timeout) |
void |
monitor(JedisMonitor jedisMonitor)
Dump all the received requests in real time.
|
Long |
move(byte[] key,
int dbIndex)
Move the specified key from the currently selected DB to the specified destination DB.
|
String |
mset(byte[]... keysvalues)
Set the the respective keys to the respective values.
|
Long |
msetnx(byte[]... keysvalues)
Set the the respective keys to the respective values.
|
Transaction |
multi() |
byte[] |
objectEncoding(byte[] key) |
Long |
objectIdletime(byte[] key) |
Long |
objectRefcount(byte[] key) |
Long |
persist(byte[] key)
Undo a
expire at turning the expire key into a normal key. |
Long |
pexpire(byte[] key,
long milliseconds) |
Long |
pexpireAt(byte[] key,
long millisecondsTimestamp) |
Long |
pfadd(byte[] key,
byte[]... elements) |
Long |
pfcount(byte[]... keys) |
long |
pfcount(byte[] key) |
String |
pfmerge(byte[] destkey,
byte[]... sourcekeys) |
String |
ping() |
Pipeline |
pipelined() |
String |
psetex(byte[] key,
int milliseconds,
byte[] value) |
void |
psubscribe(BinaryJedisPubSub jedisPubSub,
byte[]... patterns) |
Long |
pttl(byte[] key) |
Long |
publish(byte[] channel,
byte[] message) |
String |
quit()
Ask the server to silently close the connection.
|
byte[] |
randomBinaryKey()
Return a randomly selected key from the currently selected DB.
|
String |
rename(byte[] oldkey,
byte[] newkey)
Atomically renames the key oldkey to newkey.
|
Long |
renamenx(byte[] oldkey,
byte[] newkey)
Rename oldkey into newkey but fails if the destination key newkey already exists.
|
void |
resetState() |
String |
restore(byte[] key,
int ttl,
byte[] serializedValue) |
byte[] |
rpop(byte[] key)
Atomically return and remove the first (LPOP) or last (RPOP) element of the list.
|
byte[] |
rpoplpush(byte[] srckey,
byte[] 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[]... strings)
Add the string value to the head (LPUSH) or tail (RPUSH) of the list stored at key.
|
Long |
rpushx(byte[] key,
byte[]... string) |
Long |
sadd(byte[] key,
byte[]... members)
Add the specified member to the set value stored at key.
|
String |
save()
Synchronously save the DB on disk.
|
ScanResult<byte[]> |
scan(byte[] cursor) |
ScanResult<byte[]> |
scan(byte[] cursor,
ScanParams params) |
Long |
scard(byte[] key)
Return the set cardinality (number of elements).
|
List<Long> |
scriptExists(byte[]... sha1) |
Long |
scriptExists(byte[] sha1) |
String |
scriptFlush() |
String |
scriptKill() |
byte[] |
scriptLoad(byte[] script) |
Set<byte[]> |
sdiff(byte[]... keys)
Return the difference between the Set stored at key1 and all the Sets key2, ..., keyN
|
Long |
sdiffstore(byte[] dstkey,
byte[]... keys)
This command works exactly like
SDIFF but instead of being returned
the resulting set is stored in dstkey. |
String |
select(int index)
Select the DB with having the specified zero-based numeric index.
|
String |
set(byte[] key,
byte[] value)
Set the string value as value of the key.
|
String |
set(byte[] key,
byte[] value,
byte[] nxxx) |
String |
set(byte[] key,
byte[] value,
byte[] nxxx,
byte[] expx,
int time) |
String |
set(byte[] key,
byte[] value,
byte[] nxxx,
byte[] expx,
long time)
Set the string value as value of the key.
|
Boolean |
setbit(byte[] key,
long offset,
boolean value)
Sets or clears the bit at offset in the string value stored at key
|
Boolean |
setbit(byte[] key,
long offset,
byte[] value) |
String |
setex(byte[] key,
int seconds,
byte[] value)
|
Long |
setnx(byte[] key,
byte[] value)
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) |
String |
shutdown()
Synchronously save the DB on disk, then shutdown the server.
|
Set<byte[]> |
sinter(byte[]... keys)
Return the members of a set resulting from the intersection of all the sets hold at the
specified keys.
|
Long |
sinterstore(byte[] dstkey,
byte[]... keys)
This commnad works exactly like
SINTER but instead of being returned
the resulting set is sotred as dstkey. |
Boolean |
sismember(byte[] key,
byte[] member)
Return 1 if member is a member of the set stored at key, otherwise 0 is returned.
|
String |
slaveof(String host,
int port)
Change the replication settings.
|
String |
slaveofNoOne() |
List<byte[]> |
slowlogGetBinary() |
List<byte[]> |
slowlogGetBinary(long entries) |
Long |
slowlogLen() |
String |
slowlogReset() |
Set<byte[]> |
smembers(byte[] key)
Return all the members (elements) of the set value stored at key.
|
Long |
smove(byte[] srckey,
byte[] dstkey,
byte[] member)
Move the specified member from the set at srckey to the set at dstkey.
|
List<byte[]> |
sort(byte[] key)
Sort a Set or a List.
|
Long |
sort(byte[] key,
byte[] dstkey)
Sort a Set or a List and Store the Result at dstkey.
|
List<byte[]> |
sort(byte[] key,
SortingParams sortingParameters)
Sort a Set or a List accordingly to the specified parameters.
|
Long |
sort(byte[] key,
SortingParams sortingParameters,
byte[] dstkey)
Sort a Set or a List accordingly to the specified parameters and store the result at dstkey.
|
byte[] |
spop(byte[] key)
Remove a random element from a Set returning it as return value.
|
byte[] |
srandmember(byte[] key)
Return a random element from a Set, without removing the element.
|
List<byte[]> |
srandmember(byte[] key,
int count) |
Long |
srem(byte[] key,
byte[]... member)
Remove the specified member from the set value stored at key.
|
ScanResult<byte[]> |
sscan(byte[] key,
byte[] cursor) |
ScanResult<byte[]> |
sscan(byte[] key,
byte[] cursor,
ScanParams params) |
Long |
strlen(byte[] key) |
void |
subscribe(BinaryJedisPubSub jedisPubSub,
byte[]... channels) |
byte[] |
substr(byte[] key,
int start,
int end)
Return a subset of the string from offset start to offset end (both offsets are inclusive).
|
Set<byte[]> |
sunion(byte[]... 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)
This command works exactly like
SUNION but instead of being returned
the resulting set is stored as dstkey. |
void |
sync() |
List<String> |
time() |
Long |
ttl(byte[] key)
The TTL command returns the remaining time to live in seconds of a key that has an
EXPIRE set. |
String |
type(byte[] key)
Return the type of the value stored at key in form of a string.
|
String |
unwatch() |
Long |
waitReplicas(int replicas,
long timeout)
Syncrhonous replication of Redis as described here: http://antirez.com/news/66 Since Java
Object class has implemented "wait" method, we cannot use it, so I had to change the name of
the method.
|
String |
watch(byte[]... keys) |
Long |
zadd(byte[] key,
double score,
byte[] member)
Add the specified member having the specifeid score to the sorted set stored at key.
|
Long |
zadd(byte[] key,
Map<byte[],Double> scoreMembers) |
Long |
zcard(byte[] 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) |
Double |
zincrby(byte[] key,
double score,
byte[] 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(byte[] dstkey,
byte[]... sets)
Creates a union or intersection of N sorted sets given by keys k1 through kN, and stores it at
dstkey.
|
Long |
zinterstore(byte[] dstkey,
ZParams params,
byte[]... sets)
Creates a union or intersection of N sorted sets given by keys k1 through kN, and stores it at
dstkey.
|
Long |
zlexcount(byte[] key,
byte[] min,
byte[] max) |
Set<byte[]> |
zrange(byte[] key,
long start,
long end) |
Set<byte[]> |
zrangeByLex(byte[] key,
byte[] min,
byte[] max) |
Set<byte[]> |
zrangeByLex(byte[] key,
byte[] min,
byte[] max,
int offset,
int count) |
Set<byte[]> |
zrangeByScore(byte[] key,
byte[] min,
byte[] max) |
Set<byte[]> |
zrangeByScore(byte[] key,
byte[] min,
byte[] max,
int offset,
int count) |
Set<byte[]> |
zrangeByScore(byte[] 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<byte[]> |
zrangeByScore(byte[] 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(byte[] key,
byte[] min,
byte[] max) |
Set<Tuple> |
zrangeByScoreWithScores(byte[] key,
byte[] min,
byte[] max,
int offset,
int count) |
Set<Tuple> |
zrangeByScoreWithScores(byte[] 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(byte[] 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> |
zrangeWithScores(byte[] key,
long start,
long end) |
Long |
zrank(byte[] key,
byte[] member)
Return the rank (or index) or member in the sorted set at key, with scores being ordered from
low to high.
|
Long |
zrem(byte[] key,
byte[]... members)
Remove the specified member from the sorted set value stored at key.
|
Long |
zremrangeByLex(byte[] key,
byte[] min,
byte[] max) |
Long |
zremrangeByRank(byte[] key,
long start,
long end)
Remove all elements in the sorted set at key with rank between start and end.
|
Long |
zremrangeByScore(byte[] key,
byte[] start,
byte[] end) |
Long |
zremrangeByScore(byte[] 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).
|
Set<byte[]> |
zrevrange(byte[] key,
long start,
long end) |
Set<byte[]> |
zrevrangeByLex(byte[] key,
byte[] max,
byte[] min) |
Set<byte[]> |
zrevrangeByLex(byte[] key,
byte[] max,
byte[] min,
int offset,
int count) |
Set<byte[]> |
zrevrangeByScore(byte[] key,
byte[] max,
byte[] min) |
Set<byte[]> |
zrevrangeByScore(byte[] key,
byte[] max,
byte[] min,
int offset,
int count) |
Set<byte[]> |
zrevrangeByScore(byte[] key,
double max,
double min) |
Set<byte[]> |
zrevrangeByScore(byte[] key,
double max,
double min,
int offset,
int count) |
Set<Tuple> |
zrevrangeByScoreWithScores(byte[] key,
byte[] max,
byte[] min) |
Set<Tuple> |
zrevrangeByScoreWithScores(byte[] key,
byte[] max,
byte[] min,
int offset,
int count) |
Set<Tuple> |
zrevrangeByScoreWithScores(byte[] key,
double max,
double min) |
Set<Tuple> |
zrevrangeByScoreWithScores(byte[] key,
double max,
double min,
int offset,
int count) |
Set<Tuple> |
zrevrangeWithScores(byte[] key,
long start,
long end) |
Long |
zrevrank(byte[] key,
byte[] 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(byte[] key,
byte[] cursor) |
ScanResult<Tuple> |
zscan(byte[] key,
byte[] cursor,
ScanParams params) |
Double |
zscore(byte[] key,
byte[] member)
Return the score of the specified element of the sorted set at key.
|
Long |
zunionstore(byte[] dstkey,
byte[]... sets)
Creates a union or intersection of N sorted sets given by keys k1 through kN, and stores it at
dstkey.
|
Long |
zunionstore(byte[] dstkey,
ZParams params,
byte[]... sets)
Creates a union or intersection of N sorted sets given by keys k1 through kN, and stores it at
dstkey.
|
public BinaryJedis()
public BinaryJedis(String host)
public BinaryJedis(String host, int port)
public BinaryJedis(String host, int port, int timeout)
public BinaryJedis(String host, int port, int connectionTimeout, int soTimeout)
public BinaryJedis(JedisShardInfo shardInfo)
public BinaryJedis(URI uri)
public BinaryJedis(URI uri, int timeout)
public BinaryJedis(URI uri, int connectionTimeout, int soTimeout)
public String ping()
ping in interface BasicCommandspublic String set(byte[] key, byte[] value)
Time complexity: O(1)
set in interface BinaryJedisCommandskey - value - public String set(byte[] key, byte[] value, byte[] nxxx, byte[] expx, long time)
set in interface BinaryJedisCommandskey - 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 public byte[] get(byte[] key)
Time complexity: O(1)
get in interface BinaryJedisCommandskey - public String quit()
quit in interface BasicCommandspublic Boolean exists(byte[] key)
exists in interface BinaryJedisCommandskey - public Long del(byte[]... keys)
del in interface MultiKeyBinaryCommandskeys - public Long del(byte[] key)
del in interface BinaryJedisCommandspublic String type(byte[] key)
type in interface BinaryJedisCommandskey - public String flushDB()
flushDB in interface BasicCommandspublic Set<byte[]> keys(byte[] 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 MultiKeyBinaryCommandspattern - public byte[] randomBinaryKey()
Time complexity: O(1)
randomBinaryKey in interface MultiKeyBinaryCommandspublic String rename(byte[] oldkey, byte[] newkey)
Time complexity: O(1)
rename in interface MultiKeyBinaryCommandsoldkey - newkey - public Long renamenx(byte[] oldkey, byte[] newkey)
Time complexity: O(1)
renamenx in interface MultiKeyBinaryCommandsoldkey - newkey - public Long dbSize()
dbSize in interface BasicCommandspublic Long expire(byte[] 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 BinaryJedisCommandskey - seconds - public Long expireAt(byte[] 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 BinaryJedisCommandskey - unixTime - public Long ttl(byte[] 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 BinaryJedisCommandskey - public String select(int index)
select in interface BasicCommandsindex - public Long move(byte[] key, int dbIndex)
move in interface BinaryJedisCommandskey - dbIndex - public String flushAll()
flushAll in interface BasicCommandspublic byte[] getSet(byte[] key,
byte[] value)
Time complexity: O(1)
getSet in interface BinaryJedisCommandskey - value - public List<byte[]> mget(byte[]... keys)
Time complexity: O(1) for every key
mget in interface MultiKeyBinaryCommandskeys - public Long setnx(byte[] key, byte[] 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 BinaryJedisCommandskey - value - public String setex(byte[] key, int seconds, byte[] value)
SET + EXPIRE. The operation is
atomic.
Time complexity: O(1)
setex in interface BinaryJedisCommandskey - seconds - value - public String mset(byte[]... 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 MultiKeyBinaryCommandskeysvalues - #msetnx(byte[]...)public Long msetnx(byte[]... 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 MultiKeyBinaryCommandskeysvalues - #mset(byte[]...)public Long decrBy(byte[] 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 BinaryJedisCommandskey - integer - incr(byte[]),
decr(byte[]),
incrBy(byte[], long)public Long decr(byte[] 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 BinaryJedisCommandskey - incr(byte[]),
incrBy(byte[], long),
decrBy(byte[], long)public Long incrBy(byte[] 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 BinaryJedisCommandskey - integer - incr(byte[]),
decr(byte[]),
decrBy(byte[], long)public Double incrByFloat(byte[] key, double integer)
incrBy(byte[], 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 BinaryJedisCommandskey - the key to incrementinteger - the value to increment byincr(byte[]),
decr(byte[]),
decrBy(byte[], long)public Long incr(byte[] 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 BinaryJedisCommandskey - incrBy(byte[], long),
decr(byte[]),
decrBy(byte[], long)public Long append(byte[] key, byte[] 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 BinaryJedisCommandskey - value - public byte[] substr(byte[] 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 BinaryJedisCommandskey - start - end - public Long hset(byte[] key, byte[] field, byte[] value)
If key does not exist, a new key holding a hash is created.
Time complexity: O(1)
hset in interface BinaryJedisCommandskey - field - value - public byte[] hget(byte[] key,
byte[] 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 BinaryJedisCommandskey - field - public Long hsetnx(byte[] key, byte[] field, byte[] value)
hsetnx in interface BinaryJedisCommandskey - field - value - public String hmset(byte[] key, Map<byte[],byte[]> 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 BinaryJedisCommandskey - hash - public List<byte[]> hmget(byte[] key, byte[]... 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 BinaryJedisCommandskey - fields - public Long hincrBy(byte[] key, byte[] field, long value)
The range of values supported by HINCRBY is limited to 64 bit signed integers.
Time complexity: O(1)
hincrBy in interface BinaryJedisCommandskey - field - value - public Double hincrByFloat(byte[] key, byte[] field, double value)
The range of values supported by HINCRBYFLOAT is limited to double precision floating point values.
Time complexity: O(1)
hincrByFloat in interface BinaryJedisCommandskey - field - value - public Boolean hexists(byte[] key, byte[] field)
hexists in interface BinaryJedisCommandskey - field - public Long hdel(byte[] key, byte[]... fields)
Time complexity: O(1)
hdel in interface BinaryJedisCommandskey - fields - public Long hlen(byte[] key)
Time complexity: O(1)
hlen in interface BinaryJedisCommandskey - public Set<byte[]> hkeys(byte[] key)
Time complexity: O(N), where N is the total number of entries
hkeys in interface BinaryJedisCommandskey - public List<byte[]> hvals(byte[] key)
Time complexity: O(N), where N is the total number of entries
hvals in interface BinaryJedisCommandskey - public Map<byte[],byte[]> hgetAll(byte[] key)
Time complexity: O(N), where N is the total number of entries
hgetAll in interface BinaryJedisCommandskey - public Long rpush(byte[] key, byte[]... strings)
Time complexity: O(1)
rpush in interface BinaryJedisCommandskey - strings - BinaryJedis#rpush(byte[], byte[]...)public Long lpush(byte[] key, byte[]... strings)
Time complexity: O(1)
lpush in interface BinaryJedisCommandskey - strings - BinaryJedis#rpush(byte[], byte[]...)public Long llen(byte[] key)
Time complexity: O(1)
llen in interface BinaryJedisCommandskey - public List<byte[]> lrange(byte[] 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 BinaryJedisCommandskey - start - end - public String ltrim(byte[] 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 BinaryJedisCommandskey - start - end - public byte[] lindex(byte[] 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 BinaryJedisCommandskey - index - public String lset(byte[] key, long index, byte[] 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 BinaryJedisCommandskey - index - value - lindex(byte[], long)public Long lrem(byte[] key, long count, byte[] value)
Time complexity: O(N) (with N being the length of the list)
lrem in interface BinaryJedisCommandskey - count - value - public byte[] lpop(byte[] key)
If the key does not exist or the list is already empty the special value 'nil' is returned.
lpop in interface BinaryJedisCommandskey - rpop(byte[])public byte[] rpop(byte[] key)
If the key does not exist or the list is already empty the special value 'nil' is returned.
rpop in interface BinaryJedisCommandskey - lpop(byte[])public byte[] rpoplpush(byte[] srckey,
byte[] 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 MultiKeyBinaryCommandssrckey - dstkey - public Long sadd(byte[] key, byte[]... members)
Time complexity O(1)
sadd in interface BinaryJedisCommandskey - members - public Set<byte[]> smembers(byte[] key)
#sinter(byte[]...) SINTER}.
Time complexity O(N)
smembers in interface BinaryJedisCommandskey - the key of the setpublic Long srem(byte[] key, byte[]... member)
Time complexity O(1)
srem in interface BinaryJedisCommandskey - the key of the setmember - the set member to removepublic byte[] spop(byte[] key)
The srandmember(byte[]) command does a similar work but the returned element is not
removed from the Set.
Time complexity O(1)
spop in interface BinaryJedisCommandskey - public Long smove(byte[] srckey, byte[] dstkey, byte[] 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 MultiKeyBinaryCommandssrckey - dstkey - member - public Long scard(byte[] key)
scard in interface BinaryJedisCommandskey - public Boolean sismember(byte[] key, byte[] member)
Time complexity O(1)
sismember in interface BinaryJedisCommandskey - member - public Set<byte[]> sinter(byte[]... keys)
lrange(byte[], long, long) 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 MultiKeyBinaryCommandskeys - public Long sinterstore(byte[] dstkey, byte[]... 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 MultiKeyBinaryCommandsdstkey - keys - public Set<byte[]> sunion(byte[]... keys)
lrange(byte[], long, long) 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 MultiKeyBinaryCommandskeys - public Long sunionstore(byte[] dstkey, byte[]... 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 MultiKeyBinaryCommandsdstkey - keys - public Set<byte[]> sdiff(byte[]... 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 MultiKeyBinaryCommandskeys - public Long sdiffstore(byte[] dstkey, byte[]... keys)
SDIFF but instead of being returned
the resulting set is stored in dstkey.sdiffstore in interface MultiKeyBinaryCommandsdstkey - keys - public byte[] srandmember(byte[] 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 BinaryJedisCommandskey - public List<byte[]> srandmember(byte[] key, int count)
srandmember in interface BinaryJedisCommandspublic Long zadd(byte[] key, double score, byte[] 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 BinaryJedisCommandskey - score - member - public Long zadd(byte[] key, Map<byte[],Double> scoreMembers)
zadd in interface BinaryJedisCommandspublic Set<byte[]> zrange(byte[] key, long start, long end)
zrange in interface BinaryJedisCommandspublic Long zrem(byte[] key, byte[]... members)
Time complexity O(log(N)) with N being the number of elements in the sorted set
zrem in interface BinaryJedisCommandskey - members - public Double zincrby(byte[] key, double score, byte[] 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 BinaryJedisCommandskey - score - member - public Long zrank(byte[] key, byte[] 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 BinaryJedisCommandskey - member - zrevrank(byte[], byte[])public Long zrevrank(byte[] key, byte[] 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 BinaryJedisCommandskey - member - zrank(byte[], byte[])public Set<byte[]> zrevrange(byte[] key, long start, long end)
zrevrange in interface BinaryJedisCommandspublic Set<Tuple> zrangeWithScores(byte[] key, long start, long end)
zrangeWithScores in interface BinaryJedisCommandspublic Set<Tuple> zrevrangeWithScores(byte[] key, long start, long end)
zrevrangeWithScores in interface BinaryJedisCommandspublic Long zcard(byte[] key)
Time complexity O(1)
zcard in interface BinaryJedisCommandskey - public Double zscore(byte[] key, byte[] member)
Time complexity: O(1)
zscore in interface BinaryJedisCommandskey - member - public Transaction multi()
public void connect()
public void disconnect()
public void resetState()
public String watch(byte[]... keys)
watch in interface MultiKeyBinaryCommandspublic String unwatch()
unwatch in interface MultiKeyBinaryCommandspublic void close()
close in interface Closeableclose in interface AutoCloseablepublic List<byte[]> sort(byte[] 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 BinaryJedisCommandskey - sort(byte[], byte[]),
sort(byte[], SortingParams),
sort(byte[], SortingParams, byte[])public List<byte[]> sort(byte[] 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 BinaryJedisCommandskey - sortingParameters - sort(byte[]),
sort(byte[], SortingParams, byte[])public List<byte[]> blpop(int timeout, byte[]... 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 MultiKeyBinaryCommandstimeout - 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, byte[]...)public Long sort(byte[] key, SortingParams sortingParameters, byte[] dstkey)
sort in interface MultiKeyBinaryCommandskey - sortingParameters - dstkey - sort(byte[], SortingParams),
sort(byte[]),
sort(byte[], byte[])public Long sort(byte[] key, byte[] 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 MultiKeyBinaryCommandskey - dstkey - sort(byte[]),
sort(byte[], SortingParams),
sort(byte[], SortingParams, byte[])public List<byte[]> brpop(int timeout, byte[]... 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 MultiKeyBinaryCommandstimeout - 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, byte[]...)@Deprecated public List<byte[]> blpop(byte[] arg)
blpop in interface BinaryJedisCommands@Deprecated public List<byte[]> brpop(byte[] arg)
brpop in interface BinaryJedisCommandspublic List<byte[]> blpop(byte[]... args)
blpop in interface MultiKeyBinaryCommandspublic List<byte[]> brpop(byte[]... args)
brpop in interface MultiKeyBinaryCommandspublic String auth(String password)
auth in interface BasicCommandspassword - public Pipeline pipelined()
public Long zcount(byte[] key, double min, double max)
zcount in interface BinaryJedisCommandspublic Long zcount(byte[] key, byte[] min, byte[] max)
zcount in interface BinaryJedisCommandspublic Set<byte[]> zrangeByScore(byte[] 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 BinaryJedisCommandskey - min - max - zrangeByScore(byte[], double, double),
zrangeByScore(byte[], double, double, int, int),
zrangeByScoreWithScores(byte[], double, double),
zrangeByScoreWithScores(byte[], double, double, int, int),
zcount(byte[], double, double)public Set<byte[]> zrangeByScore(byte[] key, byte[] min, byte[] max)
zrangeByScore in interface BinaryJedisCommandspublic Set<byte[]> zrangeByScore(byte[] 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 BinaryJedisCommandskey - min - max - zrangeByScore(byte[], double, double),
zrangeByScore(byte[], double, double, int, int),
zrangeByScoreWithScores(byte[], double, double),
zrangeByScoreWithScores(byte[], double, double, int, int),
zcount(byte[], double, double)public Set<byte[]> zrangeByScore(byte[] key, byte[] min, byte[] max, int offset, int count)
zrangeByScore in interface BinaryJedisCommandspublic Set<Tuple> zrangeByScoreWithScores(byte[] 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 BinaryJedisCommandskey - min - max - zrangeByScore(byte[], double, double),
zrangeByScore(byte[], double, double, int, int),
zrangeByScoreWithScores(byte[], double, double),
zrangeByScoreWithScores(byte[], double, double, int, int),
zcount(byte[], double, double)public Set<Tuple> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max)
zrangeByScoreWithScores in interface BinaryJedisCommandspublic Set<Tuple> zrangeByScoreWithScores(byte[] 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 BinaryJedisCommandskey - min - max - zrangeByScore(byte[], double, double),
zrangeByScore(byte[], double, double, int, int),
zrangeByScoreWithScores(byte[], double, double),
zrangeByScoreWithScores(byte[], double, double, int, int),
zcount(byte[], double, double)public Set<Tuple> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max, int offset, int count)
zrangeByScoreWithScores in interface BinaryJedisCommandspublic Set<byte[]> zrevrangeByScore(byte[] key, double max, double min)
zrevrangeByScore in interface BinaryJedisCommandspublic Set<byte[]> zrevrangeByScore(byte[] key, byte[] max, byte[] min)
zrevrangeByScore in interface BinaryJedisCommandspublic Set<byte[]> zrevrangeByScore(byte[] key, double max, double min, int offset, int count)
zrevrangeByScore in interface BinaryJedisCommandspublic Set<byte[]> zrevrangeByScore(byte[] key, byte[] max, byte[] min, int offset, int count)
zrevrangeByScore in interface BinaryJedisCommandspublic Set<Tuple> zrevrangeByScoreWithScores(byte[] key, double max, double min)
zrevrangeByScoreWithScores in interface BinaryJedisCommandspublic Set<Tuple> zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset, int count)
zrevrangeByScoreWithScores in interface BinaryJedisCommandspublic Set<Tuple> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min)
zrevrangeByScoreWithScores in interface BinaryJedisCommandspublic Set<Tuple> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min, int offset, int count)
zrevrangeByScoreWithScores in interface BinaryJedisCommandspublic Long zremrangeByRank(byte[] 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 BinaryJedisCommandspublic Long zremrangeByScore(byte[] 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 BinaryJedisCommandskey - start - end - public Long zremrangeByScore(byte[] key, byte[] start, byte[] end)
zremrangeByScore in interface BinaryJedisCommandspublic Long zunionstore(byte[] dstkey, byte[]... sets)
As the terms imply, the #zinterstore(byte[], byte[]...) ZINTERSTORE} command requires
an element to be present in each of the given inputs to be inserted in the result. The #zunionstore(byte[], byte[]...) 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 MultiKeyBinaryCommandsdstkey - sets - #zunionstore(byte[], byte[]...),
#zunionstore(byte[], ZParams, byte[]...),
#zinterstore(byte[], byte[]...),
#zinterstore(byte[], ZParams, byte[]...)public Long zunionstore(byte[] dstkey, ZParams params, byte[]... 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 MultiKeyBinaryCommandsdstkey - sets - params - #zunionstore(byte[], byte[]...),
#zunionstore(byte[], ZParams, byte[]...),
#zinterstore(byte[], byte[]...),
#zinterstore(byte[], ZParams, byte[]...)public Long zinterstore(byte[] dstkey, byte[]... 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 MultiKeyBinaryCommandsdstkey - sets - #zunionstore(byte[], byte[]...),
#zunionstore(byte[], ZParams, byte[]...),
#zinterstore(byte[], byte[]...),
#zinterstore(byte[], ZParams, byte[]...)public Long zinterstore(byte[] dstkey, ZParams params, byte[]... 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 MultiKeyBinaryCommandsdstkey - sets - params - #zunionstore(byte[], byte[]...),
#zunionstore(byte[], ZParams, byte[]...),
#zinterstore(byte[], byte[]...),
#zinterstore(byte[], ZParams, byte[]...)public Long zlexcount(byte[] key, byte[] min, byte[] max)
zlexcount in interface BinaryJedisCommandspublic Set<byte[]> zrangeByLex(byte[] key, byte[] min, byte[] max)
zrangeByLex in interface BinaryJedisCommandspublic Set<byte[]> zrangeByLex(byte[] key, byte[] min, byte[] max, int offset, int count)
zrangeByLex in interface BinaryJedisCommandspublic Set<byte[]> zrevrangeByLex(byte[] key, byte[] max, byte[] min)
zrevrangeByLex in interface BinaryJedisCommandspublic Set<byte[]> zrevrangeByLex(byte[] key, byte[] max, byte[] min, int offset, int count)
zrevrangeByLex in interface BinaryJedisCommandspublic Long zremrangeByLex(byte[] key, byte[] min, byte[] max)
zremrangeByLex in interface BinaryJedisCommandspublic String save()
Save the whole dataset on disk (this means that all the databases are saved, as well as keys with an EXPIRE set (the expire is preserved). The server hangs while the saving is not completed, no connection is served in the meanwhile. An OK code is returned when the DB was fully stored in disk.
The background variant of this command is BGSAVE that is able to perform the
saving in the background while the server continues serving other clients.
save in interface BasicCommandspublic String bgsave()
Save the DB in background. The OK code is immediately returned. Redis forks, the parent continues to server the clients, the child saves the DB on disk then exit. A client my be able to check if the operation succeeded using the LASTSAVE command.
bgsave in interface BasicCommandspublic String bgrewriteaof()
BGREWRITEAOF rewrites the Append Only File in background when it gets too big. The Redis Append Only File is a Journal, so every operation modifying the dataset is logged in the Append Only File (and replayed at startup). This means that the Append Only File always grows. In order to rebuild its content the BGREWRITEAOF creates a new version of the append only file starting directly form the dataset in memory in order to guarantee the generation of the minimal number of commands needed to rebuild the database.
bgrewriteaof in interface BasicCommandspublic Long lastsave()
Return the UNIX TIME of the last DB save executed with success. A client may check if a
BGSAVE command succeeded reading the LASTSAVE value, then issuing a BGSAVE
command and checking at regular intervals every N seconds if LASTSAVE changed.
lastsave in interface BasicCommandspublic String shutdown()
Stop all the clients, save the DB, then quit the server. This commands makes sure that the DB
is switched off without the lost of any data. This is not guaranteed if the client uses simply
SAVE and then QUIT because other clients may alter the DB data
between the two commands.
shutdown in interface BasicCommandspublic String info()
The info command returns different information and statistics about the server in an format that's simple to parse by computers and easy to read by humans.
Format of the returned String:
All the fields are in the form field:value
edis_version:0.07 connected_clients:1 connected_slaves:0 used_memory:3187 changes_since_last_save:0 last_save_time:1237655729 total_connections_received:1 total_commands_processed:1 uptime_in_seconds:25 uptime_in_days:0Notes
used_memory is returned in bytes, and is the total number of bytes allocated by the program using malloc.
uptime_in_days is redundant since the uptime in seconds contains already the full uptime information, this field is only mainly present for humans.
changes_since_last_save does not refer to the number of key changes, but to the number of operations that produced some kind of change in the dataset.
info in interface BasicCommandspublic String info(String section)
info in interface BasicCommandspublic void monitor(JedisMonitor jedisMonitor)
MONITOR is a debugging command that outputs the whole sequence of commands received by the Redis server. is very handy in order to understand what is happening into the database. This command is used directly via telnet.
jedisMonitor - public String slaveof(String host, int port)
The SLAVEOF command can change the replication settings of a slave on the fly. If a Redis server is arleady acting as slave, the command SLAVEOF NO ONE will turn off the replicaiton turning the Redis server into a MASTER. In the proper form SLAVEOF hostname port will make the server a slave of the specific server listening at the specified hostname and port.
If a server is already a slave of some master, SLAVEOF hostname port will stop the replication against the old server and start the synchrnonization against the new one discarding the old dataset.
The form SLAVEOF no one will stop replication turning the server into a MASTER but will not discard the replication. So if the old master stop working it is possible to turn the slave into a master and set the application to use the new master in read/write. Later when the other Redis server will be fixed it can be configured in order to work as slave.
slaveof in interface BasicCommandshost - port - public String slaveofNoOne()
slaveofNoOne in interface BasicCommandspublic List<byte[]> configGet(byte[] 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 AdvancedBinaryJedisCommandspattern - public String configResetStat()
configResetStat in interface BasicCommandspublic byte[] configSet(byte[] parameter,
byte[] 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 AdvancedBinaryJedisCommandsparameter - value - public boolean isConnected()
public Long strlen(byte[] key)
strlen in interface BinaryJedisCommandspublic void sync()
public Long lpushx(byte[] key, byte[]... string)
lpushx in interface BinaryJedisCommandspublic Long persist(byte[] key)
expire at turning the expire key into a normal key.
Time complexity: O(1)
persist in interface BinaryJedisCommandskey - public Long rpushx(byte[] key, byte[]... string)
rpushx in interface BinaryJedisCommandspublic byte[] echo(byte[] string)
echo in interface BinaryJedisCommandspublic Long linsert(byte[] key, BinaryClient.LIST_POSITION where, byte[] pivot, byte[] value)
linsert in interface BinaryJedisCommandspublic String debug(DebugParams params)
debug in interface BasicCommandspublic Client getClient()
public byte[] brpoplpush(byte[] source,
byte[] destination,
int timeout)
brpoplpush in interface MultiKeyBinaryCommandssource - destination - timeout - public Boolean setbit(byte[] key, long offset, boolean value)
setbit in interface BinaryJedisCommandskey - offset - value - public Boolean setbit(byte[] key, long offset, byte[] value)
setbit in interface BinaryJedisCommandspublic Boolean getbit(byte[] key, long offset)
getbit in interface BinaryJedisCommandskey - offset - public Long bitpos(byte[] key, boolean value)
public Long bitpos(byte[] key, boolean value, BitPosParams params)
public Long setrange(byte[] key, long offset, byte[] value)
setrange in interface BinaryJedisCommandspublic byte[] getrange(byte[] key,
long startOffset,
long endOffset)
getrange in interface BinaryJedisCommandspublic Long publish(byte[] channel, byte[] message)
publish in interface MultiKeyBinaryCommandspublic void subscribe(BinaryJedisPubSub jedisPubSub, byte[]... channels)
subscribe in interface MultiKeyBinaryCommandspublic void psubscribe(BinaryJedisPubSub jedisPubSub, byte[]... patterns)
psubscribe in interface MultiKeyBinaryCommandspublic int getDB()
getDB in interface BasicCommandspublic Object eval(byte[] script, List<byte[]> keys, List<byte[]> args)
eval in interface BinaryScriptingCommandspublic Object eval(byte[] script, byte[] keyCount, byte[]... params)
eval in interface BinaryScriptingCommandspublic Object eval(byte[] script, int keyCount, byte[]... params)
eval in interface BinaryScriptingCommandspublic Object eval(byte[] script)
eval in interface BinaryScriptingCommandspublic Object evalsha(byte[] sha1)
evalsha in interface BinaryScriptingCommandspublic Object evalsha(byte[] sha1, List<byte[]> keys, List<byte[]> args)
evalsha in interface BinaryScriptingCommandspublic Object evalsha(byte[] sha1, int keyCount, byte[]... params)
evalsha in interface BinaryScriptingCommandspublic String scriptFlush()
scriptFlush in interface BinaryScriptingCommandspublic Long scriptExists(byte[] sha1)
public List<Long> scriptExists(byte[]... sha1)
scriptExists in interface BinaryScriptingCommandspublic byte[] scriptLoad(byte[] script)
scriptLoad in interface BinaryScriptingCommandspublic String scriptKill()
scriptKill in interface BinaryScriptingCommandspublic String slowlogReset()
slowlogReset in interface AdvancedBinaryJedisCommandspublic Long slowlogLen()
slowlogLen in interface AdvancedBinaryJedisCommandspublic List<byte[]> slowlogGetBinary()
slowlogGetBinary in interface AdvancedBinaryJedisCommandspublic List<byte[]> slowlogGetBinary(long entries)
slowlogGetBinary in interface AdvancedBinaryJedisCommandspublic Long objectRefcount(byte[] key)
objectRefcount in interface AdvancedBinaryJedisCommandspublic byte[] objectEncoding(byte[] key)
objectEncoding in interface AdvancedBinaryJedisCommandspublic Long objectIdletime(byte[] key)
objectIdletime in interface AdvancedBinaryJedisCommandspublic Long bitcount(byte[] key)
bitcount in interface BinaryJedisCommandspublic Long bitcount(byte[] key, long start, long end)
bitcount in interface BinaryJedisCommandspublic Long bitop(BitOP op, byte[] destKey, byte[]... srcKeys)
bitop in interface MultiKeyBinaryCommandspublic byte[] dump(byte[] key)
public String restore(byte[] key, int ttl, byte[] serializedValue)
public Long pexpire(byte[] key, long milliseconds)
public Long pexpireAt(byte[] key, long millisecondsTimestamp)
public Long pttl(byte[] key)
public String psetex(byte[] key, int milliseconds, byte[] value)
public String set(byte[] key, byte[] value, byte[] nxxx)
public String set(byte[] key, byte[] value, byte[] nxxx, byte[] expx, int time)
public String clientKill(byte[] client)
public String clientGetname()
public String clientList()
public String clientSetname(byte[] name)
public String migrate(byte[] host, int port, byte[] key, int destinationDb, int timeout)
public Long waitReplicas(int replicas, long timeout)
waitReplicas in interface BasicCommandspublic Long pfadd(byte[] key, byte[]... elements)
pfadd in interface BinaryJedisCommandspublic long pfcount(byte[] key)
pfcount in interface BinaryJedisCommandspublic String pfmerge(byte[] destkey, byte[]... sourcekeys)
pfmerge in interface MultiKeyBinaryCommandspublic Long pfcount(byte[]... keys)
pfcount in interface MultiKeyBinaryCommandspublic ScanResult<byte[]> scan(byte[] cursor)
public ScanResult<byte[]> scan(byte[] cursor, ScanParams params)
public ScanResult<Map.Entry<byte[],byte[]>> hscan(byte[] key, byte[] cursor)
public ScanResult<Map.Entry<byte[],byte[]>> hscan(byte[] key, byte[] cursor, ScanParams params)
public ScanResult<byte[]> sscan(byte[] key, byte[] cursor)
public ScanResult<byte[]> sscan(byte[] key, byte[] cursor, ScanParams params)
public ScanResult<Tuple> zscan(byte[] key, byte[] cursor)
public ScanResult<Tuple> zscan(byte[] key, byte[] cursor, ScanParams params)
Processing library Redis by Darius Morawiec. (c) 2015