public interface KeyCommands
Modifier and Type | Method and Description |
---|---|
boolean |
copy(String srcKey,
String dstKey,
boolean replace)
Copy Command
Copy the value stored at the source key to the destination key.
|
long |
del(String... keys)
Remove the specified keys.
|
long |
del(String key)
Del Command
Remove the specified key.
|
byte[] |
dump(String key)
Dump Command
Serialize the value stored at key in a Redis-specific format and return it to the user.
|
long |
exists(String... keys)
Exists Command
Test if the specified keys exist.
|
boolean |
exists(String key)
Exists Command
Test if the specified key exist.
|
long |
expire(String key,
long seconds)
Expire Command
Set a timeout on the specified key.
|
long |
expire(String key,
long seconds,
ExpiryOption expiryOption)
Similar to
EXPIRE but with optional expiry setting. |
long |
expireAt(String key,
long unixTime)
ExpireAt Command
EXPIREAT works exactly like
EXPIRE but instead to get the
number of seconds representing the Time To Live of the key as a second argument (that is a
relative way of specifying the TTL), it takes an absolute one in the form of a UNIX timestamp
(Number of seconds elapsed since 1 Gen 1970). |
long |
expireAt(String key,
long unixTime,
ExpiryOption expiryOption)
|
long |
expireTime(String key)
ExpireTime Command
Returns the absolute Unix timestamp (since January 1, 1970) in seconds at which the given key will expire.
|
Set<String> |
keys(String pattern)
Keys Command
Returns all the keys matching the glob-style pattern as space separated strings.
|
Long |
memoryUsage(String key)
Memory Usage Command
Report the number of bytes that a key and its value require to be stored in RAM.
|
Long |
memoryUsage(String key,
int samples)
Memory Usage Command
Report the number of bytes that a key and its value require to be stored in RAM.
|
String |
migrate(String host,
int port,
int timeout,
MigrateParams params,
String... keys)
Migrate Command
Atomically transfer a key from a source Redis instance to a destination Redis instance.
|
String |
migrate(String host,
int port,
String key,
int timeout)
Migrate Command
Atomically transfer a key from a source Redis instance to a destination Redis instance.
|
String |
objectEncoding(String key)
Object Encoding Command
Return the internal encoding for the Redis object stored at key.
|
Long |
objectFreq(String key)
Object Freq Command
Return the logarithmic access frequency counter of a Redis object stored at key.
|
Long |
objectIdletime(String key)
Object IdleTime Command
Return the time in seconds since the last access to the value stored at key.
|
Long |
objectRefcount(String key)
Object Refcount Command
Return the reference count of the stored at key.
|
long |
persist(String key)
Persist Command
Undo a
expire at turning the expire key into a normal key. |
long |
pexpire(String key,
long milliseconds)
PExpire Command
This command works exactly like
EXPIRE but the time
to live of the key is specified in milliseconds instead of seconds. |
long |
pexpire(String key,
long milliseconds,
ExpiryOption expiryOption)
Similar to
EXPIRE but with optional expiry setting. |
long |
pexpireAt(String key,
long millisecondsTimestamp)
PExpireAt Command
This command works exactly like
EXPIREAT but
Unix time at which the key will expire is specified in milliseconds instead of seconds. |
long |
pexpireAt(String key,
long millisecondsTimestamp,
ExpiryOption expiryOption)
|
long |
pexpireTime(String key)
PExpireTime Command
Similar to
EXPIRETIME but returns the absolute Unix expiration
timestamp in milliseconds instead of seconds. |
long |
pttl(String key)
PTTL Command
The PTTL command returns the remaining time to live in milliseconds of a key that has an
EXPIRE set. |
String |
randomKey()
RandomKey Command
Return a randomly selected key from the currently selected DB.
|
String |
rename(String oldkey,
String newkey)
|
long |
renamenx(String oldkey,
String newkey)
RenameNX Command
Rename oldkey into newkey but fails if the destination key newkey already exists.
|
String |
restore(String key,
long ttl,
byte[] serializedValue)
Restore Command
Create a key associated with a value that is obtained by deserializing the provided serialized
value (obtained via
DUMP ). |
String |
restore(String key,
long ttl,
byte[] serializedValue,
RestoreParams params)
Restore Command
Create a key associated with a value that is obtained by deserializing the provided serialized
value (obtained via
DUMP ). |
ScanResult<String> |
scan(String cursor) |
ScanResult<String> |
scan(String cursor,
ScanParams params) |
ScanResult<String> |
scan(String cursor,
ScanParams params,
String type) |
List<String> |
sort(String key)
Sort Command
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)
Similar to
SORT but store the result in dstkey . |
long |
sort(String key,
String dstkey)
Similar to
SORT but store the result in dstkey . |
List<String> |
sortReadonly(String key,
SortingParams sortingParams)
Read-only variant of the
SORT command. |
long |
touch(String... keys)
Touch Command
Alters the last access time of a key(s).
|
long |
touch(String key)
Touch Command
Alters the last access time of a key.
|
long |
ttl(String key)
TTL Command
The TTL command returns the remaining time to live in seconds of a key that has an
EXPIRE set. |
String |
type(String key)
Type Command
Return the type of the value stored at key in form of a string.
|
long |
unlink(String... keys)
Similar to
SORT but can be used with multiple keys. |
long |
unlink(String key)
Unlink Command
This command is very similar to
DEL : it removes the specified key. |
boolean exists(String key)
Time complexity: O(1)
key
- true
if the key exists, false
otherwiselong exists(String... keys)
Time complexity: O(N)
keys
- keys
.long persist(String key)
key
- String type(String key)
Time complexity: O(1)
key
- byte[] dump(String key)
Time complexity: O(1) to access the key and additional O(N*M) to serialize it where N is the number of Redis objects composing the value and M their average size.
key
- String restore(String key, long ttl, byte[] serializedValue)
DUMP
).
Time complexity: O(1) to access the key and additional O(N*M) to serialize it where N is the number of Redis objects composing the value and M their average size.
key
- ttl
- If ttl is 0 the key is created without any expire, otherwise the specified expire
time (in milliseconds) is set.serializedValue
- String restore(String key, long ttl, byte[] serializedValue, RestoreParams params)
DUMP
).
Time complexity: O(1) to access the key and additional O(N*M) to serialize it where N is the number of Redis objects composing the value and M their average size.
key
- ttl
- If ttl is 0 the key is created without any expire, otherwise the specified expire
time (in milliseconds) is set.serializedValue
- params
- RestoreParams
long expire(String key, long seconds)
Volatile keys are stored on disk like the other keys, the timeout is persistent too like all the other aspects of the dataset. Saving a dataset containing expires and stopping the server does not stop the flow of time as Redis stores on disk the time when the key will no longer be available as Unix time, and not the remaining seconds.
Since Redis 2.1.3 you can update the value of the timeout of a key already having an expire
set. It is also possible to undo the expire at all turning the key into a normal key using the
PERSIST
command.
Time complexity: O(1)
key
- seconds
- time to expirelong expire(String key, long seconds, ExpiryOption expiryOption)
EXPIRE
but with optional expiry setting.key
- seconds
- time to expireexpiryOption
- can be NX, XX, GT or LTexpire(String, long)
long pexpire(String key, long milliseconds)
EXPIRE
but the time
to live of the key is specified in milliseconds instead of seconds.
Time complexity: O(1)
key
- milliseconds
- time to expirelong pexpire(String key, long milliseconds, ExpiryOption expiryOption)
EXPIRE
but with optional expiry setting.key
- milliseconds
- time to expireexpiryOption
- can be NX, XX, GT or LTpexpire(String, long)
long expireTime(String key)
The command returns -1 if the key exists but has no associated expiration time, and -2 if the key does not exist.
Time complexity: O(1)
key
- long pexpireTime(String key)
EXPIRETIME
but returns the absolute Unix expiration
timestamp in milliseconds instead of seconds.
Time complexity: O(1)
key
- expireTime(String)
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 specifying the TTL), it takes an absolute one in the form of a UNIX timestamp
(Number of seconds elapsed since 1 Gen 1970).
EXPIREAT was introduced in order to implement the Append Only File persistence mode so that EXPIRE commands are automatically translated into EXPIREAT commands for the append only file. Of course EXPIREAT can also used by programmers that need a way to simply specify that a given key should expire at a given time in the future.
Time complexity: O(1)
key
- unixTime
- time to expirelong expireAt(String key, long unixTime, ExpiryOption expiryOption)
key
- unixTime
- time to expireexpiryOption
- can be NX, XX, GT or LTexpireAt(String, long)
long pexpireAt(String key, long millisecondsTimestamp)
EXPIREAT
but
Unix time at which the key will expire is specified in milliseconds instead of seconds.
Time complexity: O(1)
key
- millisecondsTimestamp
- time to expirelong pexpireAt(String key, long millisecondsTimestamp, ExpiryOption expiryOption)
key
- millisecondsTimestamp
- time to expireexpiryOption
- can be NX, XX, GT or LTpexpireAt(String, long)
long ttl(String key)
EXPIRE
set. This introspection capability allows a Redis
connection to check how many seconds a given key will continue to be part of the dataset.
Time complexity: O(1)
key
- long pttl(String key)
EXPIRE
set.
Time complexity: O(1)
key
- long touch(String key)
Time complexity: O(N) where N is the number of keys that will be touched.
key
- long touch(String... keys)
Time complexity: O(N) where N is the number of keys that will be touched.
keys
- List<String> sort(String key)
Sort the elements contained in the List, Set, or Sorted Set values at key. By default, sorting is numeric with elements being compared as double precision floating point numbers. This is the simplest form of SORT.
key
- sort(String, SortingParams)
long sort(String key, String dstkey)
SORT
but store the result in dstkey
.key
- dstkey
- sort(String)
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]
key
- sortingParameters
- SortingParams
long sort(String key, SortingParams sortingParameters, String dstkey)
SORT
but store the result in dstkey
.key
- sortingParameters
- SortingParams
dstkey
- sort(String, SortingParams)
List<String> sortReadonly(String key, SortingParams sortingParams)
SORT
command.
It is exactly like the original SORT but refuses the STORE option and can safely be used in read-only replicas.key
- the key to sortsortingParams
- SortingParams
long del(String key)
Time complexity: O(1)
key
- long del(String... keys)
Time complexity: O(N)
keys
- long unlink(String key)
DEL
: it removes the specified key.
Just like DEL a key is ignored if it does not exist. However, the command performs the actual
memory reclaiming in a different thread, so it is not blocking, while DEL is. This is where the
command name comes from: the command just unlinks the keys from the keyspace. The actual removal
will happen later asynchronously.
Time complexity: O(1) for each key removed regardless of its size. Then the command does O(N) work in a different thread in order to reclaim memory, where N is the number of allocations the deleted objects where composed of.
key
- long unlink(String... keys)
SORT
but can be used with multiple keys.keys
- unlink(String)
boolean copy(String srcKey, String dstKey, boolean replace)
srcKey
- the source key.dstKey
- the destination key.replace
- removes the destination key before copying the value to it, in order to avoid error.true
if source was copied, false
otherwiseString rename(String oldkey, String newkey)
oldkey
to newkey
. If the source and destination name are the same an
error is returned. If newkey
already exists it is overwritten.
Time complexity: O(1)
oldkey
- newkey
- long renamenx(String oldkey, String newkey)
Time complexity: O(1)
oldkey
- newkey
- Long memoryUsage(String key)
Time complexity: O(1)
key
- Long memoryUsage(String key, int samples)
Time complexity: O(1)
key
- samples
- the number of sampled nested values. By default, this option is set to 5.
To sample the all the nested values, use 0.Long objectRefcount(String key)
Time complexity: O(1)
key
- String objectEncoding(String key)
Time complexity: O(1)
key
- Long objectIdletime(String key)
Time complexity: O(1)
key
- Long objectFreq(String key)
Time complexity: O(1)
key
- String migrate(String host, int port, String key, int timeout)
host
- port
- key
- timeout
- the maximum idle time in any moment of the communication with the
destination instance in milliseconds.String migrate(String host, int port, int timeout, MigrateParams params, String... keys)
host
- port
- timeout
- the maximum idle time in any moment of the communication with the
destination instance in milliseconds.params
- MigrateParams
keys
- 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)
pattern
- ScanResult<String> scan(String cursor)
ScanResult<String> scan(String cursor, ScanParams params)
ScanResult<String> scan(String cursor, ScanParams params, String type)
String randomKey()
Time complexity: O(1)
nil
when the database is emptyCopyright © 2022. All rights reserved.