*418
$4
KEYS
*14
$7
summary
$64
Return every key matching the glob pattern (cross-shard gather).
$5
since
$5
1.0.0
$5
group
$4
scan
$6
syntax
$12
KEYS pattern
$10
complexity
$103
O(N) keys in the whole keyspace — every shard walks its entire map, plus an O(P*K) glob match per key
$6
compat
$4
full
$5
flags
*1
$8
readonly
$9
RANDOMKEY
*14
$7
summary
$38
Return a random key from the keyspace.
$5
since
$5
1.0.0
$5
group
$4
scan
$6
syntax
$9
RANDOMKEY
$10
complexity
$167
O(1) expected — each shard probes a random slot, and the origin folds the candidates through a reservoir weighted by shard key counts, so every key is equally likely
$6
compat
$4
full
$5
flags
*1
$8
readonly
$4
SCAN
*14
$7
summary
$108
Iterate the keyspace incrementally: each call walks ~COUNT buckets of one shard and returns the next cursor.
$5
since
$5
4.0.0
$5
group
$4
scan
$6
syntax
$53
SCAN cursor [MATCH pattern] [COUNT count] [TYPE type]
$10
complexity
$188
O(COUNT) buckets per call, amortised O(N) for a full sweep — reverse-binary cursor, rehash-tolerant (a key present for the whole sweep is returned at least once even across table growth)
$6
compat
$268
differs: cursors encode (shard, position), so a cursor is only valid on the server and shard count that issued it — the same per-node property Redis Cluster cursors have. MATCH and TYPE filter after collection; COUNT bounds the buckets visited, not the keys returned
$5
flags
*1
$8
readonly
$3
DEL
*14
$7
summary
$24
Delete one or more keys.
$5
since
$5
1.0.0
$5
group
$7
generic
$6
syntax
$17
DEL key [key ...]
$10
complexity
$94
O(N) keys, plus O(M) per key holding a collection of M elements (the drop walks the container)
$6
compat
$131
differs: the multi-key form is split by shard and summed with no barrier, so it is not atomic across shards; the single-key form is
$5
flags
*1
$5
write
$6
EXISTS
*14
$7
summary
$39
Count how many of the given keys exist.
$5
since
$5
1.0.0
$5
group
$7
generic
$6
syntax
$20
EXISTS key [key ...]
$10
complexity
$30
O(N) keys, one O(1) probe each
$6
compat
$109
differs: the multi-key form is gathered per shard, so the count is not a point-in-time snapshot across shards
$5
flags
*1
$8
readonly
$6
EXPIRE
*14
$7
summary
$62
Set a key's TTL in seconds (non-positive TTL deletes the key).
$5
since
$5
1.0.0
$5
group
$7
generic
$6
syntax
$18
EXPIRE key seconds
$10
complexity
$4
O(1)
$6
compat
$134
differs: the NX / XX / GT / LT condition flags are not parsed — arity is fixed at 3, so EXPIRE key seconds NX is a wrong-arity error
$5
flags
*1
$5
write
$8
EXPIREAT
*14
$7
summary
$60
Set a key's expiry as an absolute Unix timestamp in seconds.
$5
since
$5
1.0.0
$5
group
$7
generic
$6
syntax
$30
EXPIREAT key unix-time-seconds
$10
complexity
$4
O(1)
$6
compat
$85
differs: the NX / XX / GT / LT condition flags are not parsed — arity is fixed at 3
$5
flags
*1
$5
write
$7
PERSIST
*14
$7
summary
$19
Remove a key's TTL.
$5
since
$5
1.0.0
$5
group
$7
generic
$6
syntax
$11
PERSIST key
$10
complexity
$4
O(1)
$6
compat
$4
full
$5
flags
*1
$5
write
$7
PEXPIRE
*14
$7
summary
$32
Set a key's TTL in milliseconds.
$5
since
$5
1.0.0
$5
group
$7
generic
$6
syntax
$24
PEXPIRE key milliseconds
$10
complexity
$4
O(1)
$6
compat
$85
differs: the NX / XX / GT / LT condition flags are not parsed — arity is fixed at 3
$5
flags
*1
$5
write
$9
PEXPIREAT
*14
$7
summary
$65
Set a key's expiry as an absolute Unix timestamp in milliseconds.
$5
since
$5
1.0.0
$5
group
$7
generic
$6
syntax
$36
PEXPIREAT key unix-time-milliseconds
$10
complexity
$4
O(1)
$6
compat
$85
differs: the NX / XX / GT / LT condition flags are not parsed — arity is fixed at 3
$5
flags
*1
$5
write
$4
PTTL
*14
$7
summary
$69
Return a key's remaining TTL in milliseconds (-1 no TTL, -2 missing).
$5
since
$5
1.0.0
$5
group
$7
generic
$6
syntax
$8
PTTL key
$10
complexity
$4
O(1)
$6
compat
$4
full
$5
flags
*1
$8
readonly
$6
RENAME
*14
$7
summary
$81
Rename a key, overwriting the destination (write routed at the runtime Op level).
$5
since
$5
1.0.0
$5
group
$7
generic
$6
syntax
$17
RENAME key newkey
$10
complexity
$116
O(1) for a string value; O(M) for a collection of M elements (the entry's weight is re-derived by walking the value)
$6
compat
$174
differs: a cross-shard rename is a non-atomic Take then Put — there is a window in which neither key is visible; co-locate the two keys with a {hashtag} for the atomic path
$5
flags
*1
$5
write
$8
RENAMENX
*14
$7
summary
$91
Rename a key only if the destination does not exist (write routed at the runtime Op level).
$5
since
$5
1.0.0
$5
group
$7
generic
$6
syntax
$19
RENAMENX key newkey
$10
complexity
$60
O(1) for a string value; O(M) for a collection of M elements
$6
compat
$154
differs: cross-shard RENAMENX is a non-atomic Take, Put, restore-on-refusal sequence — there is a window in which the source is absent from the keyspace
$5
flags
*1
$5
write
$3
TTL
*14
$7
summary
$64
Return a key's remaining TTL in seconds (-1 no TTL, -2 missing).
$5
since
$5
1.0.0
$5
group
$7
generic
$6
syntax
$7
TTL key
$10
complexity
$4
O(1)
$6
compat
$4
full
$5
flags
*1
$8
readonly
$4
TYPE
*14
$7
summary
$43
Return the type of the value stored at key.
$5
since
$5
1.0.0
$5
group
$7
generic
$6
syntax
$8
TYPE key
$10
complexity
$4
O(1)
$6
compat
$4
full
$5
flags
*1
$8
readonly
$4
COPY
*14
$7
summary
$58
Copy a key's value, and its remaining TTL, to another key.
$5
since
$5
1.0.0
$5
group
$7
generic
$6
syntax
$33
COPY source destination [REPLACE]
$10
complexity
$78
O(1) same-shard; O(V) across shards, where V is the value copied over the ring
$6
compat
$185
differs: the DB argument is not accepted — kevy is single-database. A cross-shard copy is not atomic with anything else, but a failure between its two steps leaves both keys untouched
$5
flags
*1
$5
write
$5
TOUCH
*14
$7
summary
$39
Count how many of the given keys exist.
$5
since
$5
1.0.0
$5
group
$7
generic
$6
syntax
$19
TOUCH key [key ...]
$10
complexity
$61
O(N) keys — one existence probe per key on its owning shard
$6
compat
$118
differs: kevy has no idle-time clock to reset, so TOUCH is EXISTS with the eviction bookkeeping the probe already does
$5
flags
*1
$8
readonly
$6
UNLINK
*14
$7
summary
$61
Delete one or more keys (alias of DEL in kevy's shard model).
$5
since
$5
1.0.0
$5
group
$7
generic
$6
syntax
$20
UNLINK key [key ...]
$10
complexity
$66
O(N) keys, plus O(M) per collection-typed key — identical to DEL
$6
compat
$161
differs: UNLINK is an alias of DEL — the value is freed inline on the owning shard's reactor thread, not by a background thread, so it gives no latency benefit
$5
flags
*1
$5
write
$6
APPEND
*14
$7
summary
$55
Append bytes to a string value; returns the new length.
$5
since
$5
1.0.0
$5
group
$6
string
$6
syntax
$16
APPEND key value
$10
complexity
$195
O(1) amortised while the value is <= 64 B; O(N) per call once it exceeds that (the Arc payload is copied out and re-boxed on every append), so building a large string by repeated APPEND is O(N^2)
$6
compat
$4
full
$5
flags
*1
$5
write
$5
BITOP
*14
$7
summary
$47
Combine strings bitwise into a destination key.
$5
since
$5
1.0.0
$5
group
$6
string
$6
syntax
$42
BITOP AND|OR|XOR|NOT destkey key [key ...]
$10
complexity
$134
O(N) over the longest source; on a multi-shard server each source is read on its own shard and the result written on the destination's
$6
compat
$81
differs: the DIFF / DIFF1 / ANDOR / ONE operators of Redis 8.2 are a syntax error
$5
flags
*1
$5
write
$8
BITCOUNT
*14
$7
summary
$57
Count set bits in a string, optionally over a byte range.
$5
since
$5
1.0.0
$5
group
$6
string
$6
syntax
$24
BITCOUNT key [start end]
$10
complexity
$27
O(N) over the counted bytes
$6
compat
$94
differs: the BYTE / BIT unit argument of Redis 7.0 is not accepted — ranges are byte offsets
$5
flags
*1
$8
readonly
$6
BITPOS
*14
$7
summary
$51
Return the position of the first bit set to 0 or 1.
$5
since
$5
1.0.0
$5
group
$6
string
$6
syntax
$28
BITPOS key bit [start [end]]
$10
complexity
$27
O(N) over the scanned bytes
$6
compat
$94
differs: the BYTE / BIT unit argument of Redis 7.0 is not accepted — ranges are byte offsets
$5
flags
*1
$8
readonly
$6
GETBIT
*14
$7
summary
$47
Return the bit at the given offset of a string.
$5
since
$5
1.0.0
$5
group
$6
string
$6
syntax
$17
GETBIT key offset
$10
complexity
$4
O(1)
$6
compat
$4
full
$5
flags
*1
$8
readonly
$5
GETEX
*14
$7
summary
$47
Read a key and set its expiry in the same call.
$5
since
$5
1.0.0
$5
group
$6
string
$6
syntax
$40
GETEX key [EX seconds | PX milliseconds]
$10
complexity
$4
O(1)
$6
compat
$109
differs: EXAT / PXAT / PERSIST are not accepted, and an expiry of zero or less is refused rather than applied
$5
flags
*1
$5
write
$8
GETRANGE
*14
$7
summary
$38
Return a byte range of a string value.
$5
since
$5
1.0.0
$5
group
$6
string
$6
syntax
$22
GETRANGE key start end
$10
complexity
$28
O(M) over the returned bytes
$6
compat
$4
full
$5
flags
*1
$8
readonly
$6
SETBIT
*14
$7
summary
$57
Set the bit at the given offset, returning its old value.
$5
since
$5
1.0.0
$5
group
$6
string
$6
syntax
$23
SETBIT key offset value
$10
complexity
$71
O(1) amortised; O(N) on the call that grows the value out to the offset
$6
compat
$4
full
$5
flags
*1
$5
write
$8
SETRANGE
*14
$7
summary
$67
Overwrite a string from the given offset, returning the new length.
$5
since
$5
1.0.0
$5
group
$6
string
$6
syntax
$25
SETRANGE key offset value
$10
complexity
$84
O(M) over the written bytes; O(N) on the call that grows the value out to the offset
$6
compat
$4
full
$5
flags
*1
$5
write
$4
DECR
*14
$7
summary
$44
Decrement the integer value of a key by one.
$5
since
$5
1.0.0
$5
group
$6
string
$6
syntax
$8
DECR key
$10
complexity
$4
O(1)
$6
compat
$4
full
$5
flags
*1
$5
write
$6
DECRBY
*14
$7
summary
$57
Decrement the integer value of a key by the given amount.
$5
since
$5
1.0.0
$5
group
$6
string
$6
syntax
$20
DECRBY key decrement
$10
complexity
$4
O(1)
$6
compat
$4
full
$5
flags
*1
$5
write
$3
GET
*14
$7
summary
$33
Return the string value of a key.
$5
since
$5
1.0.0
$5
group
$6
string
$6
syntax
$7
GET key
$10
complexity
$4
O(1)
$6
compat
$4
full
$5
flags
*1
$8
readonly
$6
GETDEL
*14
$7
summary
$47
Return the string value of a key and delete it.
$5
since
$5
1.0.0
$5
group
$6
string
$6
syntax
$10
GETDEL key
$10
complexity
$4
O(1)
$6
compat
$4
full
$5
flags
*1
$5
write
$6
GETSET
*14
$7
summary
$55
Set a key's string value and return its previous value.
$5
since
$5
1.0.0
$5
group
$6
string
$6
syntax
$16
GETSET key value
$10
complexity
$4
O(1)
$6
compat
$4
full
$5
flags
*1
$5
write
$4
INCR
*14
$7
summary
$44
Increment the integer value of a key by one.
$5
since
$5
1.0.0
$5
group
$6
string
$6
syntax
$8
INCR key
$10
complexity
$4
O(1)
$6
compat
$4
full
$5
flags
*1
$5
write
$6
INCRBY
*14
$7
summary
$57
Increment the integer value of a key by the given amount.
$5
since
$5
1.0.0
$5
group
$6
string
$6
syntax
$20
INCRBY key increment
$10
complexity
$4
O(1)
$6
compat
$4
full
$5
flags
*1
$5
write
$11
INCRBYFLOAT
*14
$7
summary
$55
Increment the float value of a key by the given amount.
$5
since
$5
1.0.0
$5
group
$6
string
$6
syntax
$25
INCRBYFLOAT key increment
$10
complexity
$4
O(1)
$6
compat
$160
differs: arithmetic is f64 and the reply uses Rust's shortest-round-trip float printer, not a long double accumulator, so trailing digits can diverge from Redis
$5
flags
*1
$5
write
$4
MGET
*14
$7
summary
$56
Return the values of multiple keys (cross-shard gather).
$5
since
$5
1.0.0
$5
group
$6
string
$6
syntax
$18
MGET key [key ...]
$10
complexity
$50
O(N) keys, one O(1) probe each on the owning shard
$6
compat
$133
differs: keys are grouped by shard and each shard is probed independently, so the reply is not a point-in-time snapshot across shards
$5
flags
*1
$8
readonly
$4
MSET
*14
$7
summary
$50
Set multiple key/value pairs atomically per shard.
$5
since
$5
1.0.0
$5
group
$6
string
$6
syntax
$30
MSET key value [key value ...]
$10
complexity
$29
O(N) pairs, one O(1) SET each
$6
compat
$202
differs: atomic only per shard — pairs are split by key and applied shard-by-shard with no cross-shard barrier, so a reader can observe some pairs written and others not; Redis MSET is globally atomic
$5
flags
*1
$5
write
$6
PSETEX
*14
$7
summary
$45
Set a key's value with a TTL in milliseconds.
$5
since
$5
1.0.0
$5
group
$6
string
$6
syntax
$29
PSETEX key milliseconds value
$10
complexity
$4
O(1)
$6
compat
$4
full
$5
flags
*1
$5
write
$3
SET
*14
$7
summary
$68
Set a key's string value with optional TTL and existence conditions.
$5
since
$5
1.0.0
$5
group
$6
string
$6
syntax
$50
SET key value [EX seconds|PX milliseconds] [NX|XX]
$10
complexity
$4
O(1)
$6
compat
$191
differs: only NX / XX / EX / PX are parsed — KEEPTTL, EXAT, PXAT, GET and the IFEQ family are a syntax error; a repeated expire option is silently accepted last-one-wins instead of erroring
$5
flags
*1
$5
write
$5
SETEX
*14
$7
summary
$40
Set a key's value with a TTL in seconds.
$5
since
$5
1.0.0
$5
group
$6
string
$6
syntax
$23
SETEX key seconds value
$10
complexity
$4
O(1)
$6
compat
$4
full
$5
flags
*1
$5
write
$5
SETNX
*14
$7
summary
$44
Set a key's value only if it does not exist.
$5
since
$5
1.0.0
$5
group
$6
string
$6
syntax
$15
SETNX key value
$10
complexity
$4
O(1)
$6
compat
$4
full
$5
flags
*1
$5
write
$6
STRLEN
*14
$7
summary
$42
Return the length of a key's string value.
$5
since
$5
1.0.0
$5
group
$6
string
$6
syntax
$10
STRLEN key
$10
complexity
$4
O(1)
$6
compat
$4
full
$5
flags
*1
$8
readonly
$4
HDEL
*14
$7
summary
$31
Delete one or more hash fields.
$5
since
$5
1.0.0
$5
group
$4
hash
$6
syntax
$26
HDEL key field [field ...]
$10
complexity
$11
O(M) fields
$6
compat
$4
full
$5
flags
*1
$5
write
$7
HEXISTS
*14
$7
summary
$34
Check whether a hash field exists.
$5
since
$5
1.0.0
$5
group
$4
hash
$6
syntax
$17
HEXISTS key field
$10
complexity
$4
O(1)
$6
compat
$4
full
$5
flags
*1
$8
readonly
$7
HEXPIRE
*14
$7
summary
$41
Set per-field TTLs on a hash, in seconds.
$5
since
$5
1.0.0
$5
group
$4
hash
$6
syntax
$68
HEXPIRE key seconds [NX|XX|GT|LT] FIELDS numfields field [field ...]
$10
complexity
$32
O(F) fields in the FIELDS clause
$6
compat
$120
differs: the FIELDS parse error reads 'Mandatory keyword FIELDS is missing' where Redis says 'Mandatory argument FIELDS'
$5
flags
*1
$5
write
$4
HGET
*14
$7
summary
$33
Return the value of a hash field.
$5
since
$5
1.0.0
$5
group
$4
hash
$6
syntax
$14
HGET key field
$10
complexity
$4
O(1)
$6
compat
$4
full
$5
flags
*1
$8
readonly
$7
HGETALL
*14
$7
summary
$39
Return all fields and values of a hash.
$5
since
$5
1.0.0
$5
group
$4
hash
$6
syntax
$11
HGETALL key
$10
complexity
$53
O(N) fields, with a full copy of every name and value
$6
compat
$4
full
$5
flags
*1
$8
readonly
$7
HINCRBY
*14
$7
summary
$44
Increment the integer value of a hash field.
$5
since
$5
1.0.0
$5
group
$4
hash
$6
syntax
$27
HINCRBY key field increment
$10
complexity
$4
O(1)
$6
compat
$4
full
$5
flags
*1
$5
write
$12
HINCRBYFLOAT
*14
$7
summary
$42
Increment the float value of a hash field.
$5
since
$5
1.0.0
$5
group
$4
hash
$6
syntax
$32
HINCRBYFLOAT key field increment
$10
complexity
$4
O(1)
$6
compat
$4
full
$5
flags
*1
$5
write
$10
HRANDFIELD
*14
$7
summary
$104
Return random fields from a hash; a negative count allows repeats, WITHVALUES pairs each with its value.
$5
since
$5
6.2.0
$5
group
$4
hash
$6
syntax
$35
HRANDFIELD key [count [WITHVALUES]]
$10
complexity
$118
O(count) for the positive form (partial Fisher-Yates over a materialised field list), O(|count|) for the negative form
$6
compat
$4
full
$5
flags
*1
$8
readonly
$5
HKEYS
*14
$7
summary
$33
Return all field names of a hash.
$5
since
$5
1.0.0
$5
group
$4
hash
$6
syntax
$9
HKEYS key
$10
complexity
$11
O(N) fields
$6
compat
$4
full
$5
flags
*1
$8
readonly
$4
HLEN
*14
$7
summary
$38
Return the number of fields in a hash.
$5
since
$5
1.0.0
$5
group
$4
hash
$6
syntax
$8
HLEN key
$10
complexity
$4
O(1)
$6
compat
$4
full
$5
flags
*1
$8
readonly
$5
HMGET
*14
$7
summary
$42
Return the values of multiple hash fields.
$5
since
$5
1.0.0
$5
group
$4
hash
$6
syntax
$27
HMGET key field [field ...]
$10
complexity
$21
O(M) fields requested
$6
compat
$4
full
$5
flags
*1
$8
readonly
$5
HMSET
*14
$7
summary
$41
Deprecated alias of HSET that replies OK.
$5
since
$5
1.0.0
$5
group
$4
hash
$6
syntax
$39
HMSET key field value [field value ...]
$10
complexity
$10
O(M) pairs
$6
compat
$4
full
$5
flags
*1
$5
write
$8
HPERSIST
*14
$7
summary
$34
Remove per-field TTLs from a hash.
$5
since
$5
1.0.0
$5
group
$4
hash
$6
syntax
$47
HPERSIST key FIELDS numfields field [field ...]
$10
complexity
$11
O(F) fields
$6
compat
$117
differs: silently accepts a stray NX|XX|GT|LT token before FIELDS (it shares HEXPIRE's parser) where Redis rejects it
$5
flags
*1
$5
write
$8
HPEXPIRE
*14
$7
summary
$46
Set per-field TTLs on a hash, in milliseconds.
$5
since
$5
1.0.0
$5
group
$4
hash
$6
syntax
$74
HPEXPIRE key milliseconds [NX|XX|GT|LT] FIELDS numfields field [field ...]
$10
complexity
$11
O(F) fields
$6
compat
$52
differs: same FIELDS error-text deviation as HEXPIRE
$5
flags
*1
$5
write
$10
HPEXPIREAT
*14
$7
summary
$62
Set per-field expiries as absolute Unix-millisecond deadlines.
$5
since
$5
1.0.0
$5
group
$4
hash
$6
syntax
$86
HPEXPIREAT key unix-time-milliseconds [NX|XX|GT|LT] FIELDS numfields field [field ...]
$10
complexity
$11
O(F) fields
$6
compat
$52
differs: same FIELDS error-text deviation as HEXPIRE
$5
flags
*1
$5
write
$5
HSCAN
*14
$7
summary
$57
Iterate a hash's fields and values (single-batch cursor).
$5
since
$5
1.0.0
$5
group
$4
hash
$6
syntax
$46
HSCAN key cursor [MATCH pattern] [COUNT count]
$10
complexity
$59
O(N) — the whole hash is copied and returned in one batch
$6
compat
$166
differs: not a cursor iterator — the cursor is always 0 and the entire hash comes back in a single reply; NOVALUES is not parsed and COUNT is validated then ignored
$5
flags
*1
$8
readonly
$4
HSET
*14
$7
summary
$62
Set one or more hash fields; returns the number of new fields.
$5
since
$5
1.0.0
$5
group
$4
hash
$6
syntax
$38
HSET key field value [field value ...]
$10
complexity
$10
O(M) pairs
$6
compat
$4
full
$5
flags
*1
$5
write
$6
HSETNX
*14
$7
summary
$43
Set a hash field only if it does not exist.
$5
since
$5
1.0.0
$5
group
$4
hash
$6
syntax
$22
HSETNX key field value
$10
complexity
$4
O(1)
$6
compat
$4
full
$5
flags
*1
$5
write
$5
HPTTL
*14
$7
summary
$72
Return per-field remaining TTLs in milliseconds (-1 no TTL, -2 missing).
$5
since
$5
4.0.0
$5
group
$4
hash
$6
syntax
$44
HPTTL key FIELDS numfields field [field ...]
$10
complexity
$11
O(F) fields
$6
compat
$88
differs: silently accepts a stray NX|XX|GT|LT token before FIELDS where Redis rejects it
$5
flags
*1
$8
readonly
$4
HTTL
*14
$7
summary
$67
Return per-field remaining TTLs in seconds (-1 no TTL, -2 missing).
$5
since
$5
1.0.0
$5
group
$4
hash
$6
syntax
$43
HTTL key FIELDS numfields field [field ...]
$10
complexity
$11
O(F) fields
$6
compat
$88
differs: silently accepts a stray NX|XX|GT|LT token before FIELDS where Redis rejects it
$5
flags
*1
$8
readonly
$5
HVALS
*14
$7
summary
$28
Return all values of a hash.
$5
since
$5
1.0.0
$5
group
$4
hash
$6
syntax
$9
HVALS key
$10
complexity
$11
O(N) fields
$6
compat
$4
full
$5
flags
*1
$8
readonly
$5
BLPOP
*14
$7
summary
$67
Blocking left pop across one or more lists (effect logged as LPOP).
$5
since
$5
1.0.0
$5
group
$4
list
$6
syntax
$27
BLPOP key [key ...] timeout
$10
complexity
$66
O(1) to serve; the park is O(1) and waiters are woken FIFO per key
$6
compat
$171
differs: on a multi-shard server the multi-key form does not honour Redis's left-to-right key priority — keys on the connection's own shard are served before remote ones
$5
flags
*2
$5
write
$8
blocking
$5
BRPOP
*14
$7
summary
$68
Blocking right pop across one or more lists (effect logged as RPOP).
$5
since
$5
1.0.0
$5
group
$4
list
$6
syntax
$27
BRPOP key [key ...] timeout
$10
complexity
$24
O(1) to serve; FIFO park
$6
compat
$51
differs: same multi-key priority deviation as BLPOP
$5
flags
*2
$5
write
$8
blocking
$10
BRPOPLPUSH
*14
$7
summary
$78
Blocking RPOPLPUSH: pop the source tail and push it onto the destination head.
$5
since
$5
1.0.0
$5
group
$4
list
$6
syntax
$37
BRPOPLPUSH source destination timeout
$10
complexity
$13
O(1) to serve
$6
compat
$236
differs: a cross-shard move is not atomic — the element is popped on the source's shard and pushed on the destination's, and between those two steps it is in neither list. Co-locate the keys with a {hashtag} to get Redis's atomic path
$5
flags
*2
$5
write
$8
blocking
$6
LINDEX
*14
$7
summary
$43
Return the element at the given list index.
$5
since
$5
1.0.0
$5
group
$4
list
$6
syntax
$16
LINDEX key index
$10
complexity
$91
O(1) — the list is a VecDeque, so an index is a direct offset (Redis's quicklist is O(N))
$6
compat
$4
full
$5
flags
*1
$8
readonly
$4
LLEN
*14
$7
summary
$28
Return the length of a list.
$5
since
$5
1.0.0
$5
group
$4
list
$6
syntax
$8
LLEN key
$10
complexity
$4
O(1)
$6
compat
$4
full
$5
flags
*1
$8
readonly
$5
LMOVE
*14
$7
summary
$45
Atomically move an element between two lists.
$5
since
$5
1.0.0
$5
group
$4
list
$6
syntax
$46
LMOVE source destination LEFT|RIGHT LEFT|RIGHT
$10
complexity
$4
O(1)
$6
compat
$60
differs: a cross-shard move is not atomic — see BRPOPLPUSH
$5
flags
*1
$5
write
$4
LPOP
*14
$7
summary
$49
Pop one or more elements from the head of a list.
$5
since
$5
1.0.0
$5
group
$4
list
$6
syntax
$16
LPOP key [count]
$10
complexity
$20
O(C) elements popped
$6
compat
$93
differs: LPOP key 0 on an existing key replies a nil array where Redis replies an empty array
$5
flags
*1
$5
write
$4
LPOS
*14
$7
summary
$48
Return the index of matching elements in a list.
$5
since
$5
1.0.0
$5
group
$4
list
$6
syntax
$61
LPOS key element [RANK rank] [COUNT num-matches] [MAXLEN len]
$10
complexity
$132
O(N) always — the whole list is copied before RANK / COUNT / MAXLEN are applied, so MAXLEN bounds the comparisons but not the copy
$6
compat
$4
full
$5
flags
*1
$8
readonly
$5
LPUSH
*14
$7
summary
$39
Prepend one or more elements to a list.
$5
since
$5
1.0.0
$5
group
$4
list
$6
syntax
$31
LPUSH key element [element ...]
$10
complexity
$32
O(M) values, O(1) amortised each
$6
compat
$4
full
$5
flags
*1
$5
write
$6
LRANGE
*14
$7
summary
$32
Return a range of list elements.
$5
since
$5
1.0.0
$5
group
$4
list
$6
syntax
$21
LRANGE key start stop
$10
complexity
$80
O(M) elements returned — the start offset is skipped in O(1) (Redis is O(S+M))
$6
compat
$4
full
$5
flags
*1
$8
readonly
$4
LREM
*14
$7
summary
$53
Remove elements equal to the given value from a list.
$5
since
$5
1.0.0
$5
group
$4
list
$6
syntax
$22
LREM key count element
$10
complexity
$101
O(N*R) worst case — the scan is O(N) but each removal shifts up to half the deque (Redis is O(N+R))
$6
compat
$4
full
$5
flags
*1
$5
write
$7
LINSERT
*14
$7
summary
$50
Insert an element before or after a pivot element.
$5
since
$5
1.0.0
$5
group
$4
list
$6
syntax
$38
LINSERT key BEFORE|AFTER pivot element
$10
complexity
$51
O(N) — the pivot is found by a scan from the head
$6
compat
$4
full
$5
flags
*1
$5
write
$4
LSET
*14
$7
summary
$40
Set the list element at the given index.
$5
since
$5
1.0.0
$5
group
$4
list
$6
syntax
$22
LSET key index element
$10
complexity
$66
O(1) — a direct index write (Redis is O(N) for a mid-list index)
$6
compat
$4
full
$5
flags
*1
$5
write
$5
LTRIM
*14
$7
summary
$31
Trim a list to the given range.
$5
since
$5
1.0.0
$5
group
$4
list
$6
syntax
$20
LTRIM key start stop
$10
complexity
$21
O(R) elements removed
$6
compat
$4
full
$5
flags
*1
$5
write
$4
RPOP
*14
$7
summary
$49
Pop one or more elements from the tail of a list.
$5
since
$5
1.0.0
$5
group
$4
list
$6
syntax
$16
RPOP key [count]
$10
complexity
$20
O(C) elements popped
$6
compat
$93
differs: RPOP key 0 on an existing key replies a nil array where Redis replies an empty array
$5
flags
*1
$5
write
$9
RPOPLPUSH
*14
$7
summary
$58
Pop the source tail and push it onto the destination head.
$5
since
$5
1.0.0
$5
group
$4
list
$6
syntax
$28
RPOPLPUSH source destination
$10
complexity
$4
O(1)
$6
compat
$60
differs: a cross-shard move is not atomic — see BRPOPLPUSH
$5
flags
*1
$5
write
$5
RPUSH
*14
$7
summary
$38
Append one or more elements to a list.
$5
since
$5
1.0.0
$5
group
$4
list
$6
syntax
$31
RPUSH key element [element ...]
$10
complexity
$32
O(M) values, O(1) amortised each
$6
compat
$4
full
$5
flags
*1
$5
write
$4
SADD
*14
$7
summary
$33
Add one or more members to a set.
$5
since
$5
1.0.0
$5
group
$3
set
$6
syntax
$28
SADD key member [member ...]
$10
complexity
$12
O(M) members
$6
compat
$4
full
$5
flags
*1
$5
write
$5
SCARD
*14
$7
summary
$38
Return the number of members in a set.
$5
since
$5
1.0.0
$5
group
$3
set
$6
syntax
$9
SCARD key
$10
complexity
$4
O(1)
$6
compat
$4
full
$5
flags
*1
$8
readonly
$5
SDIFF
*14
$7
summary
$61
Return the difference of the given sets (cross-shard gather).
$5
since
$5
1.0.0
$5
group
$3
set
$6
syntax
$19
SDIFF key [key ...]
$10
complexity
$34
O(sum of the source cardinalities)
$6
compat
$4
full
$5
flags
*1
$8
readonly
$10
SDIFFSTORE
*14
$7
summary
$56
Store the difference of the given sets into destination.
$5
since
$5
1.0.0
$5
group
$3
set
$6
syntax
$36
SDIFFSTORE destination key [key ...]
$10
complexity
$88
O(sum of the source cardinalities) + O(result) to write the destination on its own shard
$6
compat
$4
full
$5
flags
*1
$5
write
$6
SINTER
*14
$7
summary
$63
Return the intersection of the given sets (cross-shard gather).
$5
since
$5
1.0.0
$5
group
$3
set
$6
syntax
$20
SINTER key [key ...]
$10
complexity
$143
O(sum of the source cardinalities) — there is NO smallest-set-first ordering, so SINTER huge tiny costs O(huge) where Redis costs O(tiny * k)
$6
compat
$4
full
$5
flags
*1
$8
readonly
$11
SINTERSTORE
*14
$7
summary
$58
Store the intersection of the given sets into destination.
$5
since
$5
1.0.0
$5
group
$3
set
$6
syntax
$37
SINTERSTORE destination key [key ...]
$10
complexity
$80
O(sum of the source cardinalities) + O(result); same no-smallest-first algorithm
$6
compat
$4
full
$5
flags
*1
$5
write
$9
SISMEMBER
*14
$7
summary
$43
Check whether a value is a member of a set.
$5
since
$5
1.0.0
$5
group
$3
set
$6
syntax
$20
SISMEMBER key member
$10
complexity
$4
O(1)
$6
compat
$4
full
$5
flags
*1
$8
readonly
$8
SMEMBERS
*14
$7
summary
$28
Return all members of a set.
$5
since
$5
1.0.0
$5
group
$3
set
$6
syntax
$12
SMEMBERS key
$10
complexity
$12
O(N) members
$6
compat
$4
full
$5
flags
*1
$8
readonly
$4
SPOP
*14
$7
summary
$54
Remove and return one or more random members of a set.
$5
since
$5
1.0.0
$5
group
$3
set
$6
syntax
$16
SPOP key [count]
$10
complexity
$101
O(count) expected — each member is drawn by probing a random slot and taking the first occupied one
$6
compat
$4
full
$5
flags
*1
$5
write
$11
SRANDMEMBER
*14
$7
summary
$98
Return one or more random members of a set without removing them. A negative count allows repeats.
$5
since
$5
1.0.0
$5
group
$3
set
$6
syntax
$23
SRANDMEMBER key [count]
$10
complexity
$176
O(count) expected when count is a small fraction of the set (random-slot probing); O(N) once count exceeds a quarter of it, where copying and shuffling beats rejection sampling
$6
compat
$4
full
$5
flags
*1
$8
readonly
$4
SREM
*14
$7
summary
$38
Remove one or more members from a set.
$5
since
$5
1.0.0
$5
group
$3
set
$6
syntax
$28
SREM key member [member ...]
$10
complexity
$12
O(M) members
$6
compat
$4
full
$5
flags
*1
$5
write
$5
SSCAN
*14
$7
summary
$46
Iterate a set's members (single-batch cursor).
$5
since
$5
1.0.0
$5
group
$3
set
$6
syntax
$46
SSCAN key cursor [MATCH pattern] [COUNT count]
$10
complexity
$58
O(N) — the whole set is copied and returned in one batch
$6
compat
$133
differs: not a cursor iterator — the cursor is always 0 and the entire set comes back in one reply; COUNT is validated then ignored
$5
flags
*1
$8
readonly
$6
SUNION
*14
$7
summary
$56
Return the union of the given sets (cross-shard gather).
$5
since
$5
1.0.0
$5
group
$3
set
$6
syntax
$20
SUNION key [key ...]
$10
complexity
$34
O(sum of the source cardinalities)
$6
compat
$4
full
$5
flags
*1
$8
readonly
$11
SUNIONSTORE
*14
$7
summary
$51
Store the union of the given sets into destination.
$5
since
$5
1.0.0
$5
group
$3
set
$6
syntax
$37
SUNIONSTORE destination key [key ...]
$10
complexity
$46
O(sum of the source cardinalities) + O(result)
$6
compat
$4
full
$5
flags
*1
$5
write
$8
BZPOPMIN
*14
$7
summary
$72
Blocking pop of the lowest-scored member across one or more sorted sets.
$5
since
$5
1.0.0
$5
group
$4
zset
$6
syntax
$30
BZPOPMIN key [key ...] timeout
$10
complexity
$34
O(log N) per pop; the park is O(1)
$6
compat
$4
full
$5
flags
*2
$5
write
$8
blocking
$4
ZADD
*14
$7
summary
$64
Add members with scores to a sorted set, with conditional flags.
$5
since
$5
1.0.0
$5
group
$4
zset
$6
syntax
$68
ZADD key [NX|XX] [GT|LT] [CH] [INCR] score member [score member ...]
$10
complexity
$68
O(M log N) — O(1) hash insert plus O(log N) tree insert per member
$6
compat
$4
full
$5
flags
*1
$5
write
$5
ZCARD
*14
$7
summary
$45
Return the number of members in a sorted set.
$5
since
$5
1.0.0
$5
group
$4
zset
$6
syntax
$9
ZCARD key
$10
complexity
$4
O(1)
$6
compat
$4
full
$5
flags
*1
$8
readonly
$6
ZCOUNT
*14
$7
summary
$50
Count members with scores within the given bounds.
$5
since
$5
1.0.0
$5
group
$4
zset
$6
syntax
$18
ZCOUNT key min max
$10
complexity
$102
O(log N) — two rank descents on the order-statistic tree bracket the score range; nothing is scanned
$6
compat
$4
full
$5
flags
*1
$8
readonly
$10
ZDIFFSTORE
*14
$7
summary
$63
Store the difference of the given sorted sets into destination.
$5
since
$5
1.0.0
$5
group
$4
zset
$6
syntax
$44
ZDIFFSTORE destination numkeys key [key ...]
$10
complexity
$93
O(sum of the source cardinalities + R log R); each source is extracted whole on its own shard
$6
compat
$4
full
$5
flags
*1
$5
write
$7
ZINCRBY
*14
$7
summary
$43
Increment a member's score in a sorted set.
$5
since
$5
1.0.0
$5
group
$4
zset
$6
syntax
$28
ZINCRBY key increment member
$10
complexity
$8
O(log N)
$6
compat
$4
full
$5
flags
*1
$5
write
$10
ZINTERCARD
*14
$7
summary
$68
Return the cardinality of the intersection of the given sorted sets.
$5
since
$5
1.0.0
$5
group
$4
zset
$6
syntax
$46
ZINTERCARD numkeys key [key ...] [LIMIT limit]
$10
complexity
$96
O(sum of the source cardinalities) — LIMIT does not short-circuit the gather, only the combine
$6
compat
$4
full
$5
flags
*1
$8
readonly
$11
ZINTERSTORE
*14
$7
summary
$65
Store the intersection of the given sorted sets into destination.
$5
since
$5
1.0.0
$5
group
$4
zset
$6
syntax
$99
ZINTERSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX]
$10
complexity
$44
O(sum of the source cardinalities + R log R)
$6
compat
$4
full
$5
flags
*1
$5
write
$7
ZPOPMIN
*14
$7
summary
$47
Pop up to count members with the lowest scores.
$5
since
$5
1.0.0
$5
group
$4
zset
$6
syntax
$19
ZPOPMIN key [count]
$10
complexity
$10
O(M log N)
$6
compat
$4
full
$5
flags
*1
$5
write
$13
ZPOPMIN.BELOW
*14
$7
summary
$111
kevy extension: pop up to count lowest members with score strictly below the threshold (delayed-job primitive).
$5
since
$5
3.0.0
$5
group
$4
zset
$6
syntax
$31
ZPOPMIN.BELOW key below [count]
$10
complexity
$115
O(M log N) — take_while stops at the first score at or above the threshold, so it never walks past the due prefix
$6
compat
$72
kevy-only: a delayed-job primitive (score = due time); no Redis analogue
$5
flags
*2
$5
write
$9
extension
$6
ZRANGE
*14
$7
summary
$29
Return members by rank range.
$5
since
$5
1.0.0
$5
group
$4
zset
$6
syntax
$34
ZRANGE key start stop [WITHSCORES]
$10
complexity
$89
O(log N + M) — one rank descent seeks to start, then the M requested members are walked
$6
compat
$148
differs: only the legacy 'key start stop [WITHSCORES]' form is accepted — the Redis 6.2 BYSCORE / BYLEX / REV / LIMIT arguments are a syntax error
$5
flags
*1
$8
readonly
$13
ZRANGEBYSCORE
*14
$7
summary
$51
Return members with scores within the given bounds.
$5
since
$5
1.0.0
$5
group
$4
zset
$6
syntax
$59
ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]
$10
complexity
$199
O(log N + M) — a rank descent seeks to the score bound, then only the M in-range members are walked; LIMIT is still applied after the match set is materialised, so it bounds the reply, not the walk
$6
compat
$4
full
$5
flags
*1
$8
readonly
$5
ZRANK
*14
$7
summary
$54
Return a member's rank, ordered from the lowest score.
$5
since
$5
1.0.0
$5
group
$4
zset
$6
syntax
$16
ZRANK key member
$10
complexity
$101
O(log N) — a hash lookup for the score, then one descent of the rank-augmented (score, member) tree
$6
compat
$56
differs: the Redis 7.2 WITHSCORE option is not supported
$5
flags
*1
$8
readonly
$4
ZREM
*14
$7
summary
$45
Remove one or more members from a sorted set.
$5
since
$5
1.0.0
$5
group
$4
zset
$6
syntax
$28
ZREM key member [member ...]
$10
complexity
$10
O(M log N)
$6
compat
$4
full
$5
flags
*1
$5
write
$15
ZREMRANGEBYRANK
*14
$7
summary
$43
Remove members within the given rank range.
$5
since
$5
1.0.0
$5
group
$4
zset
$6
syntax
$30
ZREMRANGEBYRANK key start stop
$10
complexity
$75
O(log N + M log N) — a rank descent seeks to start, then M member deletes
$6
compat
$4
full
$5
flags
*1
$5
write
$16
ZREMRANGEBYSCORE
*14
$7
summary
$51
Remove members with scores within the given bounds.
$5
since
$5
1.0.0
$5
group
$4
zset
$6
syntax
$28
ZREMRANGEBYSCORE key min max
$10
complexity
$63
O(log N + M log N) — a seek finds the hit set, then M deletes
$6
compat
$4
full
$5
flags
*1
$5
write
$16
ZREVRANGEBYSCORE
*14
$7
summary
$66
Return members with scores within the given bounds, highest first.
$5
since
$5
1.0.0
$5
group
$4
zset
$6
syntax
$62
ZREVRANGEBYSCORE key max min [WITHSCORES] [LIMIT offset count]
$10
complexity
$84
O(log N + M) — a seeked forward walk of the M matches, then the result is reversed
$6
compat
$4
full
$5
flags
*1
$8
readonly
$9
ZREVRANGE
*14
$7
summary
$50
Return members by rank range, highest score first.
$5
since
$5
1.0.0
$5
group
$4
zset
$6
syntax
$37
ZREVRANGE key start stop [WITHSCORES]
$10
complexity
$95
O(N + M) — the set is read in rank order and reversed, then the M requested members are taken
$6
compat
$4
full
$5
flags
*1
$8
readonly
$5
ZSCAN
*14
$7
summary
$64
Iterate a sorted set's members and scores (single-batch cursor).
$5
since
$5
1.0.0
$5
group
$4
zset
$6
syntax
$46
ZSCAN key cursor [MATCH pattern] [COUNT count]
$10
complexity
$38
O(N) — the whole set is materialised
$6
compat
$115
differs: not a cursor iterator — every call returns the whole set with cursor 0, and COUNT is parsed then ignored
$5
flags
*1
$8
readonly
$6
ZSCORE
*14
$7
summary
$24
Return a member's score.
$5
since
$5
1.0.0
$5
group
$4
zset
$6
syntax
$17
ZSCORE key member
$10
complexity
$22
O(1) — a hash lookup
$6
compat
$4
full
$5
flags
*1
$8
readonly
$11
ZUNIONSTORE
*14
$7
summary
$58
Store the union of the given sorted sets into destination.
$5
since
$5
1.0.0
$5
group
$4
zset
$6
syntax
$99
ZUNIONSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX]
$10
complexity
$44
O(sum of the source cardinalities + R log R)
$6
compat
$4
full
$5
flags
*1
$5
write
$4
XACK
*14
$7
summary
$49
Acknowledge pending entries for a consumer group.
$5
since
$5
1.0.0
$5
group
$6
stream
$6
syntax
$26
XACK key group id [id ...]
$10
complexity
$10
O(A log P)
$6
compat
$4
full
$5
flags
*1
$5
write
$4
XADD
*14
$7
summary
$48
Append an entry to a stream, with optional trim.
$5
since
$5
1.0.0
$5
group
$6
stream
$6
syntax
$101
XADD key [NOMKSTREAM] [MAXLEN|MINID [=|~] threshold [LIMIT count]] id|* field value [field value ...]
$10
complexity
$126
O(log N) to insert; O(N*F) whenever a MAXLEN / MINID clause actually evicts, because the trim triggers a full weight recompute
$6
compat
$374
differs: answers as valkey 9.1 does, an approximate '~' trim included: it removes only whole nodes of the stream's layout (at most 100 entries or 4 KB of fields each, the fixed stream-node-max-entries / stream-node-max-bytes defaults), up to LIMIT entries (10000 unless given, 0 for no limit); Redis 8.10's KEEPREF / DELREF / ACKED and IDMP / IDMPAUTO options are not parsed
$5
flags
*1
$5
write
$10
XAUTOCLAIM
*14
$7
summary
$59
Scan and claim idle pending entries starting from a cursor.
$5
since
$5
1.0.0
$5
group
$6
stream
$6
syntax
$72
XAUTOCLAIM key group consumer min-idle-time start [COUNT count] [JUSTID]
$10
complexity
$81
O(log P + COUNT log N): at most COUNT x 10 pending entries are looked at per call
$6
compat
$4
full
$5
flags
*1
$5
write
$6
XCLAIM
*14
$7
summary
$51
Claim specific idle pending entries for a consumer.
$5
since
$5
1.0.0
$5
group
$6
stream
$6
syntax
$143
XCLAIM key group consumer min-idle-time id [id ...] [IDLE ms] [TIME unix-time-milliseconds] [RETRYCOUNT count] [FORCE] [JUSTID] [LASTID lastid]
$10
complexity
$22
O(A * (log P + log N))
$6
compat
$4
full
$5
flags
*1
$5
write
$4
XDEL
*14
$7
summary
$35
Delete entries from a stream by ID.
$5
since
$5
1.0.0
$5
group
$6
stream
$6
syntax
$20
XDEL key id [id ...]
$10
complexity
$100
O(D log N + N*F) for D ids — NOT O(1): the trailing weight recompute is linear in the whole stream
$6
compat
$4
full
$5
flags
*1
$5
write
$6
XGROUP
*14
$7
summary
$30
Manage stream consumer groups.
$5
since
$5
1.0.0
$5
group
$6
stream
$6
syntax
$212
XGROUP CREATE key group id|$ [MKSTREAM] [ENTRIESREAD entries-read] | DESTROY key group | SETID key group id|$ [ENTRIESREAD entries-read] | CREATECONSUMER key group consumer | DELCONSUMER key group consumer | HELP
$10
complexity
$94
CREATE / DESTROY: O(1) plus an O(N*F) reweigh. SETID / CREATECONSUMER: O(1). DELCONSUMER: O(P)
$6
compat
$4
full
$5
flags
*1
$5
write
$5
XINFO
*14
$7
summary
$50
Introspect a stream, its groups, or its consumers.
$5
since
$5
1.0.0
$5
group
$6
stream
$6
syntax
$79
XINFO STREAM key [FULL [COUNT count]] | GROUPS key | CONSUMERS key group | HELP
$10
complexity
$266
STREAM: O(log N). GROUPS: O(G log N + G log G) — 'lag' reads the stream's head once per group, and the groups are sorted by name. CONSUMERS: O(C log C), sorted by name. STREAM FULL: O(K + G * (P log C + C log C)) for K entries shown and P pending entries per group
$6
compat
$495
differs: answers field for field as valkey 9.1 does; against Redis 8.10, XINFO STREAM lacks the six idmp-* / pids-* / iids-* fields of an XADD option kevy does not have, radix-tree-keys and radix-tree-nodes are the nodes and tree nodes valkey's layout would hold for the same history (kevy keeps no radix tree), and where the two disagree on 'lag' and 'entries-read' — an ENTRIESREAD above entries-added, a group before the first entry with a deletion behind it — kevy answers as valkey does
$5
flags
*1
$8
readonly
$4
XLEN
*14
$7
summary
$41
Return the number of entries in a stream.
$5
since
$5
1.0.0
$5
group
$6
stream
$6
syntax
$8
XLEN key
$10
complexity
$4
O(1)
$6
compat
$4
full
$5
flags
*1
$8
readonly
$8
XPENDING
*14
$7
summary
$71
Inspect pending entries of a consumer group (summary or extended form).
$5
since
$5
1.0.0
$5
group
$6
stream
$6
syntax
$68
XPENDING key group [[IDLE min-idle-time] start end count [consumer]]
$10
complexity
$126
summary: O(P*C + C log C) — the per-consumer tally is a linear find per PEL row, then sorted by name. extended: O(log P + K)
$6
compat
$142
differs: answers as valkey 9.1 does, except that a delivery count stops at 9223372036854775807 where valkey's wraps round to a negative number
$5
flags
*1
$8
readonly
$6
XRANGE
*14
$7
summary
$41
Return stream entries within an ID range.
$5
since
$5
1.0.0
$5
group
$6
stream
$6
syntax
$34
XRANGE key start end [COUNT count]
$10
complexity
$61
O(log N + M) — a B-tree range descent, COUNT applied lazily
$6
compat
$4
full
$5
flags
*1
$8
readonly
$5
XREAD
*14
$7
summary
$63
Read new entries from one or more streams, optionally blocking.
$5
since
$5
1.0.0
$5
group
$6
stream
$6
syntax
$74
XREAD [COUNT count] [BLOCK milliseconds] STREAMS key [key ...] id [id ...]
$10
complexity
$64
O(S * (log N + M)) over S streams; '$' is O(1); the park is O(1)
$6
compat
$107
differs: answers as valkey 9.1 does; Redis 8.10's unbalanced-streams error also names '+' as an accepted ID
$5
flags
*2
$8
readonly
$8
blocking
$10
XREADGROUP
*14
$7
summary
$68
Read stream entries as a consumer-group member, optionally blocking.
$5
since
$5
1.0.0
$5
group
$6
stream
$6
syntax
$108
XREADGROUP GROUP group consumer [COUNT count] [BLOCK milliseconds] [NOACK] STREAMS key [key ...] id [id ...]
$10
complexity
$119
'>' form: O(log N + M log P) for M entries handed out. History form: O(log P + K log N) for K entries handed back again
$6
compat
$4
full
$5
flags
*2
$5
write
$8
blocking
$9
XREVRANGE
*14
$7
summary
$59
Return stream entries within an ID range, in reverse order.
$5
since
$5
1.0.0
$5
group
$6
stream
$6
syntax
$37
XREVRANGE key end start [COUNT count]
$10
complexity
$12
O(log N + M)
$6
compat
$4
full
$5
flags
*1
$8
readonly
$6
XSETID
*14
$7
summary
$64
Overwrite a stream's last-generated ID and bookkeeping counters.
$5
since
$5
1.0.0
$5
group
$6
stream
$6
syntax
$77
XSETID key last-id [ENTRIESADDED entries-added] [MAXDELETEDID max-deleted-id]
$10
complexity
$8
O(log N)
$6
compat
$4
full
$5
flags
*1
$5
write
$5
XTRIM
*14
$7
summary
$38
Trim a stream by length or minimum ID.
$5
since
$5
1.0.0
$5
group
$6
stream
$6
syntax
$52
XTRIM key MAXLEN|MINID [=|~] threshold [LIMIT count]
$10
complexity
$38
O(R log N + N*F) for R evicted entries
$6
compat
$163
differs: answers as valkey 9.1 does, an approximate '~' trim removing only whole nodes as XADD's does; Redis 8.10's KEEPREF / DELREF / ACKED options are not parsed
$5
flags
*1
$5
write
$6
GEOADD
*14
$7
summary
$57
Add geospatial members (longitude/latitude) to a geo set.
$5
since
$5
1.0.0
$5
group
$3
geo
$6
syntax
$81
GEOADD key [NX|XX] [CH] longitude latitude member [longitude latitude member ...]
$10
complexity
$34
O(M log N); CH adds an O(M^2) term
$6
compat
$4
full
$5
flags
*1
$5
write
$7
GEODIST
*14
$7
summary
$44
Return the distance between two geo members.
$5
since
$5
1.0.0
$5
group
$3
geo
$6
syntax
$40
GEODIST key member1 member2 [m|km|mi|ft]
$10
complexity
$4
O(1)
$6
compat
$4
full
$5
flags
*1
$8
readonly
$7
GEOHASH
*14
$7
summary
$48
Return the base32 geohash string of each member.
$5
since
$5
1.0.0
$5
group
$3
geo
$6
syntax
$31
GEOHASH key member [member ...]
$10
complexity
$4
O(M)
$6
compat
$4
full
$5
flags
*1
$8
readonly
$6
GEOPOS
*14
$7
summary
$45
Return the longitude/latitude of each member.
$5
since
$5
1.0.0
$5
group
$3
geo
$6
syntax
$30
GEOPOS key member [member ...]
$10
complexity
$4
O(M)
$6
compat
$4
full
$5
flags
*1
$8
readonly
$9
GEORADIUS
*14
$7
summary
$69
Legacy radius search around a coordinate, with optional STORE writes.
$5
since
$5
1.0.0
$5
group
$3
geo
$6
syntax
$143
GEORADIUS key longitude latitude radius m|km|mi|ft [WITHCOORD] [WITHDIST] [WITHHASH] [COUNT count [ANY]] [ASC|DESC] [STORE key] [STOREDIST key]
$10
complexity
$196
O(log N + C) — up to nine neighbour cell ranges, each seeked on the score tree; C = members inside the matched cells. STORE / STOREDIST add O(K log K) to write plus O(D) to clear the destination
$6
compat
$108
differs: the destination is written on its own shard, so a STORE across shards is not atomic with the search
$5
flags
*1
$5
write
$17
GEORADIUSBYMEMBER
*14
$7
summary
$75
Legacy radius search around an existing member, with optional STORE writes.
$5
since
$5
1.0.0
$5
group
$3
geo
$6
syntax
$139
GEORADIUSBYMEMBER key member radius m|km|mi|ft [WITHCOORD] [WITHDIST] [WITHHASH] [COUNT count [ANY]] [ASC|DESC] [STORE key] [STOREDIST key]
$10
complexity
$89
O(log N + C) — the seeked nine-cell fetch, same as GEORADIUS; the anchor lookup is O(1)
$6
compat
$108
differs: the destination is written on its own shard, so a STORE across shards is not atomic with the search
$5
flags
*1
$5
write
$9
GEOSEARCH
*14
$7
summary
$66
Search members within a radius or box from a member or coordinate.
$5
since
$5
1.0.0
$5
group
$3
geo
$6
syntax
$183
GEOSEARCH key FROMMEMBER member|FROMLONLAT longitude latitude BYRADIUS radius m|km|mi|ft|BYBOX width height m|km|mi|ft [ASC|DESC] [COUNT count [ANY]] [WITHCOORD] [WITHDIST] [WITHHASH]
$10
complexity
$197
O(log N + C) — up to nine neighbour ranges, each a seeked slice of the score tree; C = members inside the matched geohash cells (the block bound now prunes iteration too, not just distance maths)
$6
compat
$85
differs: STOREDIST is accepted and ignored on the read-only form; COUNT 0 is an error
$5
flags
*1
$8
readonly
$14
GEOSEARCHSTORE
*14
$7
summary
$60
Run GEOSEARCH on source and store the hits into destination.
$5
since
$5
1.0.0
$5
group
$3
geo
$6
syntax
$181
GEOSEARCHSTORE destination source FROMMEMBER member|FROMLONLAT longitude latitude BYRADIUS radius m|km|mi|ft|BYBOX width height m|km|mi|ft [ASC|DESC] [COUNT count [ANY]] [STOREDIST]
$10
complexity
$87
O(log N + C) to search, plus O(D + K log K) to rewrite the destination on its own shard
$6
compat
$238
differs: STOREDIST stores the distance in the unit the query asked for (Redis does the same); the destination is written on its own shard, so the source and destination may live on different cores and the write is not atomic with the read
$5
flags
*1
$5
write
$4
ECHO
*14
$7
summary
$25
Return the given message.
$5
since
$5
1.0.0
$5
group
$10
connection
$6
syntax
$12
ECHO message
$10
complexity
$4
O(1)
$6
compat
$4
full
$5
flags
*1
$8
readonly
$5
HELLO
*14
$7
summary
$72
Handshake: report server info and switch RESP protocol version (2 or 3).
$5
since
$5
1.0.0
$5
group
$10
connection
$6
syntax
$16
HELLO [protover]
$10
complexity
$4
O(1)
$6
compat
$168
differs: only HELLO [2|3] is honoured — the AUTH and SETNAME tails are parsed off and ignored, because kevy has no AUTH and this form does not set the connection name
$5
flags
*1
$8
readonly
$4
PING
*14
$7
summary
$61
Ping the server; returns PONG or echoes the optional message.
$5
since
$5
1.0.0
$5
group
$10
connection
$6
syntax
$14
PING [message]
$10
complexity
$4
O(1)
$6
compat
$164
differs: kevy has no RESP2 subscriber mode, so PING while subscribed does not switch to the array form and non-pubsub commands stay legal on a subscribed connection
$5
flags
*1
$8
readonly
$4
QUIT
*14
$7
summary
$39
Close the connection after replying OK.
$5
since
$5
1.0.0
$5
group
$10
connection
$6
syntax
$4
QUIT
$10
complexity
$4
O(1)
$6
compat
$4
full
$5
flags
*1
$8
readonly
$6
SELECT
*14
$7
summary
$72
Select the logical database; kevy is single-DB and only accepts index 0.
$5
since
$5
1.0.0
$5
group
$10
connection
$6
syntax
$12
SELECT index
$10
complexity
$4
O(1)
$6
compat
$82
differs: kevy is single-DB — SELECT 0 replies OK and any other index is an error
$5
flags
*1
$8
readonly
$12
BGREWRITEAOF
*14
$7
summary
$52
Start an append-only-file rewrite in the background.
$5
since
$5
1.0.0
$5
group
$6
server
$6
syntax
$12
BGREWRITEAOF
$10
complexity
$102
O(S) fan-out; each shard freezes a copy-on-write view and hands serialise plus fsync to its own worker
$6
compat
$123
differs: replies +OK rather than Redis's status line, rewrites one AOF per shard, and replies +OK even when AOF is disabled
$5
flags
*2
$5
write
$5
admin
$6
BGSAVE
*14
$7
summary
$40
Start a snapshot save in the background.
$5
since
$5
1.0.0
$5
group
$6
server
$6
syntax
$6
BGSAVE
$10
complexity
$93
O(S) fan-out; O(N/S) copy-on-write freeze per shard on the reactor, then serialise off-thread
$6
compat
$83
differs: replies +OK rather than Redis's status line, and writes one dump per shard
$5
flags
*2
$5
write
$5
admin
$4
TIME
*14
$7
summary
$57
Return the server clock as unix seconds and microseconds.
$5
since
$5
1.0.0
$5
group
$6
server
$6
syntax
$4
TIME
$10
complexity
$4
O(1)
$6
compat
$4
full
$5
flags
*1
$8
readonly
$7
COMMAND
*14
$7
summary
$67
Introspect the command table (COUNT, LIST, INFO, DOCS subcommands).
$5
since
$5
1.0.0
$5
group
$6
server
$6
syntax
$82
COMMAND [COUNT | LIST | INFO command [command ...] | DOCS [command [command ...]]]
$10
complexity
$109
bare / LIST / DOCS: O(V) verbs. COUNT: O(1). INFO / DOCS with k names: O(k*V) — the lookup is a linear scan
$6
compat
$179
differs: COUNT / LIST / INFO / DOCS only — GETKEYS and GETKEYSANDFLAGS are absent, and the info rows hard-code first/last/step and leave ACL categories, tips and key-specs empty
$5
flags
*1
$8
readonly
$6
CONFIG
*14
$7
summary
$47
Read or change server configuration parameters.
$5
since
$5
1.0.0
$5
group
$6
server
$6
syntax
$64
CONFIG GET parameter | SET parameter value | REWRITE | RESETSTAT
$10
complexity
$122
GET: O(patterns * 16). SET: O(1) plus one config swap that shards pick up on their next tick. REWRITE: O(config file size)
$6
compat
$258
differs: 16 Redis-named parameters exist; only maxmemory, maxmemory-policy, appendfsync, the auto-rewrite pair, hz, maxmemory-samples, loglevel and logfile are hot-settable — bind, port, io-threads, dir and appendonly error at runtime; RESETSTAT is a no-op
$5
flags
*2
$5
write
$5
admin
$6
CLIENT
*14
$7
summary
$49
Connection introspection and control subcommands.
$5
since
$5
1.0.0
$5
group
$6
server
$6
syntax
$80
CLIENT ID | GETNAME | SETNAME name | LIST | KILL filter | INFO | NO-EVICT ON|OFF
$10
complexity
$91
ID / GETNAME / SETNAME / INFO: O(1). LIST: O(S) fan-out + O(C) rows. KILL: O(S) + O(C) scan
$6
compat
$213
differs: ID / GETNAME / SETNAME / INFO / LIST (bare) / KILL (ID, ADDR) / NO-EVICT only; CLIENT LIST with a filter is a syntax error and every other subcommand (PAUSE, REPLY, TRACKING, UNBLOCK, NO-TOUCH) is unknown
$5
flags
*2
$8
readonly
$5
admin
$7
CLUSTER
*14
$7
summary
$64
Cluster topology introspection (virtual-node model over shards).
$5
since
$5
1.0.0
$5
group
$6
server
$6
syntax
$74
CLUSTER INFO | NODES | SLOTS | SHARDS | KEYSLOT key | COUNTKEYSINSLOT slot
$10
complexity
$89
INFO / NODES / SLOTS / SHARDS / MYID: O(S). KEYSLOT: O(len(key)). COUNTKEYSINSLOT: O(N/S)
$6
compat
$255
differs: a read-only virtual-node topology derived from config (one virtual master per shard) — no gossip, no MEET / FORGET / SETSLOT effect (they reply OK as no-ops), no MIGRATE / ASK, no failover; COUNTKEYSINSLOT counts only the answering shard's keys
$5
flags
*2
$8
readonly
$5
admin
$6
DBSIZE
*14
$7
summary
$44
Return the number of keys across all shards.
$5
since
$5
1.0.0
$5
group
$6
server
$6
syntax
$6
DBSIZE
$10
complexity
$81
O(S) — one message per shard, each answering O(1) from its map length; NOT O(N)
$6
compat
$4
full
$5
flags
*1
$8
readonly
$5
DEBUG
*14
$7
summary
$81
Debug subcommands; SLEEP blocks the shard, other subcommands are tolerated as OK.
$5
since
$5
1.0.0
$5
group
$6
server
$6
syntax
$43
DEBUG SLEEP seconds | subcommand [args ...]
$10
complexity
$117
SLEEP: parks the ANSWERING shard's reactor thread for the duration (other shards keep serving). Everything else: O(1)
$6
compat
$167
differs: SLEEP is the only subcommand with an effect and it blocks one shard, not the server; every other subcommand is accepted and answered OK without doing anything
$5
flags
*2
$8
readonly
$5
admin
$8
FLUSHALL
*14
$7
summary
$32
Delete every key on every shard.
$5
since
$5
1.0.0
$5
group
$6
server
$6
syntax
$8
FLUSHALL
$10
complexity
$88
O(S) fan-out; per shard O(N/S) clear plus WATCH invalidation plus a feed-generation bump
$6
compat
$169
differs: ASYNC / SYNC are accepted and ignored (the flush is always synchronous per shard), and it bumps the CDC feed generation, so live FEED cursors get a resync error
$5
flags
*1
$5
write
$7
FLUSHDB
*14
$7
summary
$79
Delete every key of the current database (kevy is single-DB: same as FLUSHALL).
$5
since
$5
1.0.0
$5
group
$6
server
$6
syntax
$7
FLUSHDB
$10
complexity
$34
O(N + S) — identical to FLUSHALL
$6
compat
$88
differs: kevy is single-DB, so FLUSHDB is an alias of FLUSHALL; ASYNC / SYNC are ignored
$5
flags
*1
$5
write
$4
INFO
*14
$7
summary
$53
Report server statistics and status sections as text.
$5
since
$5
1.0.0
$5
group
$6
server
$6
syntax
$14
INFO [section]
$10
complexity
$76
O(1) in the keyspace — it never walks it; O(S) to sum the per-shard gauges
$6
compat
$271
differs: 8 sections only (server, clients, memory, persistence, stats, replication, cluster, keyspace) — no commandstats / latencystats / errorstats / cpu; reports redis_version 7.4.0 for client sniffing plus a kevy_version line, and the values are up to one tick stale
$5
flags
*1
$8
readonly
$6
MEMORY
*14
$7
summary
$33
Memory introspection subcommands.
$5
since
$5
1.0.0
$5
group
$6
server
$6
syntax
$72
MEMORY USAGE key [SAMPLES count] | STATS | DOCTOR | PURGE | MALLOC-STATS
$10
complexity
$95
USAGE: O(1) — the accounting is exact, not sampled. STATS: O(1) from the instance-wide gauges
$6
compat
$204
differs: USAGE's SAMPLES count is parsed and ignored (our accounting is exact); PURGE is a no-op (system allocator, no arena); DOCTOR and MALLOC-STATS return canned strings; STATS is a trimmed 8-field set
$5
flags
*1
$8
readonly
$4
SAVE
*14
$7
summary
$43
Synchronously snapshot the dataset to disk.
$5
since
$5
1.0.0
$5
group
$6
server
$6
syntax
$4
SAVE
$10
complexity
$51
O(S) fan-out; O(N/S) copy-on-write freeze per shard
$6
compat
$187
differs: SAVE is no longer synchronous-until-durable — it freezes a copy-on-write view and replies OK immediately, so 'SAVE returned, therefore the dump is safe to copy' no longer holds
$5
flags
*2
$5
write
$5
admin
$8
SHUTDOWN
*14
$7
summary
$59
Stop the server process (connection drops without a reply).
$5
since
$5
1.0.0
$5
group
$6
server
$6
syntax
$22
SHUTDOWN [NOSAVE|SAVE]
$10
complexity
$58
O(1) to trip the stop flag; the drain that follows is O(N)
$6
compat
$87
differs: only SHUTDOWN [NOSAVE|SAVE] parses — NOW, FORCE and ABORT are a syntax error
$5
flags
*2
$5
write
$5
admin
$7
SLOWLOG
*14
$7
summary
$38
Inspect or reset the slow-command log.
$5
since
$5
1.0.0
$5
group
$6
server
$6
syntax
$40
SLOWLOG GET [count] | LEN | RESET | HELP
$10
complexity
$66
GET: O(S) fan-out plus O(L log L) to merge. LEN: O(S). RESET: O(S)
$6
compat
$167
differs: the log is per-shard and GET merges across shards by timestamp, so ids are not globally monotonic; every entry's client-addr and client-name are empty strings
$5
flags
*2
$8
readonly
$5
admin
$8
FAILOVER
*14
$7
summary
$108
Planned zero-loss handover: quiesce writes, wait for the target replica to drain, promote it, and follow it.
$5
since
$5
3.0.0
$5
group
$11
replication
$6
syntax
$39
FAILOVER host port [TIMEOUT ms] | ABORT
$10
complexity
$101
O(1) at the command — the handover runs in the background, polling the target until it is caught up
$6
compat
$245
differs: Redis's syntax is FAILOVER [TO host port [FORCE]] [ABORT] [TIMEOUT ms] with an optional target; kevy's is FAILOVER host port [TIMEOUT ms] | ABORT — the target is mandatory and positional, and the port given is the target's client port
$5
flags
*2
$5
write
$5
admin
$10
REPL.TOKEN
*14
$7
summary
$159
kevy extension: mint a read-your-writes token — per-shard [generation, offset] pairs (a primary reports its live feed tail; a replica its applied positions).
$5
since
$5
3.0.0
$5
group
$11
replication
$6
syntax
$10
REPL.TOKEN
$10
complexity
$48
O(S) — one (generation, offset) pair per shard
$6
compat
$129
kevy-only: the read-your-writes token; the nearest Redis concept is master_repl_offset, which is not a resumable per-shard cursor
$5
flags
*2
$8
readonly
$9
extension
$9
REPL.WAIT
*14
$7
summary
$274
kevy extension: on a replica, block until every shard has applied the given REPL.TOKEN (then reads are read-your-writes); +OK on success, -MISDIRECTED writer is <primary> on timeout or generation mismatch. Default TIMEOUT 1000 ms, hard cap 60 s. On a primary: immediate +OK.
$5
since
$5
3.0.0
$5
group
$11
replication
$6
syntax
$60
REPL.WAIT gen offset [gen offset ...] [TIMEOUT milliseconds]
$10
complexity
$134
O(S) — a barrier, not a keyspace op; the wall-clock cost is the replication lag, bounded by TIMEOUT (default 1s, hard-capped at 60s)
$6
compat
$133
kevy-only: waits until a (generation, offset) token has been applied, which is what makes read-your-writes possible across a failover
$5
flags
*3
$8
readonly
$8
blocking
$9
extension
$9
REPLICAOF
*14
$7
summary
$65
Make this server a replica of another, or promote it with NO ONE.
$5
since
$5
1.0.0
$5
group
$11
replication
$6
syntax
$28
REPLICAOF host port | NO ONE
$10
complexity
$75
O(1) at the command; the full resync that follows is O(N) in the background
$6
compat
$159
differs: the port argument is the primary's REPLICATION port base, not its client port (the default base is client port + 10000); chain replication is rejected
$5
flags
*2
$5
write
$5
admin
$4
ROLE
*14
$7
summary
$53
Report the replication role and state of this server.
$5
since
$5
1.0.0
$5
group
$11
replication
$6
syntax
$4
ROLE
$10
complexity
$36
O(1) on a replica; O(R) on a primary
$6
compat
$4
full
$5
flags
*1
$8
readonly
$7
SLAVEOF
*14
$7
summary
$26
Legacy alias of REPLICAOF.
$5
since
$5
1.0.0
$5
group
$11
replication
$6
syntax
$26
SLAVEOF host port | NO ONE
$10
complexity
$29
O(1) plus a background resync
$6
compat
$86
differs: a deprecated alias of REPLICAOF, including the replication-port-base argument
$5
flags
*2
$5
write
$5
admin
$4
WAIT
*14
$7
summary
$262
Block until every shard's master_repl_offset is acknowledged by at least numreplicas replicas (or timeout ms pass); returns the minimum acked-replica count across shards. timeout 0 = wait forever, hard-capped at 60 s. NOTE: a replica ACK is not fsync durability.
$5
since
$5
1.0.0
$5
group
$11
replication
$6
syntax
$24
WAIT numreplicas timeout
$10
complexity
$122
O(S) — an all-shard barrier returning the MINIMUM acked-replica count; the wall-clock cost is the replication round trip
$6
compat
$249
differs: it is an all-shard barrier returning the minimum across shards (Redis has one offset to wait on); timeout 0 is capped at 60s rather than blocking forever, and an ACK means the frame reached the replica's apply pipeline, not fsync durability
$5
flags
*2
$8
readonly
$8
blocking
$7
DISCARD
*14
$7
summary
$33
Abort the open MULTI transaction.
$5
since
$5
1.0.0
$5
group
$2
tx
$6
syntax
$7
DISCARD
$10
complexity
$52
O(1) — drops the queued commands and the WATCH set
$6
compat
$4
full
$5
flags
*2
$8
readonly
$11
transaction
$4
EXEC
*14
$7
summary
$41
Execute every command queued since MULTI.
$5
since
$5
1.0.0
$5
group
$2
tx
$6
syntax
$4
EXEC
$10
complexity
$116
O(sum of the queued commands' costs); with W watched keys, one extra O(W) pre-check fanned into O(min(W,S)) messages
$6
compat
$262
differs: a MULTI batch spanning several shards is per-shard-atomic, not globally isolated (there is no cross-shard snapshot); a queue-time error aborts the whole batch with EXECABORT, but a runtime error inside EXEC leaves the other commands applied, as in Redis
$5
flags
*2
$8
readonly
$11
transaction
$5
MULTI
*14
$7
summary
$63
Start a transaction; subsequent commands are queued until EXEC.
$5
since
$5
1.0.0
$5
group
$2
tx
$6
syntax
$5
MULTI
$10
complexity
$4
O(1)
$6
compat
$4
full
$5
flags
*2
$8
readonly
$11
transaction
$7
UNWATCH
*14
$7
summary
$24
Forget all watched keys.
$5
since
$5
1.0.0
$5
group
$2
tx
$6
syntax
$7
UNWATCH
$10
complexity
$4
O(1)
$6
compat
$4
full
$5
flags
*2
$8
readonly
$11
transaction
$5
WATCH
*14
$7
summary
$51
Watch keys for optimistic locking of the next EXEC.
$5
since
$5
1.0.0
$5
group
$2
tx
$6
syntax
$19
WATCH key [key ...]
$10
complexity
$56
O(W) keys, grouped into O(min(W,S)) cross-shard messages
$6
compat
$4
full
$5
flags
*2
$8
readonly
$11
transaction
$10
PSUBSCRIBE
*14
$7
summary
$55
Subscribe to channels matching the given glob patterns.
$5
since
$5
1.0.0
$5
group
$6
pubsub
$6
syntax
$32
PSUBSCRIBE pattern [pattern ...]
$10
complexity
$76
O(p * P) — each pattern costs a linear scan of the shared pattern registry
$6
compat
$4
full
$5
flags
*2
$8
readonly
$6
pubsub
$7
PUBLISH
*14
$7
summary
$56
Post a message to a channel; returns the receiver count.
$5
since
$5
1.0.0
$5
group
$6
pubsub
$6
syntax
$23
PUBLISH channel message
$10
complexity
$177
O(1) channel lookup + O(P) — a linear walk of the registered patterns with one glob match each, even when none match. Delivery fans out only to the shards holding a subscriber
$6
compat
$4
full
$5
flags
*2
$8
readonly
$6
pubsub
$12
PUNSUBSCRIBE
*14
$7
summary
$57
Unsubscribe from patterns (all patterns when none given).
$5
since
$5
1.0.0
$5
group
$6
pubsub
$6
syntax
$36
PUNSUBSCRIBE [pattern [pattern ...]]
$10
complexity
$8
O(p * P)
$6
compat
$4
full
$5
flags
*2
$8
readonly
$6
pubsub
$9
SUBSCRIBE
*14
$7
summary
$32
Subscribe to the given channels.
$5
since
$5
1.0.0
$5
group
$6
pubsub
$6
syntax
$31
SUBSCRIBE channel [channel ...]
$10
complexity
$45
O(c) channels; never fans out to other shards
$6
compat
$176
differs: kevy has no RESP2 subscriber mode — after SUBSCRIBE the connection may still issue any command, where Redis restricts it to the pubsub verbs plus PING / QUIT / RESET
$5
flags
*2
$8
readonly
$6
pubsub
$11
UNSUBSCRIBE
*14
$7
summary
$57
Unsubscribe from channels (all channels when none given).
$5
since
$5
1.0.0
$5
group
$6
pubsub
$6
syntax
$35
UNSUBSCRIBE [channel [channel ...]]
$10
complexity
$13
O(c) channels
$6
compat
$4
full
$5
flags
*2
$8
readonly
$6
pubsub
$4
EVAL
*14
$7
summary
$74
Run a Lua script server-side; routed to KEYS[1]'s shard when numkeys >= 1.
$5
since
$5
1.0.0
$5
group
$6
script
$6
syntax
$51
EVAL script numkeys [key [key ...]] [arg [arg ...]]
$10
complexity
$232
O(compile + the script's own work). The whole script is one atomic unit on KEYS[1]'s shard and blocks that shard for its duration. The runaway guard is an INSTRUCTION budget (lua time_limit_ms x 40000 instructions), not a wall clock
$6
compat
$545
differs: there is no -BUSY state and no SCRIPT KILL — an over-budget script is aborted in place and answered with an ordinary error; nested EVAL is rejected, a redis.call touching another shard's key returns CROSSSLOT, and EVAL auto-caches its source by SHA1 so EVALSHA works without SCRIPT LOAD. Scripts replicate by SOURCE, not by effects: a script calling SPOP draws its own random members on a replica or an AOF replay — keep nondeterministic verbs out of scripts you replicate (plain SPOP outside EVAL propagates its effect and is safe)
$5
flags
*1
$5
write
$7
EVALSHA
*14
$7
summary
$43
Run a cached Lua script by its SHA1 digest.
$5
since
$5
1.0.0
$5
group
$6
script
$6
syntax
$52
EVALSHA sha1 numkeys [key [key ...]] [arg [arg ...]]
$10
complexity
$41
O(1) cache lookup, then identical to EVAL
$6
compat
$122
differs: same instruction-budget model as EVAL (no -BUSY, no SCRIPT KILL); the cache is process-wide and EVAL populates it
$5
flags
*1
$5
write
$6
SCRIPT
*14
$7
summary
$41
Manage the process-wide Lua script cache.
$5
since
$5
1.0.0
$5
group
$6
script
$6
syntax
$64
SCRIPT LOAD script | EXISTS sha1 [sha1 ...] | FLUSH [ASYNC|SYNC]
$10
complexity
$60
LOAD: O(len(script)). EXISTS: O(k). FLUSH: O(cached scripts)
$6
compat
$157
differs: LOAD / EXISTS / FLUSH only — SCRIPT KILL does not exist, by design: there is no -BUSY state to interrupt because an over-budget script self-aborts
$5
flags
*1
$8
readonly
$10
IDX.ADVISE
*14
$7
summary
$127
The declarations refused queries have been asking for, most-refused first — each rendered as the command that would serve it.
$5
since
$5
4.2.0
$5
group
$5
index
$6
syntax
$10
IDX.ADVISE
$10
complexity
$123
O(observed families); the refusal log is bounded (128 families, least-refused evicted) and cleared on every catalog install
$6
compat
$124
kevy-only: no Redis analogue — the refusal log turns 'no such index' into the declaration that would have served the query
$5
flags
*2
$8
readonly
$9
extension
$9
IDX.COUNT
*14
$7
summary
$59
Count index entries matching a range or equality predicate.
$5
since
$5
3.0.0
$5
group
$5
index
$6
syntax
$39
IDX.COUNT name RANGE min max | EQ value
$10
complexity
$109
O(log N + matched) per shard — NOT an O(1) counter and not a B-tree rank query; it counts the matched range
$6
compat
$46
kevy-only: nearest is FT.SEARCH with LIMIT 0 0
$5
flags
*2
$8
readonly
$9
extension
$10
IDX.CREATE
*14
$7
summary
$82
Declare a secondary index over a key prefix (catalog mutation, sidecar-persisted).
$5
since
$5
3.0.0
$5
group
$5
index
$6
syntax
$220
IDX.CREATE name ON PREFIX prefix FIELD field TYPE i64|f64|str|vector KIND range|unique|text|ann|agg [MAXMEM bytes] [DIM dim] [DISTANCE cosine|l2|ip] [M m] [EF ef] [GROUPBY field] [PARTITION local|global] [SPLIT value]…
$10
complexity
$240
O(1) at the call; the build is asynchronous — each shard snapshots its matching keys (O(keys on that shard)) then backfills 2048 rows per tick. Per-row build cost: range/unique O(log N), text O(tokens), vector O(ef_construction * M * dim)
$6
compat
$349
kevy-only: nearest is RediSearch FT.CREATE — comparable declarative index-on-prefix, but RediSearch is a module (`redisearch.so`, auto-loaded in Redis 8 and running in the server's own process, not a separate index server) whose index is maintained asynchronously; kevy's catalog is part of the engine and the index is maintained in the write hook
$5
flags
*2
$5
write
$9
extension
$12
IDX.DESCRIBE
*14
$7
summary
$149
Read an index declaration back: prefix, kind, type, fields, stored values, options, the table that compiled it, and the IDX.CREATE that recreates it.
$5
since
$5
6.5.0
$5
group
$5
index
$6
syntax
$17
IDX.DESCRIBE name
$10
complexity
$118
O(declaration size), plus O(tables) compiles to name the owning table; at the origin — the catalog is process-global
$6
compat
$9
kevy-only
$5
flags
*2
$8
readonly
$9
extension
$8
IDX.DROP
*14
$7
summary
$60
Drop a declared index (catalog mutation, sidecar-persisted).
$5
since
$5
3.0.0
$5
group
$5
index
$6
syntax
$13
IDX.DROP name
$10
complexity
$15
O(catalog size)
$6
compat
$34
kevy-only: nearest is FT.DROPINDEX
$5
flags
*2
$5
write
$9
extension
$8
IDX.LIST
*14
$7
summary
$59
List declared indexes with per-index build state and stats.
$5
since
$5
3.0.0
$5
group
$5
index
$6
syntax
$8
IDX.LIST
$10
complexity
$154
Not O(1) — per shard, per index it computes live stats: range/unique O(1), text O(distinct tokens + docs), vector O(nodes + links), agg O(groups + rows)
$6
compat
$52
kevy-only: nearest is FT._LIST plus FT.INFO combined
$5
flags
*2
$8
readonly
$9
extension
$11
IDX.EXPLAIN
*14
$7
summary
$84
The IDX.QUERY parse without the execution: kind, state, est_rows, and the plan line.
$5
since
$5
3.0.0
$5
group
$5
index
$6
syntax
$79
IDX.EXPLAIN name RANGE min max|EQ value|MATCH text|KNN vector|GROUPS [args ...]
$10
complexity
$79
The plan is parse-only, but est_rows costs the same live stats walk as IDX.LIST
$6
compat
$135
kevy-only: nearest is FT.EXPLAIN, which returns a parsed query tree; ours returns kind, build state, estimated rows and a one-line plan
$5
flags
*2
$8
readonly
$9
extension
$9
IDX.QUERY
*14
$7
summary
$99
Query an index: range/equality, text MATCH, vector KNN, aggregation groups, or a two-index COMPOSE.
$5
since
$5
3.0.0
$5
group
$5
index
$6
syntax
$564
IDX.QUERY name RANGE min max|EQ value [LIMIT n] [CURSOR c] [FILTER field RANGE min max|EQ value ...] [SORT field ASC|DESC] [DISTINCT field] [FACET field ...] [OFFSET n] [FIELDS field ...] | name MATCH text [LIMIT n] [FIELDS field ...] | name KNN vector [LIMIT k] [EF ef] [FIELDS field ...] | name GROUP group | name GROUPS [BY count|sum|min|max] [LIMIT n] | HYBRID text_idx MATCH text ann_idx KNN vector [LIMIT n] [RRFK k] [EF ef] [FIELDS field ...] | COMPOSE AND|OR nameA RANGE min max|EQ value nameB RANGE min max|EQ value [LIMIT n] [CURSOR c] [FIELDS field ...]
$10
complexity
$460
Depends on the index kind. range: O(log N + limit). unique: O(log N + hits). full-text: O(sum of the posting lists), MaxScore-pruned. vector ANN: O(dim * (M log N + ef * M)) distance evaluations (HNSW). agg GROUPS: a bounded top-K with 1 to 3 fan-out rounds. HYBRID: both sub-queries at 4x depth, fused by RRF at the origin. COMPOSE: NOT limit-bounded — both leaves are materialised in full, because the result is key-ordered while a segment is value-ordered
$6
compat
$572
kevy-only: nearest is RediSearch FT.SEARCH, and for the HYBRID shape FT.HYBRID (Redis 8.4+, which fuses by RRF with the same default constant of 60) — genuinely comparable on two axes (our text index is BM25 over inverted segments, our vector index is HNSW, and RediSearch offers both). Differences: nothing to load, RediSearch being `redisearch.so` and auto-loaded since Redis 8; our BM25 statistics are per-shard, not global; and our query surface is a fixed grammar, not a DSL — no field boosting, no phrase or proximity search, no stemming, no aggregation pipeline
$5
flags
*2
$8
readonly
$9
extension
$11
IDX.REBUILD
*14
$7
summary
$176
Rebuild an index: a range or unique index packs its leaves, an ANN index compacts its tombstones, a global index samples its split points again. A text or agg index is refused.
$5
since
$5
3.0.0
$5
group
$5
index
$6
syntax
$16
IDX.REBUILD name
$10
complexity
$283
Depends on the index kind, on every shard, synchronously. range / unique: O(N) to pack the leaves. global: one sample of every shard's values, then the moved entries. ann: O(V_live * ef_construction * M * dim) distance evaluations — the most expensive verb in the extension surface
$6
compat
$103
kevy-only: no Redis analogue — RediSearch handles HNSW deletes internally and exposes no rebuild verb
$5
flags
*2
$5
write
$9
extension
$10
IDX.VERIFY
*14
$7
summary
$279
Verify an index. Scalar kinds re-read every held entry against its row and report entries/bytes/coerce_failures/duplicates/drift/checked/missing (both audit directions); agg/text/ann answer their own sizing vocabulary (rows|docs|vectors, bytes, ...) and carry no row-keyed audit.
$5
since
$5
3.0.0
$5
group
$5
index
$6
syntax
$15
IDX.VERIFY name
$10
complexity
$159
O(N) per shard — every held entry is re-read against its row and re-coerced, which is the point: it makes index drift falsifiable rather than merely asserted
$6
compat
$118
kevy-only: no Redis analogue — RediSearch's index is asynchronously maintained and offers no consistency-verify verb
$5
flags
*2
$8
readonly
$9
extension
$13
TABLE.DECLARE
*14
$7
summary
$114
Declare a relational table that compiles at declare time into named indexes (catalog mutation, sidecar-persisted).
$5
since
$5
4.0.0
$5
group
$5
table
$6
syntax
$272
TABLE.DECLARE name PREFIX prefix PK col COLUMN name i64|f64|str [COLUMN ...] [INDEX col range|unique [VALUES col ...] [GLOBAL [SPLIT AT v ...]]] [ORDERPATH name ON col [DESC] [THEN col [DESC]] ... [GLOBAL [SPLIT AT 0xhex ...]]] [WINDOW col SPAN n BUCKET n] [AUTODECLARE n]
$10
complexity
$234
O(declaration size) at the call; each compiled index then backfills like IDX.CREATE (2048 rows per tick per shard). The engine gains no query planner: queries name the compiled paths (`<table>.<col>`, `<table>.<orderpath>`) explicitly
$6
compat
$235
kevy-only: nearest is CREATE TABLE in an RDBMS — but this is a declaration compiler, not a schema enforcer: a row with a missing column is a row with an absent field (NULL semantics), never an error, and no SQL executes at query time
$5
flags
*2
$5
write
$9
extension
$12
TABLE.ENSURE
*14
$7
summary
$166
TABLE.DECLARE's boot form: identical existing declaration answers +UNCHANGED, a different one is a named refusal saying which part differs — never a silent rebuild.
$5
since
$5
4.1.0
$5
group
$5
table
$6
syntax
$132
TABLE.ENSURE name PREFIX prefix PK col COLUMN name i64|f64|str [COLUMN ...] [INDEX ...] [ORDERPATH ...] [WINDOW ...] [AUTODECLARE n]
$10
complexity
$130
declare-at-boot is the steady state; plain DECLARE errors on re-declare, which quiet boot code then ignores forever (dogfood F8.2)
$6
compat
$103
kevy-only: nearest is CREATE TABLE IF NOT EXISTS — plus the spec comparison IF NOT EXISTS does not do
$5
flags
*2
$5
write
$9
extension
$13
TABLE.REPLACE
*14
$7
summary
$184
Drop and redeclare in one verb, rebuilding every compiled index from the rows. Named for its cost: a full backfill, asked for explicitly. A bad spec refuses BEFORE the old table drops.
$5
since
$5
4.1.0
$5
group
$5
table
$6
syntax
$133
TABLE.REPLACE name PREFIX prefix PK col COLUMN name i64|f64|str [COLUMN ...] [INDEX ...] [ORDERPATH ...] [WINDOW ...] [AUTODECLARE n]
$10
complexity
$48
the migration verb: spec changed, rebuild wanted
$6
compat
$78
kevy-only: nearest is DROP TABLE + CREATE TABLE, atomic against a bad new spec
$5
flags
*2
$5
write
$9
extension
$14
TABLE.DESCRIBE
*14
$7
summary
$173
Read a table declaration back: columns with types, indexes, order paths, window, and the TABLE.DECLARE that recreates it (auto-declared paths are listed but left out of it).
$5
since
$5
6.5.0
$5
group
$5
table
$6
syntax
$19
TABLE.DESCRIBE name
$10
complexity
$67
O(declaration size) at the origin — the catalog is process-global
$6
compat
$50
kevy-only: nearest is DESCRIBE / SHOW CREATE TABLE
$5
flags
*2
$8
readonly
$9
extension
$10
TABLE.DROP
*14
$7
summary
$85
Drop a declared table and its compiled indexes (catalog mutation, sidecar-persisted).
$5
since
$5
4.0.0
$5
group
$5
table
$6
syntax
$15
TABLE.DROP name
$10
complexity
$34
O(catalog size + compiled indexes)
$6
compat
$9
kevy-only
$5
flags
*2
$5
write
$9
extension
$10
TABLE.LIST
*14
$7
summary
$66
List declared tables with their prefix, PK and declaration counts.
$5
since
$5
4.0.0
$5
group
$5
table
$6
syntax
$10
TABLE.LIST
$10
complexity
$57
O(tables) at the origin — the catalog is process-global
$6
compat
$9
kevy-only
$5
flags
*2
$8
readonly
$9
extension
$12
TABLE.VERIFY
*14
$7
summary
$113
Verify a table: each compiled index's full drift recheck plus a bounded column-type spot check over sampled rows.
$5
since
$5
4.0.0
$5
group
$5
table
$6
syntax
$17
TABLE.VERIFY name
$10
complexity
$212
O(sum of compiled index entries) per shard for the drift recheck (the IDX.VERIFY discipline, composites re-derive their byte encoding) plus a bounded 64-row-per-shard column spot check through the no-promote peek
$6
compat
$84
kevy-only: nearest is a relational fsck; verify-not-enforce is the declarative fence
$5
flags
*2
$8
readonly
$9
extension
$11
VIEW.CREATE
*14
$7
summary
$92
Declare a composed view over indexes with an ORDER BY (catalog mutation, sidecar-persisted).
$5
since
$5
3.0.0
$5
group
$4
view
$6
syntax
$179
VIEW.CREATE name QUERY tree ORDER BY index [DESC] [MODE virtual|materialized] [TOPK k] [VIA template] (tree = '( AND|OR|DIFF sub sub )' | 'index RANGE min max' | 'index EQ value')
$10
complexity
$156
O(tree size) at the call. A materialized view builds lazily on the next tick (a full eval_tree plus an O(M log M) sort); a virtual view builds nothing, ever
$6
compat
$188
kevy-only: no Redis analogue. A view is neither a stored query nor a join — it is a named composition tree over declared indexes that stores membership and order only, never field values
$5
flags
*2
$5
write
$9
extension
$13
VIEW.DESCRIBE
*14
$7
summary
$123
Read a view declaration back: the composition tree, order, mode, hydration template, and the VIEW.CREATE that recreates it.
$5
since
$5
6.5.0
$5
group
$4
view
$6
syntax
$18
VIEW.DESCRIBE name
$10
complexity
$67
O(declaration size) at the origin — the catalog is process-global
$6
compat
$38
kevy-only: nearest is SHOW CREATE VIEW
$5
flags
*2
$8
readonly
$9
extension
$9
VIEW.DROP
*14
$7
summary
$59
Drop a declared view (catalog mutation, sidecar-persisted).
$5
since
$5
3.0.0
$5
group
$4
view
$6
syntax
$14
VIEW.DROP name
$10
complexity
$15
O(catalog size)
$6
compat
$9
kevy-only
$5
flags
*2
$5
write
$9
extension
$12
VIEW.EXPLAIN
*14
$7
summary
$62
Explain a view's composition tree with per-leaf cardinalities.
$5
since
$5
3.0.0
$5
group
$4
view
$6
syntax
$17
VIEW.EXPLAIN name
$10
complexity
$140
O(sum over leaves of (log N + matched)) — each leaf's cardinality is a real count, so EXPLAIN on a broad leaf costs as much as counting it
$6
compat
$95
kevy-only: nearest is FT.EXPLAIN, which returns a query tree rather than per-leaf cardinalities
$5
flags
*2
$8
readonly
$9
extension
$9
VIEW.LIST
*14
$7
summary
$46
List declared views with their mode and shape.
$5
since
$5
3.0.0
$5
group
$4
view
$6
syntax
$9
VIEW.LIST
$10
complexity
$56
O(views) at the origin — the catalog is process-global
$6
compat
$9
kevy-only
$5
flags
*2
$8
readonly
$9
extension
$10
VIEW.QUERY
*14
$7
summary
$88
Page through a view's ordered members, optionally hydrating fields via the VIA template.
$5
since
$5
3.0.0
$5
group
$4
view
$6
syntax
$55
VIEW.QUERY name [LIMIT n] [CURSOR c] [FIELDS field ...]
$10
complexity
$275
virtual: O(log N_order + candidates * leaves) — it streams the ORDER index and probes membership per candidate, stopping at the limit, so it never materialises the member set. materialized: O(log M + limit). Adding FIELDS with VIA costs a SECOND fan-out to hydrate the rows
$6
compat
$158
kevy-only: no Redis analogue. Absent by construction: no joins, no predicates at the view layer, no projection from the view itself, no HAVING, no aggregation
$5
flags
*2
$8
readonly
$9
extension
$12
VIEW.REBUILD
*14
$7
summary
$39
Force a rebuild of a materialized view.
$5
since
$5
3.0.0
$5
group
$4
view
$6
syntax
$17
VIEW.REBUILD name
$10
complexity
$139
Materialized only. A full eval_tree over the whole tree plus an O(M log M) sort and re-insert, on every shard, now (not deferred to a tick)
$6
compat
$9
kevy-only
$5
flags
*2
$5
write
$9
extension
$11
VIEW.VERIFY
*14
$7
summary
$48
Verify a view and report member/byte statistics.
$5
since
$5
3.0.0
$5
group
$4
view
$6
syntax
$16
VIEW.VERIFY name
$10
complexity
$190
materialized: O(M). virtual: O(sum over leaves of (log N + leaf range) + M) — a full fresh evaluation just to report cardinality, which is the one place a virtual view is the expensive one
$6
compat
$9
kevy-only
$5
flags
*2
$8
readonly
$9
extension
$9
FEED.READ
*14
$7
summary
$71
Read change-feed frames from one shard past a generation/offset cursor.
$5
since
$5
3.0.0
$5
group
$4
feed
$6
syntax
$63
FEED.READ shard generation offset [COUNT n] [PREFIX prefix ...]
$10
complexity
$209
A single shard (the shard is an argument, not a fan-out). O(log B) to locate the start offset in the backlog plus O(count * frame size) to decode and re-encode. COUNT defaults to 256 and is hard-capped at 4096
$6
compat
$414
kevy-only: no clean Redis analogue. Keyspace notifications are fire-and-forget with no cursor and no replay; Redis Streams have cursors but are a stream you must dual-write to, not a feed over your existing keyspace; the replication backlog is what this is built on, but Redis exposes it only to replicas. kevy is deliberately not a broker: no consumer groups, no server-side positions, no global cross-shard order
$5
flags
*2
$8
readonly
$9
extension
$11
FEED.SHARDS
*14
$7
summary
$40
Return the number of change-feed shards.
$5
since
$5
3.0.0
$5
group
$4
feed
$6
syntax
$11
FEED.SHARDS
$10
complexity
$22
O(1), answered locally
$6
compat
$66
kevy-only: Redis has no shard-partitioned change feed to enumerate
$5
flags
*2
$8
readonly
$9
extension
$9
FEED.TAIL
*14
$7
summary
$57
Return a shard's current feed generation and next offset.
$5
since
$5
3.0.0
$5
group
$4
feed
$6
syntax
$15
FEED.TAIL shard
$10
complexity
$22
O(1) on a single shard
$6
compat
$106
kevy-only: nearest is INFO replication's master_repl_offset, which is not a resumable per-shard CDC cursor
$5
flags
*2
$8
readonly
$9
extension
$12
PREFIX.STATS
*14
$7
summary
$54
Report key-count and byte statistics for a key prefix.
$5
since
$5
3.0.0
$5
group
$9
migration
$6
syntax
$19
PREFIX.STATS prefix
$10
complexity
$94
O(keys on the shard) — a full keyspace walk on every shard; the prefix cannot be precomputed
$6
compat
$173
kevy-only: nearest is INFO keyspace's db0:keys=N,expires=M — the same two counters, but whole-DB and O(1) off a counter, where ours is per-prefix and therefore O(keyspace)
$5
flags
*2
$8
readonly
$9
extension
$13
PREFIX.DIGEST
*14
$7
summary
$73
Order-insensitive checksum of a prefix's rows for migration verification.
$5
since
$5
3.0.0
$5
group
$9
migration
$6
syntax
$20
PREFIX.DIGEST prefix
$10
complexity
$174
O(keys on the shard) to walk plus O(sum of row sizes) to digest, on every shard. Per-row digests XOR together, so the result is order-insensitive and safe across shard counts
$6
compat
$233
kevy-only: nearest is DEBUG DIGEST — comparable in kind (Redis also XORs per-key digests), but Redis's is whole-DB and lives behind DEBUG, while ours is per-prefix (the unit a migration actually cares about) and is a supported verb
$5
flags
*2
$8
readonly
$9
extension