yo-resp 0.3.12

//! The command table: what each command is called, how many arguments it
//! takes, where its keys are, and what `COMMAND` reports about it.
//!
//! Every field here was read out of a running Redis 8.8 with `COMMAND INFO`
//! rather than written from the documentation, because this is the table a
//! client library builds its own routing from. A cluster aware client asks
//! `COMMAND` where the keys are and then decides which node to send a command
//! to, so an arity or a key position that is off by one does not produce a
//! wrong error message, it produces a client that sends `MSET` to the wrong
//! shard. The summaries are ours, since those are the one field nobody parses.
//!
//! `cargo xtask check` compares this table against `commands.toml` in both
//! directions, so a command cannot be dispatched without a storage plan and
//! cannot claim `wire = "verified"` without an entry here.

/// Everything `COMMAND` has to be able to say about one command.
#[derive(Debug, Clone, Copy)]
pub struct Spec {
    /// The name, lower case, which is how `COMMAND` reports it whatever case
    /// the client used.
    pub name: &'static str,
    /// Redis's arity: a positive number is exact, a negative one is a minimum
    /// of its magnitude, and both count the command name itself.
    pub arity: i32,
    /// The command flags, in the order `COMMAND INFO` lists them.
    pub flags: &'static [&'static str],
    /// The first argument that is a key, or zero when there are none.
    pub first_key: i32,
    /// The last argument that is a key, negative counting back from the end.
    pub last_key: i32,
    /// How far apart the keys are, for the commands that take pairs.
    pub step: i32,
    /// The ACL categories, which are what `COMMAND LIST FILTERBY ACLCAT` reads.
    pub acl: &'static [&'static str],
    /// The Redis this command first appeared in.
    pub since: &'static str,
    /// The cost, in the shape `COMMAND DOCS` uses.
    pub complexity: &'static str,
    /// One line about what it does, in our words.
    pub summary: &'static str,
    /// The group in `commands.toml`, which is how the two files are compared.
    pub group: &'static str,
}

/// Read only, fast, one key at argument one, which is most of the getters.
const READ_FAST: &[&str] = &["readonly", "fast"];
/// A write that allocates, fast, one key at argument one.
const WRITE_FAST_OOM: &[&str] = &["write", "denyoom", "fast"];
/// A write that allocates and is not counted as fast.
const WRITE_OOM: &[&str] = &["write", "denyoom"];
/// The read side categories.
const AC_READ_FAST: &[&str] = &["@read", "@string", "@fast"];
/// The read side categories for the ones that walk the value.
const AC_READ_SLOW: &[&str] = &["@read", "@string", "@slow"];
/// The write side categories.
const AC_WRITE_FAST: &[&str] = &["@write", "@string", "@fast"];
/// The write side categories for the ones that are not counted as fast.
const AC_WRITE_SLOW: &[&str] = &["@write", "@string", "@slow"];
/// A write that frees rather than allocates, so Redis does not mark it denyoom.
const WRITE_FAST: &[&str] = &["write", "fast"];
/// The set read side, for the ones that answer without walking the members.
const AC_SET_READ_FAST: &[&str] = &["@read", "@set", "@fast"];
/// The set read side for the ones that walk the members.
const AC_SET_READ_SLOW: &[&str] = &["@read", "@set", "@slow"];
/// The set write side.
const AC_SET_WRITE_FAST: &[&str] = &["@write", "@set", "@fast"];
/// The set write side for the ones that walk whole sets to decide what to
/// write, which is the whole `*STORE` family.
const AC_SET_WRITE_SLOW: &[&str] = &["@write", "@set", "@slow"];
/// The hash read side, for the ones that answer without walking the fields.
const AC_HASH_READ_FAST: &[&str] = &["@read", "@hash", "@fast"];
/// The hash read side for the ones that walk the fields.
const AC_HASH_READ_SLOW: &[&str] = &["@read", "@hash", "@slow"];
/// The hash write side.
const AC_HASH_WRITE_FAST: &[&str] = &["@write", "@hash", "@fast"];
/// Read only and not counted as fast, which is every list read that walks.
const READ_SLOW: &[&str] = &["readonly"];
/// A write that is not counted as fast and does not allocate, which on the list
/// side is `LREM` and `LTRIM` and nothing else.
const WRITE_SLOW: &[&str] = &["write"];
/// The list read side, for the two that answer without walking the elements.
const AC_LIST_READ_FAST: &[&str] = &["@read", "@list", "@fast"];
/// The list read side for the ones that walk.
const AC_LIST_READ_SLOW: &[&str] = &["@read", "@list", "@slow"];
/// The list write side, which is the pushes and the pops. Redis counts a push
/// as fast even though it can split a chunk, because the split is amortised.
const AC_LIST_WRITE_FAST: &[&str] = &["@write", "@list", "@fast"];
/// The list write side for the ones whose cost is the length of the list.
const AC_LIST_WRITE_SLOW: &[&str] = &["@write", "@list", "@slow"];
/// The five that can wait, which carry a category of their own so that an ACL
/// can say "this user may not park a connection" without naming five commands.
const AC_LIST_WRITE_BLOCKING: &[&str] = &["@write", "@list", "@slow", "@blocking"];
/// The sorted set read side, for the ones that answer without walking members.
const AC_ZSET_READ_FAST: &[&str] = &["@read", "@sortedset", "@fast"];
/// The sorted set read side for the ones that walk members.
const AC_ZSET_READ_SLOW: &[&str] = &["@read", "@sortedset", "@slow"];
/// The sorted set write side.
const AC_ZSET_WRITE_FAST: &[&str] = &["@write", "@sortedset", "@fast"];
/// The sorted set write side for the ones whose cost is the size of the window
/// they touch, which is the removals and `ZRANGESTORE`.
const AC_ZSET_WRITE_SLOW: &[&str] = &["@write", "@sortedset", "@slow"];
/// The two sorted set pops that can wait, which Redis counts as fast because
/// each of them takes one member.
const AC_ZSET_BLOCKING_FAST: &[&str] = &["@write", "@sortedset", "@fast", "@blocking"];
/// And `BZMPOP`, whose cost is the number of keys named and the count popped.
const AC_ZSET_BLOCKING_SLOW: &[&str] = &["@write", "@sortedset", "@slow", "@blocking"];
/// The array read side, for the ones whose cost is the number of indices named
/// and not the size of the array.
const AC_ARRAY_READ_FAST: &[&str] = &["@read", "@array", "@fast"];
/// The array read side for `ARGETRANGE`, which answers once per position in the
/// range and so costs the range rather than the population.
const AC_ARRAY_READ_SLOW: &[&str] = &["@read", "@array", "@slow"];
/// The array write side.
const AC_ARRAY_WRITE_FAST: &[&str] = &["@write", "@array", "@fast"];
/// The array write side for `ARDELRANGE`, the one array command Redis does not
/// mark fast.
const AC_ARRAY_WRITE_SLOW: &[&str] = &["@write", "@array", "@slow"];
/// Read only and not counted as fast, for a command whose keys are counted
/// rather than positioned, so a client has to read the key specs to route it.
const READ_MOVABLE: &[&str] = &["readonly", "movablekeys"];
/// The same for a write, which is the three store forms.
const WRITE_MOVABLE: &[&str] = &["write", "denyoom", "movablekeys"];
/// `MIGRATE`, which is the one movable key write that is not `denyoom`.
///
/// It only ever frees here, since the local key goes away and nothing arrives,
/// so a server with no room left can still migrate its way out of trouble. That
/// is the same reasoning that leaves the flag off `DEL`.
const MIGRATE_FLAGS: &[&str] = &["write", "movablekeys"];
/// The connection commands' categories.
const AC_CONN: &[&str] = &["@fast", "@connection"];
/// The keyspace read side, which is `EXISTS` and `TYPE`.
const AC_KEY_READ: &[&str] = &["@keyspace", "@read", "@fast"];
/// The keyspace reads that walk something, which is `SCAN` and `RANDOMKEY`.
const AC_KEY_READ_SLOW: &[&str] = &["@keyspace", "@read", "@slow"];
/// And `KEYS`, which is the same walk without a bound on it and is the one read
/// in this group Redis calls dangerous.
const AC_KEY_READ_ALL: &[&str] = &["@keyspace", "@read", "@slow", "@dangerous"];
/// The keyspace writes that are allowed to cost what the value costs. `DEL`
/// frees on the spot and `COPY` clones a body, and `RENAME` is in here with
/// them even though it moves thirteen bytes, because Redis says slow for it and
/// this list is Redis's list rather than ours.
const AC_KEY_WRITE_SLOW: &[&str] = &["@keyspace", "@write", "@slow"];
/// `UNLINK`, which Redis does count as fast because it does not, and the
/// expiry writers, which move a deadline and never touch a value.
const AC_KEY_WRITE_FAST: &[&str] = &["@keyspace", "@write", "@fast"];
/// The two that empty a database, which are in the dangerous category.
const AC_KEY_FLUSH: &[&str] = &["@keyspace", "@write", "@slow", "@dangerous"];
/// `SWAPDB`, which is fast and dangerous at the same time. It is two pointer
/// writes and it changes what every connected client is looking at, so Redis
/// puts it in `@fast` and in `@dangerous` and both are right.
const AC_SWAPDB: &[&str] = &["@keyspace", "@write", "@fast", "@dangerous"];
/// `RESTORE`, which is dangerous for a reason worth saying out loud: it is the
/// one command that takes bytes from a client and turns them into a value
/// without any command ever having built it. `DUMP` is only `@read`, because
/// reading a value out is no more than reading it.
const AC_RESTORE: &[&str] = &["@keyspace", "@write", "@slow", "@dangerous"];
/// `WAIT` and `WAITAOF`, which are the two commands that block on something
/// that is not a key. They are not in `@keyspace` at all, because they name no
/// key and read nothing, and they carry `@blocking` for the same reason the
/// five list commands do.
const AC_WAIT: &[&str] = &["@slow", "@blocking", "@connection"];
/// `SORT`, which names three type categories because it takes any of the three
/// and a write because of `STORE`. Redis leaves `@keyspace` off both of these
/// even though the command lives in that group, and this list is Redis's.
const AC_SORT_WRITE: &[&str] = &[
    "@write",
    "@set",
    "@sortedset",
    "@list",
    "@slow",
    "@dangerous",
];
/// `SORT_RO`, which is the same list with the write turned into a read.
const AC_SORT_READ: &[&str] = &[
    "@read",
    "@set",
    "@sortedset",
    "@list",
    "@slow",
    "@dangerous",
];

/// Every command this server answers, in the order the groups ship.
pub static COMMANDS: &[Spec] = &[
    // ------------------------------------------------------------- strings
    Spec {
        name: "set",
        arity: -3,
        flags: WRITE_OOM,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_WRITE_SLOW,
        since: "1.0.0",
        complexity: "O(1)",
        summary: "Set a key to a string value, whatever it held before.",
        group: "string",
    },
    Spec {
        name: "get",
        arity: 2,
        flags: READ_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_READ_FAST,
        since: "1.0.0",
        complexity: "O(1)",
        summary: "The string value of a key.",
        group: "string",
    },
    Spec {
        name: "getset",
        arity: 3,
        flags: WRITE_FAST_OOM,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_WRITE_FAST,
        since: "1.0.0",
        complexity: "O(1)",
        summary: "Set a key and hand back what it held.",
        group: "string",
    },
    Spec {
        name: "getdel",
        arity: 2,
        flags: &["write", "fast"],
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_WRITE_FAST,
        since: "6.2.0",
        complexity: "O(1)",
        summary: "Read a key and delete it in the same step.",
        group: "string",
    },
    Spec {
        name: "getex",
        arity: -2,
        flags: &["write", "fast"],
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_WRITE_FAST,
        since: "6.2.0",
        complexity: "O(1)",
        summary: "Read a key and change its deadline in the same step.",
        group: "string",
    },
    Spec {
        name: "setnx",
        arity: 3,
        flags: WRITE_FAST_OOM,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_WRITE_FAST,
        since: "1.0.0",
        complexity: "O(1)",
        summary: "Set a key only if it is not there.",
        group: "string",
    },
    Spec {
        name: "setex",
        arity: 4,
        flags: WRITE_OOM,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_WRITE_SLOW,
        since: "2.0.0",
        complexity: "O(1)",
        summary: "Set a key and give it a deadline in seconds.",
        group: "string",
    },
    Spec {
        name: "psetex",
        arity: 4,
        flags: WRITE_OOM,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_WRITE_SLOW,
        since: "2.6.0",
        complexity: "O(1)",
        summary: "Set a key and give it a deadline in milliseconds.",
        group: "string",
    },
    Spec {
        name: "mset",
        arity: -3,
        flags: WRITE_OOM,
        first_key: 1,
        last_key: -1,
        step: 2,
        acl: AC_WRITE_SLOW,
        since: "1.0.1",
        complexity: "O(N) with N the number of keys",
        summary: "Set several keys, all of them or none.",
        group: "string",
    },
    Spec {
        name: "msetnx",
        arity: -3,
        flags: WRITE_OOM,
        first_key: 1,
        last_key: -1,
        step: 2,
        acl: AC_WRITE_SLOW,
        since: "1.0.1",
        complexity: "O(N) with N the number of keys",
        summary: "Set several keys only if none of them are there.",
        group: "string",
    },
    Spec {
        name: "mget",
        arity: -2,
        flags: READ_FAST,
        first_key: 1,
        last_key: -1,
        step: 1,
        acl: AC_READ_FAST,
        since: "1.0.0",
        complexity: "O(N) with N the number of keys",
        summary: "The values of several keys, in the order asked for.",
        group: "string",
    },
    Spec {
        name: "append",
        arity: 3,
        flags: WRITE_FAST_OOM,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_WRITE_FAST,
        since: "2.0.0",
        complexity: "O(M) with M the length of the value being appended",
        summary: "Add to the end of a string, creating it if it is not there.",
        group: "string",
    },
    Spec {
        name: "strlen",
        arity: 2,
        flags: READ_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_READ_FAST,
        since: "2.2.0",
        complexity: "O(1)",
        summary: "How long a string value is, without reading it.",
        group: "string",
    },
    Spec {
        name: "setrange",
        arity: 4,
        flags: WRITE_OOM,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_WRITE_SLOW,
        since: "2.2.0",
        complexity: "O(M) with M the length of the replacement",
        summary: "Overwrite part of a string at an offset, zero filling the gap.",
        group: "string",
    },
    Spec {
        name: "getrange",
        arity: 4,
        flags: &["readonly"],
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_READ_SLOW,
        since: "2.4.0",
        complexity: "O(N) with N the length of the answer",
        summary: "Part of a string, by an inclusive range that may count backwards.",
        group: "string",
    },
    Spec {
        name: "substr",
        arity: 4,
        flags: &["readonly"],
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_READ_SLOW,
        since: "1.0.0",
        complexity: "O(N) with N the length of the answer",
        summary: "GETRANGE under the name it had before 2.4.",
        group: "string",
    },
    Spec {
        name: "incr",
        arity: 2,
        flags: WRITE_FAST_OOM,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_WRITE_FAST,
        since: "1.0.0",
        complexity: "O(1)",
        summary: "Add one, starting from zero if the key is not there.",
        group: "string",
    },
    Spec {
        name: "decr",
        arity: 2,
        flags: WRITE_FAST_OOM,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_WRITE_FAST,
        since: "1.0.0",
        complexity: "O(1)",
        summary: "Take one away, starting from zero if the key is not there.",
        group: "string",
    },
    Spec {
        name: "incrby",
        arity: 3,
        flags: WRITE_FAST_OOM,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_WRITE_FAST,
        since: "1.0.0",
        complexity: "O(1)",
        summary: "Add a number, starting from zero if the key is not there.",
        group: "string",
    },
    Spec {
        name: "decrby",
        arity: 3,
        flags: WRITE_FAST_OOM,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_WRITE_FAST,
        since: "1.0.0",
        complexity: "O(1)",
        summary: "Take a number away, starting from zero if the key is not there.",
        group: "string",
    },
    Spec {
        name: "incrbyfloat",
        arity: 3,
        flags: WRITE_FAST_OOM,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_WRITE_FAST,
        since: "2.6.0",
        complexity: "O(1)",
        summary: "Add a float, starting from zero if the key is not there.",
        group: "string",
    },
    Spec {
        name: "lcs",
        arity: -3,
        flags: &["readonly"],
        first_key: 1,
        last_key: 2,
        step: 1,
        acl: AC_READ_SLOW,
        since: "7.0.0",
        complexity: "O(N*M) with N and M the lengths of the two values",
        summary: "The longest subsequence two string values have in common.",
        group: "string",
    },
    Spec {
        name: "msetex",
        arity: -4,
        flags: &["write", "denyoom", "movablekeys"],
        first_key: 0,
        last_key: 0,
        step: 0,
        acl: AC_WRITE_SLOW,
        since: "8.4.0",
        complexity: "O(N) with N the number of keys",
        summary: "Set several keys with one deadline and one condition over all of them.",
        group: "string",
    },
    Spec {
        name: "delex",
        arity: -2,
        flags: &["write", "fast"],
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_WRITE_FAST,
        since: "8.4.0",
        complexity: "O(1) by value, O(N) by digest",
        summary: "Delete a key only if it still holds what the caller thinks.",
        group: "string",
    },
    Spec {
        name: "digest",
        arity: 2,
        flags: READ_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_READ_FAST,
        since: "8.4.0",
        complexity: "O(N) with N the length of the value",
        summary: "The XXH3 of a string value, as sixteen hex characters.",
        group: "string",
    },
    Spec {
        name: "increx",
        arity: -2,
        flags: WRITE_FAST_OOM,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_WRITE_FAST,
        since: "8.8.0",
        complexity: "O(1)",
        summary: "Count, with a bound, a saturation policy and a deadline.",
        group: "string",
    },
    // ----------------------------------------------------------------- sets
    Spec {
        name: "sadd",
        arity: -3,
        flags: WRITE_FAST_OOM,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_SET_WRITE_FAST,
        since: "1.0.0",
        complexity: "O(N) with N the number of members being added",
        summary: "Add members to a set, creating it if it is not there.",
        group: "set",
    },
    Spec {
        name: "srem",
        arity: -3,
        flags: WRITE_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_SET_WRITE_FAST,
        since: "1.0.0",
        complexity: "O(N) with N the number of members being removed",
        summary: "Take members out of a set, deleting the key if none are left.",
        group: "set",
    },
    Spec {
        name: "scard",
        arity: 2,
        flags: READ_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_SET_READ_FAST,
        since: "1.0.0",
        complexity: "O(1)",
        summary: "How many members a set has.",
        group: "set",
    },
    Spec {
        name: "sismember",
        arity: 3,
        flags: READ_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_SET_READ_FAST,
        since: "1.0.0",
        complexity: "O(1)",
        summary: "Whether a member is in a set.",
        group: "set",
    },
    Spec {
        name: "smismember",
        arity: -3,
        flags: READ_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_SET_READ_FAST,
        since: "6.2.0",
        complexity: "O(N) with N the number of members being asked about",
        summary: "Whether each of several members is in a set, in the order asked.",
        group: "set",
    },
    Spec {
        name: "smembers",
        arity: 2,
        flags: &["readonly"],
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_SET_READ_SLOW,
        since: "1.0.0",
        complexity: "O(N) with N the size of the set",
        summary: "Every member of a set.",
        group: "set",
    },
    Spec {
        name: "spop",
        arity: -2,
        flags: WRITE_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_SET_WRITE_FAST,
        since: "1.0.0",
        complexity: "O(1) without a count, O(N) with one",
        summary: "Take members out of a set at random and hand them back.",
        group: "set",
    },
    Spec {
        name: "srandmember",
        arity: -2,
        flags: &["readonly"],
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_SET_READ_SLOW,
        since: "1.0.0",
        complexity: "O(1) without a count, O(N) with one",
        summary: "Members of a set at random, leaving the set as it was.",
        group: "set",
    },
    Spec {
        name: "smove",
        arity: 4,
        flags: WRITE_FAST,
        first_key: 1,
        last_key: 2,
        step: 1,
        acl: AC_SET_WRITE_FAST,
        since: "1.0.0",
        complexity: "O(1)",
        summary: "Move one member from one set to another.",
        group: "set",
    },
    Spec {
        name: "sscan",
        arity: -3,
        flags: &["readonly"],
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_SET_READ_SLOW,
        since: "2.8.0",
        complexity: "O(1) a call, O(N) for a whole iteration",
        summary: "Walk part of a set and say where to carry on from.",
        group: "set",
    },
    Spec {
        name: "sinter",
        arity: -2,
        flags: &["readonly"],
        first_key: 1,
        last_key: -1,
        step: 1,
        acl: AC_SET_READ_SLOW,
        since: "1.0.0",
        complexity: "O(N*M) worst case, N the smallest set and M the number of sets",
        summary: "The members every one of these sets has.",
        group: "set",
    },
    Spec {
        name: "sintercard",
        arity: -3,
        // The only set command whose keys are counted rather than positioned,
        // so the legacy key range cannot describe it and Redis reports zeroes
        // in these three fields too. A client that wants the keys reads the key
        // specs, which is what the count is for, and movablekeys is how it is
        // told to go and read them.
        flags: READ_MOVABLE,
        first_key: 0,
        last_key: 0,
        step: 0,
        acl: AC_SET_READ_SLOW,
        since: "7.0.0",
        complexity: "O(N*M) worst case, N the smallest set and M the number of sets",
        summary: "How many members every one of these sets has, up to a limit.",
        group: "set",
    },
    Spec {
        name: "sinterstore",
        arity: -3,
        flags: WRITE_OOM,
        first_key: 1,
        last_key: -1,
        step: 1,
        acl: AC_SET_WRITE_SLOW,
        since: "1.0.0",
        complexity: "O(N*M) worst case, N the smallest set and M the number of sets",
        summary: "Store the members every one of these sets has.",
        group: "set",
    },
    Spec {
        name: "sunion",
        arity: -2,
        flags: &["readonly"],
        first_key: 1,
        last_key: -1,
        step: 1,
        acl: AC_SET_READ_SLOW,
        since: "1.0.0",
        complexity: "O(N) in the total number of members",
        summary: "The members any of these sets has, each once.",
        group: "set",
    },
    Spec {
        name: "sunionstore",
        arity: -3,
        flags: WRITE_OOM,
        first_key: 1,
        last_key: -1,
        step: 1,
        acl: AC_SET_WRITE_SLOW,
        since: "1.0.0",
        complexity: "O(N) in the total number of members",
        summary: "Store the members any of these sets has.",
        group: "set",
    },
    Spec {
        name: "sdiff",
        arity: -2,
        flags: &["readonly"],
        first_key: 1,
        last_key: -1,
        step: 1,
        acl: AC_SET_READ_SLOW,
        since: "1.0.0",
        complexity: "O(N) in the total number of members",
        summary: "The members of the first set that no later set has.",
        group: "set",
    },
    Spec {
        name: "sdiffstore",
        arity: -3,
        flags: WRITE_OOM,
        first_key: 1,
        last_key: -1,
        step: 1,
        acl: AC_SET_WRITE_SLOW,
        since: "1.0.0",
        complexity: "O(N) in the total number of members",
        summary: "Store the members of the first set that no later set has.",
        group: "set",
    },
    // -------------------------------------------------------------- hashes
    Spec {
        name: "hset",
        arity: -4,
        flags: WRITE_FAST_OOM,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_HASH_WRITE_FAST,
        since: "2.0.0",
        complexity: "O(N) with N the number of pairs being written",
        summary: "Write fields into a hash, creating it if it is not there.",
        group: "hash",
    },
    Spec {
        name: "hsetnx",
        arity: 4,
        flags: WRITE_FAST_OOM,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_HASH_WRITE_FAST,
        since: "2.0.0",
        complexity: "O(1)",
        summary: "Write a field only if the hash does not have it already.",
        group: "hash",
    },
    // Deprecated since 4.0 and still sent by a great deal of code, so it is
    // here rather than left out. It is HSET with an OK instead of a count.
    Spec {
        name: "hmset",
        arity: -4,
        flags: WRITE_FAST_OOM,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_HASH_WRITE_FAST,
        since: "2.0.0",
        complexity: "O(N) with N the number of pairs being written",
        summary: "Write fields into a hash and answer OK. Use HSET.",
        group: "hash",
    },
    Spec {
        name: "hget",
        arity: 3,
        flags: READ_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_HASH_READ_FAST,
        since: "2.0.0",
        complexity: "O(1)",
        summary: "The value of one field of a hash.",
        group: "hash",
    },
    Spec {
        name: "hmget",
        arity: -3,
        flags: READ_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_HASH_READ_FAST,
        since: "2.0.0",
        complexity: "O(N) with N the number of fields asked for",
        summary: "The values of several fields, one reply entry each.",
        group: "hash",
    },
    Spec {
        name: "hdel",
        arity: -3,
        flags: WRITE_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_HASH_WRITE_FAST,
        since: "2.0.0",
        complexity: "O(N) with N the number of fields being removed",
        summary: "Take fields out of a hash, deleting the key if none are left.",
        group: "hash",
    },
    Spec {
        name: "hlen",
        arity: 2,
        flags: READ_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_HASH_READ_FAST,
        since: "2.0.0",
        complexity: "O(1)",
        summary: "How many fields a hash has.",
        group: "hash",
    },
    Spec {
        name: "hexists",
        arity: 3,
        flags: READ_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_HASH_READ_FAST,
        since: "2.0.0",
        complexity: "O(1)",
        summary: "Whether a hash has a field.",
        group: "hash",
    },
    Spec {
        name: "hstrlen",
        arity: 3,
        flags: READ_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_HASH_READ_FAST,
        since: "3.2.0",
        complexity: "O(1)",
        summary: "How many bytes a field's value is, without sending it.",
        group: "hash",
    },
    Spec {
        name: "hgetall",
        arity: 2,
        flags: &["readonly"],
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_HASH_READ_SLOW,
        since: "2.0.0",
        complexity: "O(N) in the size of the hash",
        summary: "Every field and value, as a map on RESP3.",
        group: "hash",
    },
    Spec {
        name: "hkeys",
        arity: 2,
        flags: &["readonly"],
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_HASH_READ_SLOW,
        since: "2.0.0",
        complexity: "O(N) in the size of the hash",
        summary: "Every field of a hash.",
        group: "hash",
    },
    Spec {
        name: "hvals",
        arity: 2,
        flags: &["readonly"],
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_HASH_READ_SLOW,
        since: "2.0.0",
        complexity: "O(N) in the size of the hash",
        summary: "Every value of a hash.",
        group: "hash",
    },
    Spec {
        name: "hincrby",
        arity: 4,
        flags: WRITE_FAST_OOM,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_HASH_WRITE_FAST,
        since: "2.0.0",
        complexity: "O(1)",
        summary: "Add an integer to a field, treating a missing one as zero.",
        group: "hash",
    },
    Spec {
        name: "hincrbyfloat",
        arity: 4,
        flags: WRITE_FAST_OOM,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_HASH_WRITE_FAST,
        since: "2.6.0",
        complexity: "O(1)",
        summary: "Add a float to a field, treating a missing one as zero.",
        group: "hash",
    },
    Spec {
        name: "hrandfield",
        arity: -2,
        flags: &["readonly"],
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_HASH_READ_SLOW,
        since: "6.2.0",
        complexity: "O(1) without a count, O(N) with one",
        summary: "Fields of a hash at random, leaving the hash as it was.",
        group: "hash",
    },
    Spec {
        name: "hscan",
        arity: -3,
        flags: &["readonly"],
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_HASH_READ_SLOW,
        since: "2.8.0",
        complexity: "O(1) a call, O(N) for a whole iteration",
        summary: "Walk part of a hash and say where to carry on from.",
        group: "hash",
    },
    Spec {
        name: "hexpire",
        arity: -6,
        flags: WRITE_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_HASH_WRITE_FAST,
        since: "7.4.0",
        complexity: "O(N) with N the number of fields named",
        summary: "Put a deadline in seconds on hash fields.",
        group: "hash",
    },
    Spec {
        name: "hpexpire",
        arity: -6,
        flags: WRITE_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_HASH_WRITE_FAST,
        since: "7.4.0",
        complexity: "O(N) with N the number of fields named",
        summary: "Put a deadline in milliseconds on hash fields.",
        group: "hash",
    },
    Spec {
        name: "hexpireat",
        arity: -6,
        flags: WRITE_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_HASH_WRITE_FAST,
        since: "7.4.0",
        complexity: "O(N) with N the number of fields named",
        summary: "Put an absolute deadline in unix seconds on hash fields.",
        group: "hash",
    },
    Spec {
        name: "hpexpireat",
        arity: -6,
        flags: WRITE_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_HASH_WRITE_FAST,
        since: "7.4.0",
        complexity: "O(N) with N the number of fields named",
        summary: "Put an absolute deadline in unix milliseconds on hash fields.",
        group: "hash",
    },
    Spec {
        name: "httl",
        arity: -5,
        flags: READ_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_HASH_READ_FAST,
        since: "7.4.0",
        complexity: "O(N) with N the number of fields named",
        summary: "How long hash fields have left, in seconds.",
        group: "hash",
    },
    Spec {
        name: "hpttl",
        arity: -5,
        flags: READ_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_HASH_READ_FAST,
        since: "7.4.0",
        complexity: "O(N) with N the number of fields named",
        summary: "How long hash fields have left, in milliseconds.",
        group: "hash",
    },
    Spec {
        name: "hexpiretime",
        arity: -5,
        flags: READ_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_HASH_READ_FAST,
        since: "7.4.0",
        complexity: "O(N) with N the number of fields named",
        summary: "When hash fields fall due, in unix seconds.",
        group: "hash",
    },
    Spec {
        name: "hpexpiretime",
        arity: -5,
        flags: READ_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_HASH_READ_FAST,
        since: "7.4.0",
        complexity: "O(N) with N the number of fields named",
        summary: "When hash fields fall due, in unix milliseconds.",
        group: "hash",
    },
    Spec {
        name: "hpersist",
        arity: -5,
        flags: WRITE_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_HASH_WRITE_FAST,
        since: "7.4.0",
        complexity: "O(N) with N the number of fields named",
        summary: "Take the deadlines off hash fields.",
        group: "hash",
    },
    Spec {
        name: "hgetdel",
        arity: -5,
        flags: WRITE_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_HASH_WRITE_FAST,
        since: "8.0.0",
        complexity: "O(N) with N the number of fields named",
        summary: "Read hash fields and delete them.",
        group: "hash",
    },
    Spec {
        name: "hgetex",
        arity: -5,
        flags: WRITE_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_HASH_WRITE_FAST,
        since: "8.0.0",
        complexity: "O(N) with N the number of fields named",
        summary: "Read hash fields and set their deadlines.",
        group: "hash",
    },
    Spec {
        name: "hsetex",
        arity: -6,
        flags: WRITE_FAST_OOM,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_HASH_WRITE_FAST,
        since: "8.0.0",
        complexity: "O(N) with N the number of fields being set",
        summary: "Set hash fields and their deadlines together.",
        group: "hash",
    },
    // ---------------------------------------------------------------- lists
    Spec {
        name: "lpush",
        arity: -3,
        flags: WRITE_FAST_OOM,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_LIST_WRITE_FAST,
        since: "1.0.0",
        complexity: "O(N) with N the number of elements pushed",
        summary: "Push elements onto the head of a list.",
        group: "list",
    },
    Spec {
        name: "rpush",
        arity: -3,
        flags: WRITE_FAST_OOM,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_LIST_WRITE_FAST,
        since: "1.0.0",
        complexity: "O(N) with N the number of elements pushed",
        summary: "Push elements onto the tail of a list.",
        group: "list",
    },
    Spec {
        name: "lpushx",
        arity: -3,
        flags: WRITE_FAST_OOM,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_LIST_WRITE_FAST,
        since: "2.2.0",
        complexity: "O(N) with N the number of elements pushed",
        summary: "Push elements onto the head of a list that already exists.",
        group: "list",
    },
    Spec {
        name: "rpushx",
        arity: -3,
        flags: WRITE_FAST_OOM,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_LIST_WRITE_FAST,
        since: "2.2.0",
        complexity: "O(N) with N the number of elements pushed",
        summary: "Push elements onto the tail of a list that already exists.",
        group: "list",
    },
    Spec {
        name: "lpop",
        arity: -2,
        flags: WRITE_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_LIST_WRITE_FAST,
        since: "1.0.0",
        complexity: "O(N) with N the count asked for",
        summary: "Take elements off the head of a list.",
        group: "list",
    },
    Spec {
        name: "rpop",
        arity: -2,
        flags: WRITE_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_LIST_WRITE_FAST,
        since: "1.0.0",
        complexity: "O(N) with N the count asked for",
        summary: "Take elements off the tail of a list.",
        group: "list",
    },
    Spec {
        name: "llen",
        arity: 2,
        flags: READ_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_LIST_READ_FAST,
        since: "1.0.0",
        complexity: "O(1)",
        summary: "How many elements a list holds.",
        group: "list",
    },
    Spec {
        name: "lrange",
        arity: 4,
        flags: READ_SLOW,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_LIST_READ_SLOW,
        since: "1.0.0",
        complexity: "O(S+N) with S the offset of the first element and N the range",
        summary: "Read a range of a list, both ends included.",
        group: "list",
    },
    Spec {
        name: "lindex",
        arity: 3,
        flags: READ_SLOW,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_LIST_READ_SLOW,
        since: "1.0.0",
        complexity: "O(N) with N the distance to the index from the nearer end",
        summary: "Read one element of a list by index.",
        group: "list",
    },
    Spec {
        name: "lset",
        arity: 4,
        flags: WRITE_OOM,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_LIST_WRITE_SLOW,
        since: "1.0.0",
        complexity: "O(N) with N the distance to the index from the nearer end",
        summary: "Replace one element of a list by index.",
        group: "list",
    },
    Spec {
        name: "linsert",
        arity: 5,
        flags: WRITE_OOM,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_LIST_WRITE_SLOW,
        since: "2.2.0",
        complexity: "O(N) with N the distance to the pivot from the head",
        summary: "Insert an element before or after another one.",
        group: "list",
    },
    Spec {
        name: "lrem",
        arity: 4,
        flags: WRITE_SLOW,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_LIST_WRITE_SLOW,
        since: "1.0.0",
        complexity: "O(N) with N the length of the list",
        summary: "Remove elements equal to a value from a list.",
        group: "list",
    },
    Spec {
        name: "ltrim",
        arity: 4,
        flags: WRITE_SLOW,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_LIST_WRITE_SLOW,
        since: "1.0.0",
        complexity: "O(N) with N the number of elements thrown away",
        summary: "Keep a range of a list and throw the rest away.",
        group: "list",
    },
    Spec {
        name: "lpos",
        arity: -3,
        flags: READ_SLOW,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_LIST_READ_SLOW,
        since: "6.0.6",
        complexity: "O(N) with N the length of the list",
        summary: "Find where a value sits in a list.",
        group: "list",
    },
    Spec {
        name: "rpoplpush",
        arity: 3,
        flags: WRITE_OOM,
        first_key: 1,
        last_key: 2,
        step: 1,
        acl: AC_LIST_WRITE_SLOW,
        since: "1.2.0",
        complexity: "O(1)",
        summary: "Move an element from the tail of one list to the head of another.",
        group: "list",
    },
    Spec {
        name: "lmove",
        arity: 5,
        flags: WRITE_OOM,
        first_key: 1,
        last_key: 2,
        step: 1,
        acl: AC_LIST_WRITE_SLOW,
        since: "6.2.0",
        complexity: "O(1)",
        summary: "Move an element from either end of one list to either end of another.",
        group: "list",
    },
    // The keys are behind a count, so `first_key` is zero and a cluster client
    // has to ask `COMMAND GETKEYS` rather than read a position out of this row.
    // That is what `movablekeys` means and it is why the three key fields are
    // all zero rather than pointing at argument two.
    Spec {
        name: "lmpop",
        arity: -4,
        flags: &["write", "movablekeys"],
        first_key: 0,
        last_key: 0,
        step: 0,
        acl: AC_LIST_WRITE_SLOW,
        since: "7.0.0",
        complexity: "O(N+M) with N the number of keys and M the count popped",
        summary: "Pop from the first of several lists that has anything in it.",
        group: "list",
    },
    // The five that wait. `blocking` is what the dispatcher branches on to send
    // them somewhere that can park a client, so it is load bearing here rather
    // than only being reported.
    //
    // `BLPOP` and `BRPOP` take their keys up to the timeout, which is the one
    // shape in the list group where `last_key` is negative: everything from
    // argument one to the second from last.
    Spec {
        name: "blpop",
        arity: -3,
        flags: &["write", "blocking"],
        first_key: 1,
        last_key: -2,
        step: 1,
        acl: AC_LIST_WRITE_BLOCKING,
        since: "2.0.0",
        complexity: "O(N) with N the number of keys named",
        summary: "Pop the head of the first list that has anything, waiting if none does.",
        group: "list",
    },
    Spec {
        name: "brpop",
        arity: -3,
        flags: &["write", "blocking"],
        first_key: 1,
        last_key: -2,
        step: 1,
        acl: AC_LIST_WRITE_BLOCKING,
        since: "2.0.0",
        complexity: "O(N) with N the number of keys named",
        summary: "Pop the tail of the first list that has anything, waiting if none does.",
        group: "list",
    },
    // Redis marks the two that push somewhere `denyoom` and does not mark the
    // pops, because these are the blocking commands that can grow the keyspace.
    Spec {
        name: "blmove",
        arity: 6,
        flags: &["write", "denyoom", "blocking"],
        first_key: 1,
        last_key: 2,
        step: 1,
        acl: AC_LIST_WRITE_BLOCKING,
        since: "6.2.0",
        complexity: "O(1)",
        summary: "Move an element between two lists, waiting for one to arrive.",
        group: "list",
    },
    Spec {
        name: "brpoplpush",
        arity: 4,
        flags: &["write", "denyoom", "blocking"],
        first_key: 1,
        last_key: 2,
        step: 1,
        acl: AC_LIST_WRITE_BLOCKING,
        since: "2.2.0",
        complexity: "O(1)",
        summary: "Move a tail element to another list's head, waiting for one to arrive.",
        group: "list",
    },
    // Keys behind a count again, so the same three zeroes `LMPOP` has.
    Spec {
        name: "blmpop",
        arity: -5,
        flags: &["write", "blocking", "movablekeys"],
        first_key: 0,
        last_key: 0,
        step: 0,
        acl: AC_LIST_WRITE_BLOCKING,
        since: "7.0.0",
        complexity: "O(N+M) with N the number of keys and M the count popped",
        summary: "Pop from the first of several lists that has anything, waiting if none does.",
        group: "list",
    },
    // ------------------------------------------------------------ sorted set
    Spec {
        name: "zadd",
        arity: -4,
        flags: WRITE_FAST_OOM,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ZSET_WRITE_FAST,
        since: "1.2.0",
        complexity: "O(log(N)) for each member added",
        summary: "Add members with scores, or move the scores of members already there.",
        group: "zset",
    },
    Spec {
        name: "zincrby",
        arity: 4,
        flags: WRITE_FAST_OOM,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ZSET_WRITE_FAST,
        since: "1.2.0",
        complexity: "O(log(N))",
        summary: "Add to a member's score, creating the member at zero if it is not there.",
        group: "zset",
    },
    Spec {
        name: "zcard",
        arity: 2,
        flags: READ_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ZSET_READ_FAST,
        since: "1.2.0",
        complexity: "O(1)",
        summary: "How many members a sorted set has.",
        group: "zset",
    },
    Spec {
        name: "zscore",
        arity: 3,
        flags: READ_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ZSET_READ_FAST,
        since: "1.2.0",
        complexity: "O(1)",
        summary: "A member's score, or nothing if it is not there.",
        group: "zset",
    },
    Spec {
        name: "zmscore",
        arity: -3,
        flags: READ_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ZSET_READ_FAST,
        since: "6.2.0",
        complexity: "O(N) with N the number of members asked about",
        summary: "The scores of several members in one round trip.",
        group: "zset",
    },
    Spec {
        name: "zrem",
        arity: -3,
        flags: WRITE_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ZSET_WRITE_FAST,
        since: "1.2.0",
        complexity: "O(M*log(N)) with M the number of members removed",
        summary: "Remove members, deleting the key if the last one goes.",
        group: "zset",
    },
    Spec {
        name: "zrank",
        arity: -3,
        flags: READ_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ZSET_READ_FAST,
        since: "2.0.0",
        complexity: "O(log(N))",
        summary: "Where a member sits counting up from the lowest score.",
        group: "zset",
    },
    Spec {
        name: "zrevrank",
        arity: -3,
        flags: READ_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ZSET_READ_FAST,
        since: "2.0.0",
        complexity: "O(log(N))",
        summary: "Where a member sits counting down from the highest score.",
        group: "zset",
    },
    Spec {
        name: "zcount",
        arity: 4,
        flags: READ_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ZSET_READ_FAST,
        since: "2.0.0",
        complexity: "O(log(N))",
        summary: "How many members have scores between two bounds.",
        group: "zset",
    },
    Spec {
        name: "zlexcount",
        arity: 4,
        flags: READ_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ZSET_READ_FAST,
        since: "2.8.9",
        complexity: "O(log(N))",
        summary: "How many members fall between two members, by name.",
        group: "zset",
    },
    Spec {
        name: "zrange",
        arity: -4,
        flags: READ_SLOW,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ZSET_READ_SLOW,
        since: "1.2.0",
        complexity: "O(log(N)+M) with M the number of members answered",
        summary: "A window of members, by rank or by score or by name, either way round.",
        group: "zset",
    },
    Spec {
        name: "zrevrange",
        arity: -4,
        flags: READ_SLOW,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ZSET_READ_SLOW,
        since: "1.2.0",
        complexity: "O(log(N)+M) with M the number of members answered",
        summary: "A window by rank, counting down from the highest score.",
        group: "zset",
    },
    Spec {
        name: "zrangebyscore",
        arity: -4,
        flags: READ_SLOW,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ZSET_READ_SLOW,
        since: "1.0.5",
        complexity: "O(log(N)+M) with M the number of members answered",
        summary: "The members whose scores fall between two bounds.",
        group: "zset",
    },
    Spec {
        name: "zrevrangebyscore",
        arity: -4,
        flags: READ_SLOW,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ZSET_READ_SLOW,
        since: "2.2.0",
        complexity: "O(log(N)+M) with M the number of members answered",
        summary: "The same window as ZRANGEBYSCORE, highest score first and named high end first.",
        group: "zset",
    },
    Spec {
        name: "zrangebylex",
        arity: -4,
        flags: READ_SLOW,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ZSET_READ_SLOW,
        since: "2.8.9",
        complexity: "O(log(N)+M) with M the number of members answered",
        summary: "The members that fall between two names, for a set where every score is the same.",
        group: "zset",
    },
    Spec {
        name: "zrevrangebylex",
        arity: -4,
        flags: READ_SLOW,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ZSET_READ_SLOW,
        since: "2.8.9",
        complexity: "O(log(N)+M) with M the number of members answered",
        summary: "The same window as ZRANGEBYLEX, backwards and named high end first.",
        group: "zset",
    },
    Spec {
        name: "zrangestore",
        arity: -5,
        flags: WRITE_OOM,
        first_key: 1,
        last_key: 2,
        step: 1,
        acl: AC_ZSET_WRITE_SLOW,
        since: "6.2.0",
        complexity: "O(log(N)+M) with M the number of members stored",
        summary: "Write a window of one sorted set into another key.",
        group: "zset",
    },
    Spec {
        name: "zremrangebyrank",
        arity: 4,
        flags: WRITE_SLOW,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ZSET_WRITE_SLOW,
        since: "2.0.0",
        complexity: "O(log(N)+M) with M the number of members removed",
        summary: "Remove the members in a range of ranks.",
        group: "zset",
    },
    Spec {
        name: "zremrangebyscore",
        arity: 4,
        flags: WRITE_SLOW,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ZSET_WRITE_SLOW,
        since: "1.2.0",
        complexity: "O(log(N)+M) with M the number of members removed",
        summary: "Remove the members whose scores fall between two bounds.",
        group: "zset",
    },
    Spec {
        name: "zremrangebylex",
        arity: 4,
        flags: WRITE_SLOW,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ZSET_WRITE_SLOW,
        since: "2.8.9",
        complexity: "O(log(N)+M) with M the number of members removed",
        summary: "Remove the members that fall between two names.",
        group: "zset",
    },
    Spec {
        name: "zunion",
        arity: -3,
        flags: READ_MOVABLE,
        first_key: 0,
        last_key: 0,
        step: 0,
        acl: AC_ZSET_READ_SLOW,
        since: "6.2.0",
        complexity: "O(N)+O(M*log(M)) with N the total number of members and M the number in the answer",
        summary: "Every member of these sorted sets, with the scores combined.",
        group: "zset",
    },
    Spec {
        name: "zinter",
        arity: -3,
        flags: READ_MOVABLE,
        first_key: 0,
        last_key: 0,
        step: 0,
        acl: AC_ZSET_READ_SLOW,
        since: "6.2.0",
        complexity: "O(N)+O(M*log(M)) with N the total number of members and M the number in the answer",
        summary: "Only the members all of these sorted sets have, with the scores combined.",
        group: "zset",
    },
    Spec {
        name: "zdiff",
        arity: -3,
        flags: READ_MOVABLE,
        first_key: 0,
        last_key: 0,
        step: 0,
        acl: AC_ZSET_READ_SLOW,
        since: "6.2.0",
        complexity: "O(N)+O(M*log(M)) with N the total number of members and M the number in the answer",
        summary: "The members of the first that none of the rest have.",
        group: "zset",
    },
    Spec {
        name: "zunionstore",
        arity: -4,
        flags: WRITE_MOVABLE,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ZSET_WRITE_SLOW,
        since: "2.0.0",
        complexity: "O(N)+O(M*log(M)) with N the total number of members and M the number in the answer",
        summary: "Store the union in another key and say how big it is.",
        group: "zset",
    },
    Spec {
        name: "zinterstore",
        arity: -4,
        flags: WRITE_MOVABLE,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ZSET_WRITE_SLOW,
        since: "2.0.0",
        complexity: "O(N)+O(M*log(M)) with N the total number of members and M the number in the answer",
        summary: "Store the intersection in another key and say how big it is.",
        group: "zset",
    },
    Spec {
        name: "zdiffstore",
        arity: -4,
        flags: WRITE_MOVABLE,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ZSET_WRITE_SLOW,
        since: "6.2.0",
        complexity: "O(N)+O(M*log(M)) with N the total number of members and M the number in the answer",
        summary: "Store the difference in another key and say how big it is.",
        group: "zset",
    },
    Spec {
        name: "zintercard",
        arity: -3,
        flags: READ_MOVABLE,
        first_key: 0,
        last_key: 0,
        step: 0,
        acl: AC_ZSET_READ_SLOW,
        since: "7.0.0",
        complexity: "O(N*M) worst case, N the smallest input and M the number of inputs",
        summary: "How many members the intersection would have, without building it.",
        group: "zset",
    },
    Spec {
        name: "zrandmember",
        arity: -2,
        flags: READ_SLOW,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ZSET_READ_SLOW,
        since: "6.2.0",
        complexity: "O(N) with N the number of members drawn",
        summary: "Draw members at random, with or without replacement.",
        group: "zset",
    },
    Spec {
        name: "zscan",
        arity: -3,
        flags: READ_SLOW,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ZSET_READ_SLOW,
        since: "2.8.0",
        complexity: "O(1) per call, O(N) over a full walk",
        summary: "Walk the members and their scores a batch at a time.",
        group: "zset",
    },
    // The pops. Redis calls the two single key ones fast even though they cost a
    // logarithm, on the grounds that the logarithm is of a size a client chose.
    Spec {
        name: "zpopmin",
        arity: -2,
        flags: WRITE_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ZSET_WRITE_FAST,
        since: "5.0.0",
        complexity: "O(log(N)*M) with M the number of members popped",
        summary: "Take the lowest scoring members off and answer them.",
        group: "zset",
    },
    Spec {
        name: "zpopmax",
        arity: -2,
        flags: WRITE_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ZSET_WRITE_FAST,
        since: "5.0.0",
        complexity: "O(log(N)*M) with M the number of members popped",
        summary: "Take the highest scoring members off and answer them.",
        group: "zset",
    },
    // Keys behind a count, so the same three zeroes `LMPOP` has, and `write`
    // without `denyoom` because a pop cannot grow the keyspace.
    Spec {
        name: "zmpop",
        arity: -4,
        flags: &["write", "movablekeys"],
        first_key: 0,
        last_key: 0,
        step: 0,
        acl: AC_ZSET_WRITE_SLOW,
        since: "7.0.0",
        complexity: "O(K) + O(M*log(N)) with K the keys named and M the count popped",
        summary: "Pop from the first of several sorted sets that has anything in it.",
        group: "zset",
    },
    // The three that wait. `blocking` is what the dispatcher branches on, the
    // same as it is for the five list ones.
    Spec {
        name: "bzpopmin",
        arity: -3,
        flags: &["write", "blocking", "fast"],
        first_key: 1,
        last_key: -2,
        step: 1,
        acl: AC_ZSET_BLOCKING_FAST,
        since: "5.0.0",
        complexity: "O(log(N)) with N the size of the sorted set that answers",
        summary: "Take the lowest scoring member off the first sorted set that has one, waiting if none does.",
        group: "zset",
    },
    Spec {
        name: "bzpopmax",
        arity: -3,
        flags: &["write", "blocking", "fast"],
        first_key: 1,
        last_key: -2,
        step: 1,
        acl: AC_ZSET_BLOCKING_FAST,
        since: "5.0.0",
        complexity: "O(log(N)) with N the size of the sorted set that answers",
        summary: "Take the highest scoring member off the first sorted set that has one, waiting if none does.",
        group: "zset",
    },
    Spec {
        name: "bzmpop",
        arity: -5,
        flags: &["write", "blocking", "movablekeys"],
        first_key: 0,
        last_key: 0,
        step: 0,
        acl: AC_ZSET_BLOCKING_SLOW,
        since: "7.0.0",
        complexity: "O(K) + O(M*log(N)) with K the keys named and M the count popped",
        summary: "Pop from the first of several sorted sets that has anything, waiting if none does.",
        group: "zset",
    },
    // --------------------------------------------------------------- array
    Spec {
        name: "arset",
        arity: -4,
        flags: WRITE_FAST_OOM,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ARRAY_WRITE_FAST,
        since: "8.8.0",
        complexity: "O(N) with N the number of values",
        summary: "Write values into consecutive positions from an index.",
        group: "array",
    },
    Spec {
        name: "armset",
        arity: -4,
        flags: WRITE_FAST_OOM,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ARRAY_WRITE_FAST,
        since: "8.8.0",
        complexity: "O(N) with N the number of pairs",
        summary: "Write index and value pairs, which need not be neighbours.",
        group: "array",
    },
    Spec {
        name: "arget",
        arity: 3,
        flags: READ_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ARRAY_READ_FAST,
        since: "8.8.0",
        complexity: "O(1)",
        summary: "The value at one index, or a null if nothing is there.",
        group: "array",
    },
    Spec {
        name: "armget",
        arity: -3,
        flags: READ_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ARRAY_READ_FAST,
        since: "8.8.0",
        complexity: "O(N) with N the number of indices",
        summary: "The values at the indices named, in the order named.",
        group: "array",
    },
    Spec {
        name: "argetrange",
        arity: 4,
        flags: READ_SLOW,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ARRAY_READ_SLOW,
        since: "8.8.0",
        complexity: "O(N) with N the length of the range",
        summary: "One reply per position between two indices, holes included.",
        group: "array",
    },
    Spec {
        name: "arlen",
        arity: 2,
        flags: READ_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ARRAY_READ_FAST,
        since: "8.8.0",
        complexity: "O(1)",
        summary: "The highest populated index plus one.",
        group: "array",
    },
    Spec {
        name: "arcount",
        arity: 2,
        flags: READ_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ARRAY_READ_FAST,
        since: "8.8.0",
        complexity: "O(1)",
        summary: "How many indices hold something.",
        group: "array",
    },
    Spec {
        name: "ardel",
        arity: -3,
        flags: WRITE_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ARRAY_WRITE_FAST,
        since: "8.8.0",
        complexity: "O(N) with N the number of indices",
        summary: "Empty the indices named and say how many held something.",
        group: "array",
    },
    Spec {
        name: "ardelrange",
        arity: -4,
        flags: WRITE_SLOW,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ARRAY_WRITE_SLOW,
        since: "8.8.0",
        complexity: "O(N) with N the elements touched, not the span asked for",
        summary: "Empty one or more ranges of indices.",
        group: "array",
    },
    Spec {
        name: "arinsert",
        arity: -3,
        flags: WRITE_FAST_OOM,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ARRAY_WRITE_FAST,
        since: "8.8.0",
        complexity: "O(N) with N the number of values",
        summary: "Append values at the insert cursor.",
        group: "array",
    },
    Spec {
        name: "arring",
        arity: -4,
        flags: WRITE_OOM,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ARRAY_WRITE_SLOW,
        since: "8.8.0",
        complexity: "O(N) with N the values, plus the ring size when it changes",
        summary: "Append values into a ring of the given size.",
        group: "array",
    },
    Spec {
        name: "arnext",
        arity: 2,
        flags: READ_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ARRAY_READ_FAST,
        since: "8.8.0",
        complexity: "O(1)",
        summary: "The index the next append would write to.",
        group: "array",
    },
    Spec {
        name: "arseek",
        arity: 3,
        flags: WRITE_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ARRAY_WRITE_FAST,
        since: "8.8.0",
        complexity: "O(1)",
        summary: "Point the insert cursor at an index.",
        group: "array",
    },
    Spec {
        name: "arlastitems",
        arity: -3,
        flags: READ_SLOW,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ARRAY_READ_SLOW,
        since: "8.8.0",
        complexity: "O(N) with N the count asked for",
        summary: "The newest positions from the insert cursor, holes included.",
        group: "array",
    },
    Spec {
        name: "arscan",
        arity: -4,
        flags: READ_SLOW,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ARRAY_READ_SLOW,
        since: "8.8.0",
        complexity: "O(N) with N the elements found, not the span asked for",
        summary: "Index and value pairs for what a range holds, skipping holes.",
        group: "array",
    },
    Spec {
        name: "argrep",
        arity: -6,
        flags: READ_SLOW,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ARRAY_READ_SLOW,
        since: "8.8.0",
        complexity: "O(P * C) with P the positions visited and C the cost of the predicates on one element",
        summary: "The indexes in a range whose elements answer a set of textual predicates.",
        group: "array",
    },
    Spec {
        name: "arop",
        arity: -5,
        flags: READ_SLOW,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ARRAY_READ_SLOW,
        since: "8.8.0",
        complexity: "O(N) with N the elements found, not the span asked for",
        summary: "One number out of a range, added up or compared or counted.",
        group: "array",
    },
    Spec {
        name: "arinfo",
        arity: -2,
        flags: READ_SLOW,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_ARRAY_READ_SLOW,
        since: "8.8.0",
        complexity: "O(1), or O(N) with N the slices when FULL is given",
        summary: "The shape of the array, and what its slices look like.",
        group: "array",
    },
    // ------------------------------------------------------------ keyspace
    Spec {
        name: "del",
        arity: -2,
        flags: &["write"],
        first_key: 1,
        last_key: -1,
        step: 1,
        acl: AC_KEY_WRITE_SLOW,
        since: "1.0.0",
        complexity: "O(N) in the number of keys.",
        summary: "Delete keys and say how many were there.",
        group: "keyspace",
    },
    Spec {
        name: "unlink",
        arity: -2,
        flags: &["write", "fast"],
        first_key: 1,
        last_key: -1,
        step: 1,
        acl: AC_KEY_WRITE_FAST,
        since: "4.0.0",
        complexity: "O(1) per key, since the freeing is not on this thread.",
        summary: "Delete keys and free them out of the way of the reply.",
        group: "keyspace",
    },
    Spec {
        name: "exists",
        arity: -2,
        flags: READ_FAST,
        first_key: 1,
        last_key: -1,
        step: 1,
        acl: AC_KEY_READ,
        since: "1.0.0",
        complexity: "O(N) in the number of keys.",
        summary: "Count how many of these keys are there, naming one twice counting twice.",
        group: "keyspace",
    },
    Spec {
        name: "type",
        arity: 2,
        flags: READ_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_KEY_READ,
        since: "1.0.0",
        complexity: "O(1)",
        summary: "What kind of value is under a key, or none.",
        group: "keyspace",
    },
    Spec {
        name: "touch",
        arity: -2,
        flags: READ_FAST,
        first_key: 1,
        last_key: -1,
        step: 1,
        acl: AC_KEY_READ,
        since: "3.2.1",
        complexity: "O(N) in the number of keys.",
        summary: "Count how many of these keys are there, and move them up the eviction order.",
        group: "keyspace",
    },
    // The three that look at keys nobody named. No key positions on any of
    // them, which is what the zeroes say, and it is also why a cluster client
    // sends them to a node rather than to a slot.
    Spec {
        name: "scan",
        arity: -2,
        flags: &["readonly"],
        first_key: 0,
        last_key: 0,
        step: 0,
        acl: AC_KEY_READ_SLOW,
        since: "2.8.0",
        complexity: "O(1) a call, O(N) for a whole iteration",
        summary: "Walk part of the keyspace and say where to carry on from.",
        group: "keyspace",
    },
    Spec {
        name: "keys",
        arity: 2,
        flags: &["readonly"],
        first_key: 0,
        last_key: 0,
        step: 0,
        acl: AC_KEY_READ_ALL,
        since: "1.0.0",
        complexity: "O(N) in the number of keys.",
        summary: "Every key matching a pattern, in one reply.",
        group: "keyspace",
    },
    Spec {
        name: "randomkey",
        arity: 1,
        flags: &["readonly"],
        first_key: 0,
        last_key: 0,
        step: 0,
        acl: AC_KEY_READ_SLOW,
        since: "1.0.0",
        complexity: "O(1)",
        summary: "One key from the database, chosen at random.",
        group: "keyspace",
    },
    // Two keys and not one, which is the 1 2 1 in the key positions. Every other
    // row in this group names a range that runs to the end of the arguments.
    Spec {
        name: "rename",
        arity: 3,
        flags: &["write"],
        first_key: 1,
        last_key: 2,
        step: 1,
        acl: AC_KEY_WRITE_SLOW,
        since: "1.0.0",
        complexity: "O(1)",
        summary: "Move a key to another name, over whatever was there.",
        group: "keyspace",
    },
    Spec {
        name: "renamenx",
        arity: 3,
        flags: WRITE_FAST,
        first_key: 1,
        last_key: 2,
        step: 1,
        acl: AC_KEY_WRITE_FAST,
        since: "1.0.0",
        complexity: "O(1)",
        summary: "Move a key to another name, but only if that name is free.",
        group: "keyspace",
    },
    // `denyoom` and no `fast`, because this is the one command in the group that
    // allocates a whole second value.
    Spec {
        name: "copy",
        arity: -3,
        flags: &["write", "denyoom"],
        first_key: 1,
        last_key: 2,
        step: 1,
        acl: AC_KEY_WRITE_SLOW,
        since: "6.2.0",
        complexity: "O(N) in the size of the value.",
        summary: "Copy a value to another key, in this database or another one.",
        group: "keyspace",
    },
    // `COPY` with the source deleted, and the only command in the group whose
    // second argument is a database rather than a key. The key spec is one key
    // at argument one and the database index is not a key, which is why this
    // does not look like `COPY` above it.
    Spec {
        name: "move",
        arity: 3,
        flags: WRITE_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_KEY_WRITE_FAST,
        since: "1.0.0",
        complexity: "O(1)",
        summary: "Move a key to another database, if it is not already there.",
        group: "keyspace",
    },
    // The two that block on replication rather than on a key, so they name no
    // key at all and the three zeroes below are not a placeholder.
    Spec {
        name: "wait",
        arity: 3,
        flags: &["blocking"],
        first_key: 0,
        last_key: 0,
        step: 0,
        acl: AC_WAIT,
        since: "3.0.0",
        complexity: "O(1)",
        summary: "Wait for this connection's writes to reach a number of replicas.",
        group: "keyspace",
    },
    Spec {
        name: "waitaof",
        arity: 4,
        flags: &["blocking"],
        first_key: 0,
        last_key: 0,
        step: 0,
        acl: AC_WAIT,
        since: "7.2.0",
        complexity: "O(1)",
        summary: "Wait for this connection's writes to reach the append only files.",
        group: "keyspace",
    },
    // The two that speak the file format. A payload is a value standing on its
    // own outside the process, so these are the only two commands in the group
    // that move a value rather than a name.
    Spec {
        name: "dump",
        arity: 2,
        flags: READ_SLOW,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_KEY_READ_SLOW,
        since: "2.6.0",
        complexity: "O(1) to find the key, then O(N) in the size of the value.",
        summary: "Serialize a value into a payload another server can load.",
        group: "keyspace",
    },
    Spec {
        name: "restore",
        arity: -4,
        flags: &["write", "denyoom"],
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_RESTORE,
        since: "2.6.0",
        complexity: "O(1) to find the key, then O(N) in the size of the payload.",
        summary: "Create a key from a payload produced by DUMP.",
        group: "keyspace",
    },
    // And the third one, which is the other two with a socket in between. Its
    // keys are movable for the same reason `SORT`'s are, though for a plainer
    // reason: the `KEYS` option moves them from argument three to everything
    // after the word, so where they are depends on what was written.
    Spec {
        name: "migrate",
        arity: -6,
        flags: MIGRATE_FLAGS,
        first_key: 3,
        last_key: 3,
        step: 1,
        acl: AC_RESTORE,
        since: "2.6.0",
        complexity: "A DUMP and a DEL here, a RESTORE there, and the bytes in between.",
        summary: "Move a key to another server.",
        group: "keyspace",
    },
    // The two whose keys cannot be read off the command. `SORT k BY w_* GET d_*`
    // touches every key those two patterns name and a client cannot know which
    // ones without the data, so both carry `movablekeys` and Redis's own key
    // specs give the same answer: the first key, and the STORE destination if
    // there is one.
    Spec {
        name: "sort",
        arity: -2,
        flags: WRITE_MOVABLE,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_SORT_WRITE,
        since: "1.0.0",
        complexity: "O(N+M*log(M)) with N elements and M returned.",
        summary: "Sort a list, set or sorted set, optionally into another key.",
        group: "keyspace",
    },
    Spec {
        name: "sort_ro",
        arity: -2,
        flags: READ_MOVABLE,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_SORT_READ,
        since: "7.0.0",
        complexity: "O(N+M*log(M)) with N elements and M returned.",
        summary: "Sort a list, set or sorted set, without the STORE option.",
        group: "keyspace",
    },
    // The four writers take an optional NX, XX, GT or LT, which is the -3 in
    // the arity, and they take the same one whichever unit they are in.
    Spec {
        name: "expire",
        arity: -3,
        flags: WRITE_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_KEY_WRITE_FAST,
        since: "1.0.0",
        complexity: "O(1)",
        summary: "Put a deadline on a key, counted in seconds from now.",
        group: "keyspace",
    },
    Spec {
        name: "pexpire",
        arity: -3,
        flags: WRITE_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_KEY_WRITE_FAST,
        since: "2.6.0",
        complexity: "O(1)",
        summary: "Put a deadline on a key, counted in milliseconds from now.",
        group: "keyspace",
    },
    Spec {
        name: "expireat",
        arity: -3,
        flags: WRITE_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_KEY_WRITE_FAST,
        since: "1.2.0",
        complexity: "O(1)",
        summary: "Put a deadline on a key, as a unix time in seconds.",
        group: "keyspace",
    },
    Spec {
        name: "pexpireat",
        arity: -3,
        flags: WRITE_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_KEY_WRITE_FAST,
        since: "2.6.0",
        complexity: "O(1)",
        summary: "Put a deadline on a key, as a unix time in milliseconds.",
        group: "keyspace",
    },
    Spec {
        name: "persist",
        arity: 2,
        flags: WRITE_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_KEY_WRITE_FAST,
        since: "2.2.0",
        complexity: "O(1)",
        summary: "Take a key's deadline off, so it stops being temporary.",
        group: "keyspace",
    },
    Spec {
        name: "ttl",
        arity: 2,
        flags: READ_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_KEY_READ,
        since: "1.0.0",
        complexity: "O(1)",
        summary: "How many seconds a key has left, -1 with no deadline, -2 if gone.",
        group: "keyspace",
    },
    Spec {
        name: "pttl",
        arity: 2,
        flags: READ_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_KEY_READ,
        since: "2.6.0",
        complexity: "O(1)",
        summary: "How many milliseconds a key has left, -1 with no deadline, -2 if gone.",
        group: "keyspace",
    },
    Spec {
        name: "expiretime",
        arity: 2,
        flags: READ_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_KEY_READ,
        since: "7.0.0",
        complexity: "O(1)",
        summary: "When a key falls due, as a unix time in seconds.",
        group: "keyspace",
    },
    Spec {
        name: "pexpiretime",
        arity: 2,
        flags: READ_FAST,
        first_key: 1,
        last_key: 1,
        step: 1,
        acl: AC_KEY_READ,
        since: "7.0.0",
        complexity: "O(1)",
        summary: "When a key falls due, as a unix time in milliseconds.",
        group: "keyspace",
    },
    // A container command, so no keys and no flags of its own: the key is the
    // subcommand's and a real server reports it on `object|encoding` rather
    // than here. `@slow` is the whole ACL, checked against 8.10.1.
    Spec {
        name: "object",
        arity: -2,
        flags: &[],
        first_key: 0,
        last_key: 0,
        step: 0,
        acl: &["@slow"],
        since: "2.2.3",
        complexity: "O(1)",
        summary: "Look at the machinery under a key rather than at its value.",
        group: "keyspace",
    },
    // ----------------------------------------------------------- scripting
    // Both are containers with no flags and no keys of their own, which is what
    // a real 8.10.1 reports: the flags live on the subcommands.
    Spec {
        name: "script",
        arity: -2,
        flags: &[],
        first_key: 0,
        last_key: 0,
        step: 0,
        acl: &["@slow"],
        since: "2.6.0",
        complexity: "O(1) for the subcommands that are here.",
        summary: "The script cache, which is empty and stays empty until M6.",
        group: "scripting",
    },
    Spec {
        name: "function",
        arity: -2,
        flags: &[],
        first_key: 0,
        last_key: 0,
        step: 0,
        acl: &["@slow"],
        since: "7.0.0",
        complexity: "O(1) for the subcommands that are here.",
        summary: "The function libraries, of which there are none until M6.",
        group: "scripting",
    },
    // ---------------------------------------------------------- connection
    Spec {
        name: "ping",
        arity: -1,
        flags: &["fast"],
        first_key: 0,
        last_key: 0,
        step: 0,
        acl: AC_CONN,
        since: "1.0.0",
        complexity: "O(1)",
        summary: "Ask whether the server is answering.",
        group: "connection",
    },
    Spec {
        name: "echo",
        arity: 2,
        flags: &["loading", "stale", "fast"],
        first_key: 0,
        last_key: 0,
        step: 0,
        acl: AC_CONN,
        since: "1.0.0",
        complexity: "O(1)",
        summary: "Send a string back unchanged.",
        group: "connection",
    },
    Spec {
        name: "hello",
        arity: -1,
        flags: &[
            "noscript",
            "loading",
            "stale",
            "fast",
            "no_auth",
            "allow_busy",
        ],
        first_key: 0,
        last_key: 0,
        step: 0,
        acl: AC_CONN,
        since: "6.0.0",
        complexity: "O(1)",
        summary: "Agree on a protocol version and describe the server.",
        group: "connection",
    },
    Spec {
        name: "select",
        arity: 2,
        flags: &["loading", "stale", "fast"],
        first_key: 0,
        last_key: 0,
        step: 0,
        acl: AC_CONN,
        since: "1.0.0",
        complexity: "O(1)",
        summary: "Choose which database this connection works in.",
        group: "connection",
    },
    Spec {
        name: "reset",
        arity: 1,
        flags: &[
            "noscript",
            "loading",
            "stale",
            "fast",
            "no_auth",
            "allow_busy",
        ],
        first_key: 0,
        last_key: 0,
        step: 0,
        acl: AC_CONN,
        since: "6.2.0",
        complexity: "O(1)",
        summary: "Put the connection back the way it was opened.",
        group: "connection",
    },
    Spec {
        name: "quit",
        arity: -1,
        flags: &[
            "noscript",
            "loading",
            "stale",
            "fast",
            "no_auth",
            "allow_busy",
        ],
        first_key: 0,
        last_key: 0,
        step: 0,
        acl: AC_CONN,
        since: "1.0.0",
        complexity: "O(1)",
        summary: "Close the connection after the replies already queued.",
        group: "connection",
    },
    // -------------------------------------------------------------- server
    // COMMAND is in the connection ACL category and in the server group, which
    // is not a contradiction: the category is about what a connection is
    // allowed to do and the group is about what the command is about. The group
    // is the one reported by COMMAND DOCS, so it is the one that has to match.
    Spec {
        name: "command",
        arity: -1,
        flags: &["loading", "stale"],
        first_key: 0,
        last_key: 0,
        step: 0,
        acl: &["@slow", "@connection"],
        since: "2.8.13",
        complexity: "O(N) with N the number of commands",
        summary: "What this server can do, in the shape client libraries read.",
        group: "server",
    },
    Spec {
        name: "config",
        arity: -2,
        flags: &[],
        first_key: 0,
        last_key: 0,
        step: 0,
        acl: &["@slow"],
        since: "2.0.0",
        complexity: "Depends on the subcommand.",
        summary: "Read and change the settings a running server exposes.",
        group: "server",
    },
    Spec {
        name: "info",
        arity: -1,
        flags: &["loading", "stale"],
        first_key: 0,
        last_key: 0,
        step: 0,
        acl: &["@slow", "@dangerous"],
        since: "1.0.0",
        complexity: "O(1)",
        summary: "The server's own numbers, in sections.",
        group: "server",
    },
    Spec {
        name: "dbsize",
        arity: 1,
        flags: READ_FAST,
        first_key: 0,
        last_key: 0,
        step: 0,
        acl: AC_KEY_READ,
        since: "1.0.0",
        complexity: "O(1)",
        summary: "How many keys are in the database this connection is on.",
        group: "server",
    },
    Spec {
        name: "flushall",
        arity: -1,
        flags: &["write"],
        first_key: 0,
        last_key: 0,
        step: 0,
        acl: AC_KEY_FLUSH,
        since: "1.0.0",
        complexity: "O(N) in the number of keys in every database.",
        summary: "Empty every database.",
        group: "server",
    },
    Spec {
        name: "flushdb",
        arity: -1,
        flags: &["write"],
        first_key: 0,
        last_key: 0,
        step: 0,
        acl: AC_KEY_FLUSH,
        since: "1.0.0",
        complexity: "O(N) in the number of keys in this database.",
        summary: "Empty the database this connection is on.",
        group: "server",
    },
    // In the server group and not the keyspace one, which is Redis's answer and
    // is the right one: it names no key, it takes two database indexes, and what
    // it changes is what every connected client is looking at.
    Spec {
        name: "swapdb",
        arity: 3,
        flags: WRITE_FAST,
        first_key: 0,
        last_key: 0,
        step: 0,
        acl: AC_SWAPDB,
        since: "4.0.0",
        complexity: "O(N) in the number of clients watching or blocked on either.",
        summary: "Swap two databases, so every client on one sees the other.",
        group: "server",
    },
    // No ACL category but `@fast`, which is Redis's answer and reads like an
    // omission. It is not: the categories are about what a command can reach and
    // this one reaches nothing.
    Spec {
        name: "time",
        arity: 1,
        flags: &["loading", "stale", "fast"],
        first_key: 0,
        last_key: 0,
        step: 0,
        acl: &["@fast"],
        since: "2.6.0",
        complexity: "O(1)",
        summary: "The server's clock, as seconds and microseconds.",
        group: "server",
    },
];

/// The command called `name`, whatever case the client spelled it in.
///
/// Linear over a table of this size, which is a handful of length compares
/// against a table that fits in one page and is in cache because the previous
/// command looked at it too. A hash would be a hash of the name plus a probe,
/// and the name is already in a register. The table grows to about 250 by M8,
/// at which point this becomes a perfect hash built at compile time, and the
/// signature does not change when it does.
#[must_use]
pub fn lookup(name: &[u8]) -> Option<&'static Spec> {
    COMMANDS
        .iter()
        .find(|c| c.name.len() == name.len() && c.name.as_bytes().eq_ignore_ascii_case(name))
}

/// Whether `n` arguments, counting the name, satisfy this command's arity.
#[must_use]
pub fn arity_ok(spec: &Spec, n: usize) -> bool {
    let n = n as i32;
    if spec.arity >= 0 {
        n == spec.arity
    } else {
        n >= -spec.arity
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn every_name_is_lower_case_and_appears_once() {
        let mut seen = std::collections::BTreeSet::new();
        for c in COMMANDS {
            assert_eq!(
                c.name,
                c.name.to_lowercase(),
                "{} is not lower case",
                c.name
            );
            assert!(seen.insert(c.name), "{} is in the table twice", c.name);
        }
    }

    #[test]
    fn lookup_ignores_case_and_does_not_match_a_prefix() {
        assert_eq!(lookup(b"GET").unwrap().name, "get");
        assert_eq!(lookup(b"gEt").unwrap().name, "get");
        assert!(lookup(b"ge").is_none());
        assert!(lookup(b"gets").is_none());
    }

    #[test]
    fn arity_counts_the_command_name() {
        let get = lookup(b"get").unwrap();
        assert!(!arity_ok(get, 1));
        assert!(arity_ok(get, 2));
        assert!(!arity_ok(get, 3));

        // A negative arity is a minimum, which is how SET takes its options.
        let set = lookup(b"set").unwrap();
        assert!(!arity_ok(set, 2));
        assert!(arity_ok(set, 3));
        assert!(arity_ok(set, 9));
    }

    /// A key spec that is wrong sends a cluster client to the wrong node, so
    /// the pair commands are worth stating twice.
    #[test]
    fn the_pair_commands_step_two_keys_at_a_time() {
        for name in [b"mset".as_slice(), b"msetnx"] {
            let c = lookup(name).unwrap();
            assert_eq!((c.first_key, c.last_key, c.step), (1, -1, 2));
        }
        let mget = lookup(b"mget").unwrap();
        assert_eq!((mget.first_key, mget.last_key, mget.step), (1, -1, 1));
        // MSETEX counts its keys in an argument, so there is no static spec
        // for them and a client has to ask with COMMAND GETKEYS.
        let msetex = lookup(b"msetex").unwrap();
        assert_eq!((msetex.first_key, msetex.last_key, msetex.step), (0, 0, 0));
        assert!(msetex.flags.contains(&"movablekeys"));
    }
}