Struct redis_driver::Client

pub struct Client { /* private fields */ }

Implementations

impl Client

pub async fn connect(config: impl IntoConfig) -> Result<Self>

Client with a unique connection to a Redis server

Errors

Any Redis driver Error that occurs during the connection operation

pub async fn send(&self, command: Command) -> Result<Value>

Send an arbitrary command to the server.

This is used primarily intended for implementing high level commands API but may also be used to provide access to new features that lack a direct API.

Arguments

• name - Command name in uppercase.
• args - Command arguments which can be provided as arrays (up to 4 elements) or vectors of BulkString.

Errors

Any Redis driver Error that occurs during the send operation

Example

use redis_driver::{resp::cmd, Client, Result};

#[tokio::main]
async fn main() -> Result<()> {
    let client = Client::connect("127.0.0.1:6379").await?;

   let values: Vec<String> = client
        .send(cmd("MGET").arg("key1").arg("key2").arg("key3").arg("key4"))
        .await?
        .into()?;
    println!("{:?}", values);

    Ok(())
}

pub fn send_and_forget(&self, command: Command) -> Result<()>

Send command and forget its response

Errors

Any Redis driver Error that occurs during the send operation

pub async fn create_transaction(
    &self
) -> Result<Transaction<TransactionResult0>>

Create a new transaction

Errors

Any Redis driver Error

Trait Implementations

impl BitmapCommands<ClientResult> for Client

fn bitcount<K>(&self, key: K, range: BitRange) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,

Count the number of set bits (population counting) in a string.

fn bitfield<K, C, E, O>(
    &self,
    key: K,
    sub_commands: C
) -> CommandResult<'_, T, Vec<u64>>where
    K: Into<BulkString>,
    E: Into<BulkString>,
    O: Into<BulkString>,
    C: ArgsOrCollection<BitFieldSubCommand<E, O>>,

The command treats a Redis string as an array of bits, and is capable of addressing specific integer fields of varying bit widths and arbitrary non (necessary) aligned offset.

fn bitfield_readonly<K, C, E, O>(
    &self,
    key: K,
    get_commands: C
) -> CommandResult<'_, T, Vec<u64>>where
    K: Into<BulkString>,
    E: Into<BulkString>,
    O: Into<BulkString>,
    C: ArgsOrCollection<BitFieldGetSubCommand<E, O>>,

Read-only variant of the BITFIELD command. It is like the original BITFIELD but only accepts GET subcommand and can safely be used in read-only replicas.

fn bitop<D, K, KK>(
    &self,
    operation: BitOperation,
    dest_key: D,
    keys: KK
) -> CommandResult<'_, T, usize>where
    D: Into<BulkString>,
    K: Into<BulkString>,
    KK: SingleArgOrCollection<K>,

Perform a bitwise operation between multiple keys (containing string values) and store the result in the destination key.

fn bitpos<K>(
    &self,
    key: K,
    bit: u64,
    range: BitRange
) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,

Perform a bitwise operation between multiple keys (containing string values) and store the result in the destination key.

fn getbit<K>(&self, key: K, offset: u64) -> CommandResult<'_, T, u64>where
    K: Into<BulkString>,

Returns the bit value at offset in the string value stored at key.

fn setbit<K>(&self, key: K, offset: u64, value: u64) -> CommandResult<'_, T, u64>where
    K: Into<BulkString>,

Sets or clears the bit at offset in the string value stored at key.

impl Clone for Client

fn clone(&self) -> Client

Returns a copy of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl ConnectionCommands<ClientResult> for Client

fn auth<U, P>(&self, username: Option<U>, password: P) -> CommandResult<'_, T, ()>where
    U: Into<BulkString>,
    P: Into<BulkString>,

Authenticates the current connection.

fn client_caching(
    &self,
    mode: ClientCachingMode
) -> CommandResult<'_, T, Option<()>>

This command controls the tracking of the keys in the next command executed by the connection, when tracking is enabled in OPTIN or OPTOUT mode.

fn client_getname<CN>(&self) -> CommandResult<'_, T, Option<CN>>where
    CN: FromValue,

Returns the name of the current connection as set by [CLIENT SETNAME].

fn client_getredir(&self) -> CommandResult<'_, T, i64>

This command returns the client ID we are redirecting our tracking notifications to.

fn client_id(&self) -> CommandResult<'_, T, i64>

The command just returns the ID of the current connection.

fn client_info(&self) -> CommandResult<'_, T, ClientInfo>

The command returns information and statistics about the current client connection in a mostly human readable format.

fn client_kill(&self, options: ClientKillOptions) -> CommandResult<'_, T, usize>

Closes a given clients connection based on a filter list

fn client_list(
    &self,
    options: ClientListOptions
) -> CommandResult<'_, T, ClientListResult>

Returns information and statistics about the client connections server in a mostly human readable format.

fn client_no_evict(&self, no_evict: bool) -> CommandResult<'_, T, ()>

sets the client eviction mode for the current connection.

fn client_pause(
    &self,
    timeout: u64,
    mode: ClientPauseMode
) -> CommandResult<'_, T, ()>

Connections control command able to suspend all the Redis clients for the specified amount of time (in milliseconds).

fn client_reply(&self, mode: ClientReplyMode) -> CommandResult<'_, T, ()>

Sometimes it can be useful for clients to completely disable replies from the Redis server.

fn client_setname<CN>(&self, connection_name: CN) -> CommandResult<'_, T, ()>where
    CN: Into<BulkString>,

Assigns a name to the current connection.

fn client_tracking(
    &self,
    status: ClientTrackingStatus,
    options: ClientTrackingOptions
) -> CommandResult<'_, T, ()>

This command enables the tracking feature of the Redis server, that is used for server assisted client side caching.

fn client_trackinginfo(&self) -> CommandResult<'_, T, ClientTrackingInfo>

This command enables the tracking feature of the Redis server, that is used for server assisted client side caching.

fn client_unblock(
    &self,
    client_id: i64,
    mode: ClientUnblockMode
) -> CommandResult<'_, T, bool>

This command can unblock, from a different connection, a client blocked in a blocking operation, such as for instance BRPOP or XREAD or WAIT.

fn client_unpause(&self) -> CommandResult<'_, T, bool>

Used to resume command processing for all clients that were paused by client_pause.

fn echo<M, R>(&self, message: M) -> CommandResult<'_, T, R>where
    M: Into<BulkString>,
    R: FromValue,

Returns message.

fn hello(&self, options: HelloOptions) -> CommandResult<'_, T, HelloResult>

Switch to a different protocol, optionally authenticating and setting the connection’s name, or provide a contextual client report.

fn ping<R>(&self, options: PingOptions) -> CommandResult<'_, T, R>where
    R: FromValue,

Returns PONG if no argument is provided, otherwise return a copy of the argument as a bulk.

fn quit(&self) -> CommandResult<'_, T, ()>

Ask the server to close the connection.

fn reset(&self) -> CommandResult<'_, T, ()>

This command performs a full reset of the connection’s server-side context, mimicking the effect of disconnecting and reconnecting again.

fn select(&self, index: usize) -> CommandResult<'_, T, ()>

Select the Redis logical database having the specified zero-based numeric index.

impl GenericCommands<ClientResult> for Client

fn copy<S, D>(
    &self,
    source: S,
    destination: D,
    destination_db: Option<usize>,
    replace: bool
) -> CommandResult<'_, T, bool>where
    S: Into<BulkString>,
    D: Into<BulkString>,

This command copies the value stored at the source key to the destination key.

fn del<K, C>(&self, keys: C) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,
    C: SingleArgOrCollection<K>,

Removes the specified keys. A key is ignored if it does not exist.

fn dump<K>(&self, key: K) -> CommandResult<'_, T, DumpResult>where
    K: Into<BulkString>,

Serialize the value stored at key in a Redis-specific format and return it to the user.

fn exists<K, C>(&self, keys: C) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,
    C: SingleArgOrCollection<K>,

Returns if keys exist.

fn expire<K>(
    &self,
    key: K,
    seconds: u64,
    option: ExpireOption
) -> CommandResult<'_, T, bool>where
    K: Into<BulkString>,

Set a timeout on key in seconds

fn expireat<K>(
    &self,
    key: K,
    unix_time_seconds: u64,
    option: ExpireOption
) -> CommandResult<'_, T, bool>where
    K: Into<BulkString>,

EXPIREAT has the same effect and semantic as EXPIRE, but instead of specifying the number of seconds representing the TTL (time to live), it takes an absolute Unix timestamp (seconds since January 1, 1970)

fn expiretime<K>(&self, key: K) -> CommandResult<'_, T, i64>where
    K: Into<BulkString>,

Returns the absolute Unix timestamp (since January 1, 1970) in seconds at which the given key will expire.

fn keys<P, K, A>(&self, pattern: P) -> CommandResult<'_, T, A>where
    P: Into<BulkString>,
    K: FromValue,
    A: FromSingleValueArray<K>,

Returns all keys matching pattern.

fn migrate<H, K>(
    &self,
    host: H,
    port: u16,
    key: K,
    destination_db: usize,
    timeout: u64,
    options: MigrateOptions
) -> CommandResult<'_, T, bool>where
    H: Into<BulkString>,
    K: Into<BulkString>,

Atomically transfer a key or a collection of keys from a source Redis instance to a destination Redis instance.

fn move_<K>(&self, key: K, db: usize) -> CommandResult<'_, T, i64>where
    K: Into<BulkString>,

Move key from the currently selected database to the specified destination database.

fn object_encoding<K, E>(&self, key: K) -> CommandResult<'_, T, E>where
    K: Into<BulkString>,
    E: FromValue,

Returns the internal encoding for the Redis object stored at key

fn object_freq<K>(&self, key: K) -> CommandResult<'_, T, i64>where
    K: Into<BulkString>,

This command returns the logarithmic access frequency counter of a Redis object stored at key.

fn object_idle_time<K>(&self, key: K) -> CommandResult<'_, T, i64>where
    K: Into<BulkString>,

This command returns the time in seconds since the last access to the value stored at key.

fn object_refcount<K>(&self, key: K) -> CommandResult<'_, T, i64>where
    K: Into<BulkString>,

This command returns the reference count of the stored at key.

fn persist<K>(&self, key: K) -> CommandResult<'_, T, bool>where
    K: Into<BulkString>,

Remove the existing timeout on key, turning the key from volatile (a key with an expire set) to persistent (a key that will never expire as no timeout is associated).

fn pexpire<K>(
    &self,
    key: K,
    milliseconds: u64,
    option: ExpireOption
) -> CommandResult<'_, T, bool>where
    K: Into<BulkString>,

This command works exactly like EXPIRE but the time to live of the key is specified in milliseconds instead of seconds.

fn pexpireat<K>(
    &self,
    key: K,
    unix_time_milliseconds: u64,
    option: ExpireOption
) -> CommandResult<'_, T, bool>where
    K: Into<BulkString>,

PEXPIREAT has the same effect and semantic as EXPIREAT, but the Unix time at which the key will expire is specified in milliseconds instead of seconds.

fn pexpiretime<K>(&self, key: K) -> CommandResult<'_, T, i64>where
    K: Into<BulkString>,

PEXPIRETIME has the same semantic as EXPIRETIME, but returns the absolute Unix expiration timestamp in milliseconds instead of seconds.

fn pttl<K>(&self, key: K) -> CommandResult<'_, T, i64>where
    K: Into<BulkString>,

Returns the remaining time to live of a key that has a timeout.

fn randomkey<R>(&self) -> CommandResult<'_, T, R>where
    R: FromValue,

Return a random key from the currently selected database.

fn rename<K1, K2>(&self, key: K1, new_key: K2) -> CommandResult<'_, T, ()>where
    K1: Into<BulkString>,
    K2: Into<BulkString>,

Renames key to newkey.

fn renamenx<K1, K2>(&self, key: K1, new_key: K2) -> CommandResult<'_, T, bool>where
    K1: Into<BulkString>,
    K2: Into<BulkString>,

Renames key to newkey if newkey does not yet exist. It returns an error when key does not exist.

fn restore<K>(
    &self,
    key: K,
    ttl: u64,
    serialized_value: Vec<u8>,
    options: RestoreOptions
) -> CommandResult<'_, T, ()>where
    K: Into<BulkString>,

Create a key associated with a value that is obtained by deserializing the provided serialized value (obtained via DUMP).

fn scan<K, A>(
    &self,
    cursor: u64,
    options: ScanOptions
) -> CommandResult<'_, T, (u64, A)>where
    K: FromValue,
    A: FromSingleValueArray<K>,

Iterates the set of keys in the currently selected Redis database.

fn sort<K, M, A>(&self, key: K, options: SortOptions) -> CommandResult<'_, T, A>where
    K: Into<BulkString>,
    M: FromValue,
    A: FromSingleValueArray<M>,

Returns the elements contained in the list, set or sorted set at key.

fn sort_and_store<K, D>(
    &self,
    key: K,
    destination: D,
    options: SortOptions
) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,
    D: Into<BulkString>,

Stores the elements contained in the list, set or sorted set at key.

fn sort_readonly<K, M, A>(
    &self,
    key: K,
    options: SortOptions
) -> CommandResult<'_, T, A>where
    K: Into<BulkString>,
    M: FromValue,
    A: FromSingleValueArray<M>,

Read-only variant of the SORT command.

fn touch<K, KK>(&self, keys: KK) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,
    KK: SingleArgOrCollection<K>,

Alters the last access time of a key(s). A key is ignored if it does not exist.

fn ttl<K>(&self, key: K) -> CommandResult<'_, T, i64>where
    K: Into<BulkString>,

Returns the remaining time to live of a key that has a timeout.

fn type_<K>(&self, key: K) -> CommandResult<'_, T, String>where
    K: Into<BulkString>,

Returns the string representation of the type of the value stored at key.

fn unlink<K, C>(&self, keys: C) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,
    C: SingleArgOrCollection<K>,

This command is very similar to DEL: it removes the specified keys.

fn wait(&self, num_replicas: usize, timeout: u64) -> CommandResult<'_, T, usize>

This command blocks the current client until all the previous write commands are successfully transferred and acknowledged by at least the specified number of replicas.

impl GeoCommands<ClientResult> for Client

fn geoadd<K, M, I>(
    &self,
    key: K,
    condition: GeoAddCondition,
    change: bool,
    items: I
) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,
    M: Into<BulkString>,
    I: ArgsOrCollection<(f64, f64, M)>,

Adds the specified geospatial items (longitude, latitude, name) to the specified key.

fn geodist<K, M>(
    &self,
    key: K,
    member1: M,
    member2: M,
    unit: GeoUnit
) -> CommandResult<'_, T, Option<f64>>where
    K: Into<BulkString>,
    M: Into<BulkString>,

Return the distance between two members in the geospatial index represented by the sorted set.

fn geohash<K, M, C>(
    &self,
    key: K,
    members: C
) -> CommandResult<'_, T, Vec<String>>where
    K: Into<BulkString>,
    M: Into<BulkString>,
    C: SingleArgOrCollection<M>,

Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using geoadd).

fn geopos<K, M, C>(
    &self,
    key: K,
    members: C
) -> CommandResult<'_, T, Vec<Option<(f64, f64)>>>where
    K: Into<BulkString>,
    M: Into<BulkString>,
    C: SingleArgOrCollection<M>,

Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.

fn geosearch<K, M1, M2, A>(
    &self,
    key: K,
    from: GeoSearchFrom<M1>,
    by: GeoSearchBy,
    options: GeoSearchOptions
) -> CommandResult<'_, T, A>where
    K: Into<BulkString>,
    M1: Into<BulkString>,
    M2: FromValue,
    A: FromSingleValueArray<GeoSearchResult<M2>>,

Return the members of a sorted set populated with geospatial information using geoadd, which are within the borders of the area specified by a given shape.

fn geosearchstore<D, S, M>(
    &self,
    destination: D,
    source: S,
    from: GeoSearchFrom<M>,
    by: GeoSearchBy,
    options: GeoSearchStoreOptions
) -> CommandResult<'_, T, usize>where
    D: Into<BulkString>,
    S: Into<BulkString>,
    M: Into<BulkString>,

This command is like geosearch, but stores the result in destination key.

impl HashCommands<ClientResult> for Client

fn hdel<K, F, C>(&self, key: K, fields: C) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,
    F: Into<BulkString>,
    C: SingleArgOrCollection<F>,

Removes the specified fields from the hash stored at key.

fn hexists<K, F>(&self, key: K, field: F) -> CommandResult<'_, T, bool>where
    K: Into<BulkString>,
    F: Into<BulkString>,

Returns if field is an existing field in the hash stored at key.

fn hget<K, F, V>(&self, key: K, field: F) -> CommandResult<'_, T, V>where
    K: Into<BulkString>,
    F: Into<BulkString>,
    V: FromValue,

Returns the value associated with field in the hash stored at key.

fn hgetall<K, F, V, A>(&self, key: K) -> CommandResult<'_, T, A>where
    K: Into<BulkString>,
    F: FromValue,
    V: FromValue,
    A: FromKeyValueValueArray<F, V>,

Returns all fields and values of the hash stored at key.

fn hincrby<K, F>(
    &self,
    key: K,
    field: F,
    increment: i64
) -> CommandResult<'_, T, i64>where
    K: Into<BulkString>,
    F: Into<BulkString>,

Increments the number stored at field in the hash stored at key by increment.

fn hincrbyfloat<K, F>(
    &self,
    key: K,
    field: F,
    increment: f64
) -> CommandResult<'_, T, f64>where
    K: Into<BulkString>,
    F: Into<BulkString>,

Increment the specified field of a hash stored at key, and representing a floating point number, by the specified increment.

fn hkeys<K, F, A>(&self, key: K) -> CommandResult<'_, T, A>where
    K: Into<BulkString>,
    F: FromValue,
    A: FromSingleValueArray<F>,

Returns all field names in the hash stored at key.

fn hlen<K>(&self, key: K) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,

Returns the number of fields contained in the hash stored at key.

fn hmget<K, F, V, C, A>(&self, key: K, fields: C) -> CommandResult<'_, T, A>where
    K: Into<BulkString>,
    F: Into<BulkString>,
    C: SingleArgOrCollection<F>,
    V: FromValue,
    A: FromSingleValueArray<V>,

Returns the values associated with the specified fields in the hash stored at key.

fn hrandfield<K, F>(&self, key: K) -> CommandResult<'_, T, F>where
    K: Into<BulkString>,
    F: FromValue,

return random fields from the hash value stored at key.

fn hrandfields<K, F, A>(&self, key: K, count: isize) -> CommandResult<'_, T, A>where
    K: Into<BulkString>,
    F: FromValue,
    A: FromSingleValueArray<F>,

return random fields from the hash value stored at key.

fn hrandfields_with_values<K, F, V, A>(
    &self,
    key: K,
    count: isize
) -> CommandResult<'_, T, A>where
    K: Into<BulkString>,
    F: FromValue,
    V: FromValue,
    A: FromKeyValueValueArray<F, V>,

return random fields from the hash value stored at key.

fn hscan<K, F, V>(
    &self,
    key: K,
    cursor: u64,
    options: HScanOptions
) -> CommandResult<'_, T, (u64, Vec<(F, V)>)>where
    K: Into<BulkString>,
    F: FromValue,
    V: FromValue,

Iterates fields of Hash types and their associated values.

fn hset<K, F, V, I>(&self, key: K, items: I) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,
    F: Into<BulkString>,
    V: Into<BulkString>,
    I: KeyValueArgOrCollection<F, V>,

Sets field in the hash stored at key to value.

fn hsetnx<K, F, V>(&self, key: K, field: F, value: V) -> CommandResult<'_, T, bool>where
    K: Into<BulkString>,
    F: Into<BulkString>,
    V: Into<BulkString>,

Sets field in the hash stored at key to value, only if field does not yet exist.

fn hstrlen<K, F>(&self, key: K, field: F) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,
    F: Into<BulkString>,

Returns the string length of the value associated with field in the hash stored at key.

fn hvals<K, V, A>(&self, key: K) -> CommandResult<'_, T, A>where
    K: Into<BulkString>,
    V: FromValue,
    A: FromSingleValueArray<V>,

list of values in the hash, or an empty list when key does not exist.

impl HyperLogLogCommands<ClientResult> for Client

fn pfadd<K, E, EE>(&self, key: K, elements: EE) -> CommandResult<'_, T, bool>where
    K: Into<BulkString>,
    E: Into<BulkString>,
    EE: SingleArgOrCollection<E>,

Adds the specified elements to the specified HyperLogLog.

fn pfcount<K, KK>(&self, keys: KK) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,
    KK: SingleArgOrCollection<K>,

Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).

fn pfmerge<D, S, SS>(
    &self,
    dest_key: D,
    source_keys: SS
) -> CommandResult<'_, T, ()>where
    D: Into<BulkString>,
    S: Into<BulkString>,
    SS: SingleArgOrCollection<S>,

Merge N different HyperLogLogs into a single one.

impl ListCommands<ClientResult> for Client

fn blmove<S, D, E>(
    &self,
    source: S,
    destination: D,
    where_from: LMoveWhere,
    where_to: LMoveWhere,
    timeout: f64
) -> CommandResult<'_, T, E>where
    S: Into<BulkString>,
    D: Into<BulkString>,
    E: FromValue,

This command is the blocking variant of lmove.

fn blmpop<K, E, C>(
    &self,
    timeout: f64,
    keys: C,
    where_: LMoveWhere,
    count: usize
) -> CommandResult<'_, T, Option<(String, Vec<E>)>>where
    K: Into<BulkString>,
    E: FromValue,
    C: SingleArgOrCollection<K>,

This command is the blocking variant of lmpop.

fn blpop<K, KK, K1, V>(
    &self,
    keys: KK,
    timeout: f64
) -> CommandResult<'_, T, Option<(K1, V)>>where
    K: Into<BulkString>,
    KK: SingleArgOrCollection<K>,
    K1: FromValue,
    V: FromValue,

This command is a blocking list pop primitive.

fn brpop<K, KK, K1, V>(
    &self,
    keys: KK,
    timeout: f64
) -> CommandResult<'_, T, Option<(K1, V)>>where
    K: Into<BulkString>,
    KK: SingleArgOrCollection<K>,
    K1: FromValue,
    V: FromValue,

This command is a blocking list pop primitive.

fn lindex<K, E>(&self, key: K, index: isize) -> CommandResult<'_, T, E>where
    K: Into<BulkString>,
    E: FromValue,

Returns the element at index index in the list stored at key.

fn linsert<K, E>(
    &self,
    key: K,
    where_: LInsertWhere,
    pivot: E,
    element: E
) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,
    E: Into<BulkString>,

Inserts element in the list stored at key either before or after the reference value pivot.

fn llen<K>(&self, key: K) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,

Inserts element in the list stored at key either before or after the reference value pivot.

fn lmove<S, D, E>(
    &self,
    source: S,
    destination: D,
    where_from: LMoveWhere,
    where_to: LMoveWhere
) -> CommandResult<'_, T, E>where
    S: Into<BulkString>,
    D: Into<BulkString>,
    E: FromValue,

Atomically returns and removes the first/last element (head/tail depending on the wherefrom argument) of the list stored at source, and pushes the element at the first/last element (head/tail depending on the whereto argument) of the list stored at destination.

fn lmpop<K, E, C>(
    &self,
    keys: C,
    where_: LMoveWhere,
    count: usize
) -> CommandResult<'_, T, (String, Vec<E>)>where
    K: Into<BulkString>,
    E: FromValue,
    C: SingleArgOrCollection<K>,

Pops one or more elements from the first non-empty list key from the list of provided key names.

fn lpop<K, E, A>(&self, key: K, count: usize) -> CommandResult<'_, T, A>where
    K: Into<BulkString>,
    E: FromValue,
    A: FromSingleValueArray<E>,

Removes and returns the first elements of the list stored at key.

fn lpos<K, E>(
    &self,
    key: K,
    element: E,
    rank: Option<usize>,
    max_len: Option<usize>
) -> CommandResult<'_, T, Option<usize>>where
    K: Into<BulkString>,
    E: Into<BulkString>,

Returns the index of matching elements inside a Redis list.

fn lpos_with_count<K, E, A>(
    &self,
    key: K,
    element: E,
    num_matches: usize,
    rank: Option<usize>,
    max_len: Option<usize>
) -> CommandResult<'_, T, A>where
    K: Into<BulkString>,
    E: Into<BulkString>,
    A: FromSingleValueArray<usize>,

Returns the index of matching elements inside a Redis list.

fn lpush<K, E, C>(&self, key: K, elements: C) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,
    E: Into<BulkString>,
    C: SingleArgOrCollection<E>,

Insert all the specified values at the head of the list stored at key

fn lpushx<K, E, C>(&self, key: K, elements: C) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,
    E: Into<BulkString>,
    C: SingleArgOrCollection<E>,

Inserts specified values at the head of the list stored at key, only if key already exists and holds a list.

fn lrange<K, E, A>(
    &self,
    key: K,
    start: isize,
    stop: isize
) -> CommandResult<'_, T, A>where
    K: Into<BulkString>,
    E: FromValue,
    A: FromSingleValueArray<E>,

Returns the specified elements of the list stored at key.

fn lrem<K, E>(
    &self,
    key: K,
    count: isize,
    element: E
) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,
    E: Into<BulkString>,

Removes the first count occurrences of elements equal to element from the list stored at key.

fn lset<K, E>(&self, key: K, index: isize, element: E) -> CommandResult<'_, T, ()>where
    K: Into<BulkString>,
    E: Into<BulkString>,

Sets the list element at index to element.

fn ltrim<K>(&self, key: K, start: isize, stop: isize) -> CommandResult<'_, T, ()>where
    K: Into<BulkString>,

Trim an existing list so that it will contain only the specified range of elements specified.

fn rpop<K, E, C>(&self, key: K, count: usize) -> CommandResult<'_, T, C>where
    K: Into<BulkString>,
    E: FromValue,
    C: FromSingleValueArray<E>,

Removes and returns the first elements of the list stored at key.

fn rpush<K, E, C>(&self, key: K, elements: C) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,
    E: Into<BulkString>,
    C: SingleArgOrCollection<E>,

Insert all the specified values at the tail of the list stored at key

fn rpushx<K, E, C>(&self, key: K, elements: C) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,
    E: Into<BulkString>,
    C: SingleArgOrCollection<E>,

Inserts specified values at the tail of the list stored at key, only if key already exists and holds a list.

impl PrepareCommand<ClientResult> for Client

fn prepare_command<R: FromValue>(
    &self,
    command: Command
) -> CommandResult<'_, ClientResult, R>

impl PubSubCommands<ClientResult> for Client

fn subscribe<'a, C, CC>(&'a self, channels: CC) -> Future<'a, PubSubStream>where
    C: Into<BulkString> + Send + 'a,
    CC: SingleArgOrCollection<C>,

Subscribes the client to the specified channels.

fn psubscribe<'a, P, PP>(&'a self, patterns: PP) -> Future<'a, PubSubStream>where
    P: Into<BulkString> + Send + 'a,
    PP: SingleArgOrCollection<P>,

Subscribes the client to the given patterns.

fn publish<C, M>(&self, channel: C, message: M) -> CommandResult<'_, T, usize>where
    C: Into<BulkString>,
    M: Into<BulkString>,

Posts a message to the given channel.

fn pub_sub_channels<C, CC>(
    &self,
    options: PubSubChannelsOptions
) -> CommandResult<'_, T, CC>where
    C: FromValue,
    CC: FromSingleValueArray<C>,

Lists the currently active channels.

fn pub_sub_numpat(&self) -> CommandResult<'_, T, usize>

Returns the number of unique patterns that are subscribed to by clients (that are performed using the PSUBSCRIBE command).

fn pub_sub_numsub<C, CC, R, RR>(&self, channels: CC) -> CommandResult<'_, T, RR>where
    C: Into<BulkString>,
    CC: SingleArgOrCollection<C>,
    R: FromValue,
    RR: FromKeyValueValueArray<R, usize>,

Returns the number of subscribers (exclusive of clients subscribed to patterns) for the specified channels.

impl ScriptingCommands<ClientResult> for Client

fn eval<R>(&self, builder: CallBuilder) -> CommandResult<'_, T, R>where
    R: FromValue,

Invoke the execution of a server-side Lua script.

fn eval_readonly<R>(&self, builder: CallBuilder) -> CommandResult<'_, T, R>where
    R: FromValue,

This is a read-only variant of the eval] command that cannot execute commands that modify data.

fn evalsha<R>(&self, builder: CallBuilder) -> CommandResult<'_, T, R>where
    R: FromValue,

Evaluate a script from the server’s cache by its SHA1 digest.

fn evalsha_readonly<R>(&self, builder: CallBuilder) -> CommandResult<'_, T, R>where
    R: FromValue,

This is a read-only variant of the evalsha command that cannot execute commands that modify data.

fn fcall<R>(&self, builder: CallBuilder) -> CommandResult<'_, T, R>where
    R: FromValue,

Invoke a function.

fn fcall_readonly<R>(&self, builder: CallBuilder) -> CommandResult<'_, T, R>where
    R: FromValue,

Invoke a function.

fn function_delete<L>(&self, library_name: L) -> CommandResult<'_, T, ()>where
    L: Into<BulkString>,

Delete a library and all its functions.

fn function_dump<P>(&self) -> CommandResult<'_, T, P>where
    P: FromValue,

Return the serialized payload of loaded libraries. You can restore the serialized payload later with the function_restore command.

fn function_flush(&self, flushing_mode: FlushingMode) -> CommandResult<'_, T, ()>

Deletes all the libraries.

fn function_kill(&self) -> CommandResult<'_, T, ()>

Kill a function that is currently executing.

fn function_list(
    &self,
    options: FunctionListOptions
) -> CommandResult<'_, T, Vec<LibraryInfo>>

Return information about the functions and libraries.

fn function_load<F, L>(
    &self,
    replace: bool,
    function_code: F
) -> CommandResult<'_, T, L>where
    F: Into<BulkString>,
    L: FromValue,

Load a library to Redis.

fn function_restore<P>(
    &self,
    serialized_payload: P,
    policy: FunctionRestorePolicy
) -> CommandResult<'_, T, ()>where
    P: Into<BulkString>,

Restore libraries from the serialized payload.

fn function_stats(&self) -> CommandResult<'_, T, FunctionStats>

Return information about the function that’s currently running and information about the available execution engines.

fn script_debug(&self, debug_mode: ScriptDebugMode) -> CommandResult<'_, T, ()>

Set the debug mode for subsequent scripts executed with EVAL.

fn script_exists<S, C>(&self, sha1s: C) -> CommandResult<'_, T, Vec<bool>>where
    S: Into<BulkString>,
    C: SingleArgOrCollection<S>,

Returns information about the existence of the scripts in the script cache.

fn script_flush(&self, flushing_mode: FlushingMode) -> CommandResult<'_, T, ()>

Flush the Lua scripts cache.

fn script_kill(&self) -> CommandResult<'_, T, ()>

Kills the currently executing EVAL script, assuming no write operation was yet performed by the script.

fn script_load<S, V>(&self, script: S) -> CommandResult<'_, T, V>where
    S: Into<BulkString>,
    V: FromValue,

Load a script into the scripts cache, without executing it.

impl SentinelCommands<ClientResult> for Client

fn sentinel_get_master_addr_by_name<N>(
    &self,
    master_name: N
) -> CommandResult<'_, T, Option<(String, u16)>>where
    N: Into<BulkString>,

Return the ip and port number of the master with that name.

fn sentinel_failover<N>(&self, master_name: N) -> CommandResult<'_, T, ()>where
    N: Into<BulkString>,

Force a failover as if the master was not reachable, and without asking for agreement to other Sentinels (however a new version of the configuration will be published so that the other Sentinels will update their configurations).

impl ServerCommands<ClientResult> for Client

fn monitor(&self) -> Future<'_, MonitorStream>

Debugging command that streams back every command processed by the Redis server.

fn acl_cat<C, CC>(&self, options: AclCatOptions) -> CommandResult<'_, T, CC>where
    C: FromValue,
    CC: FromSingleValueArray<C>,

The command shows the available ACL categories if called without arguments. If a category name is given, the command shows all the Redis commands in the specified category.

fn acl_deluser<U, UU>(&self, usernames: UU) -> CommandResult<'_, T, usize>where
    U: Into<BulkString>,
    UU: SingleArgOrCollection<U>,

Delete all the specified ACL users and terminate all the connections that are authenticated with such users.

fn acl_dryrun<U, C, R>(
    &self,
    username: U,
    command: C,
    options: AclDryRunOptions
) -> CommandResult<'_, T, R>where
    U: Into<BulkString>,
    C: Into<BulkString>,
    R: FromValue,

Simulate the execution of a given command by a given user.

fn acl_genpass<R: FromValue>(
    &self,
    options: AclGenPassOptions
) -> CommandResult<'_, T, R>

Generates a password starting from /dev/urandom if available, otherwise (in systems without /dev/urandom) it uses a weaker system that is likely still better than picking a weak password by hand.

fn acl_getuser<U, RR>(&self, username: U) -> CommandResult<'_, T, RR>where
    U: Into<BulkString>,
    RR: FromKeyValueValueArray<String, Value>,

The command returns all the rules defined for an existing ACL user.

fn acl_list(&self) -> CommandResult<'_, T, Vec<String>>

The command shows the currently active ACL rules in the Redis server.

fn acl_load(&self) -> CommandResult<'_, T, ()>

When Redis is configured to use an ACL file (with the aclfile configuration option), this command will reload the ACLs from the file, replacing all the current ACL rules with the ones defined in the file.

fn acl_log<EE>(&self, options: AclLogOptions) -> CommandResult<'_, T, Vec<EE>>where
    EE: FromKeyValueValueArray<String, Value>,

The command shows a list of recent ACL security events

fn acl_save(&self) -> CommandResult<'_, T, ()>

When Redis is configured to use an ACL file (with the aclfile configuration option), this command will save the currently defined ACLs from the server memory to the ACL file.

fn acl_setuser<U, R, RR>(
    &self,
    username: U,
    rules: RR
) -> CommandResult<'_, T, ()>where
    U: Into<BulkString>,
    R: Into<BulkString>,
    RR: SingleArgOrCollection<R>,

Create an ACL user with the specified rules or modify the rules of an existing user.

fn acl_users<U, UU>(&self) -> CommandResult<'_, T, UU>where
    U: FromValue,
    UU: FromSingleValueArray<U>,

The command shows a list of all the usernames of the currently configured users in the Redis ACL system.

fn acl_whoami<U: FromValue>(&self) -> CommandResult<'_, T, U>

Return the username the current connection is authenticated with.

fn command(&self) -> CommandResult<'_, T, Vec<CommandInfo>>

Return an array with details about every Redis command.

fn command_count(&self) -> CommandResult<'_, T, usize>

Number of total commands in this Redis server.

fn command_docs<N, NN, DD>(&self, command_names: NN) -> CommandResult<'_, T, DD>where
    N: Into<BulkString>,
    NN: SingleArgOrCollection<N>,
    DD: FromKeyValueValueArray<String, CommandDoc>,

Number of total commands in this Redis server.

fn command_getkeys<A, AA, KK>(&self, args: AA) -> CommandResult<'_, T, KK>where
    A: Into<BulkString>,
    AA: SingleArgOrCollection<A>,
    KK: FromSingleValueArray<String>,

A helper command to let you find the keys from a full Redis command.

fn command_getkeysandflags<A, AA, KK>(
    &self,
    args: AA
) -> CommandResult<'_, T, KK>where
    A: Into<BulkString>,
    AA: SingleArgOrCollection<A>,
    KK: FromKeyValueValueArray<String, Vec<String>>,

A helper command to let you find the keys from a full Redis command together with flags indicating what each key is used for.

fn command_info<N, NN>(
    &self,
    command_names: NN
) -> CommandResult<'_, T, Vec<CommandInfo>>where
    N: Into<BulkString>,
    NN: SingleArgOrCollection<N>,

Return an array with details about multiple Redis command.

fn command_list<CC>(
    &self,
    options: CommandListOptions
) -> CommandResult<'_, T, CC>where
    CC: FromSingleValueArray<String>,

Return an array of the server’s command names based on optional filters

fn config_get<P, PP, V, VV>(&self, params: PP) -> CommandResult<'_, T, VV>where
    P: Into<BulkString>,
    PP: SingleArgOrCollection<P>,
    V: FromValue,
    VV: FromKeyValueValueArray<String, V>,

Used to read the configuration parameters of a running Redis server.

fn config_resetstat(&self) -> CommandResult<'_, T, ()>

Resets the statistics reported by Redis using the info command.

fn config_rewrite(&self) -> CommandResult<'_, T, ()>

Rewrites the redis.conf file the server was started with, applying the minimal changes needed to make it reflect the configuration currently used by the server, which may be different compared to the original one because of the use of the config_set command.

fn config_set<P, V, C>(&self, configs: C) -> CommandResult<'_, T, ()>where
    P: Into<BulkString>,
    V: Into<BulkString>,
    C: KeyValueArgOrCollection<P, V>,

Used in order to reconfigure the server at run time without the need to restart Redis.

fn dbsize(&self) -> CommandResult<'_, T, usize>

Return the number of keys in the currently-selected database.

fn failover(&self, options: FailOverOptions) -> CommandResult<'_, T, ()>

This command will start a coordinated failover between the currently-connected-to master and one of its replicas.

fn flushdb(&self, flushing_mode: FlushingMode) -> CommandResult<'_, T, ()>

Delete all the keys of the currently selected DB.

fn flushall(&self, flushing_mode: FlushingMode) -> CommandResult<'_, T, ()>

Delete all the keys of all the existing databases, not just the currently selected one.

fn info<SS>(&self, sections: SS) -> CommandResult<'_, T, String>where
    SS: SingleArgOrCollection<InfoSection>,

This command returns information and statistics about the server in a format that is simple to parse by computers and easy to read by humans.

fn lastsave(&self) -> CommandResult<'_, T, u64>

Return the UNIX TIME of the last DB save executed with success.

fn latency_doctor(&self) -> CommandResult<'_, T, String>

This command reports about different latency-related issues and advises about possible remedies.

fn latency_graph(
    &self,
    event: LatencyHistoryEvent
) -> CommandResult<'_, T, String>

Produces an ASCII-art style graph for the specified event.

fn latency_histogram<C, CC, RR>(&self, commands: CC) -> CommandResult<'_, T, RR>where
    C: Into<BulkString>,
    CC: SingleArgOrCollection<C>,
    RR: FromKeyValueValueArray<String, CommandHistogram>,

This command reports a cumulative distribution of latencies in the format of a histogram for each of the specified command names.

fn latency_history<RR>(
    &self,
    event: LatencyHistoryEvent
) -> CommandResult<'_, T, RR>where
    RR: FromSingleValueArray<(u32, u32)>,

This command returns the raw data of the event’s latency spikes time series.

fn latency_latest<RR>(&self) -> CommandResult<'_, T, RR>where
    RR: FromSingleValueArray<(String, u32, u32, u32)>,

This command reports the latest latency events logged.

fn latency_reset<EE>(&self, events: EE) -> CommandResult<'_, T, usize>where
    EE: SingleArgOrCollection<LatencyHistoryEvent>,

This command resets the latency spikes time series of all, or only some, events.

fn lolwut(&self, options: LolWutOptions) -> CommandResult<'_, T, String>

The LOLWUT command displays the Redis version: however as a side effect of doing so, it also creates a piece of generative computer art that is different with each version of Redis.

fn memory_doctor(&self) -> CommandResult<'_, T, String>

This command reports about different memory-related issues that the Redis server experiences, and advises about possible remedies.

fn memory_malloc_stats(&self) -> CommandResult<'_, T, String>

This command provides an internal statistics report from the memory allocator.

fn memory_purge(&self) -> CommandResult<'_, T, ()>

This command attempts to purge dirty pages so these can be reclaimed by the allocator.

fn memory_stats(&self) -> CommandResult<'_, T, MemoryStats>

This command returns information about the memory usage of the server.

fn memory_usage<K>(
    &self,
    key: K,
    options: MemoryUsageOptions
) -> CommandResult<'_, T, Option<usize>>where
    K: Into<BulkString>,

This command reports the number of bytes that a key and its value require to be stored in RAM.

fn module_list<MM>(&self) -> CommandResult<'_, T, MM>where
    MM: FromSingleValueArray<ModuleInfo>,

Returns information about the modules loaded to the server.

fn module_load<P>(
    &self,
    path: P,
    options: ModuleLoadOptions
) -> CommandResult<'_, T, ()>where
    P: Into<BulkString>,

Loads a module from a dynamic library at runtime.

fn module_unload<N>(&self, name: N) -> CommandResult<'_, T, ()>where
    N: Into<BulkString>,

Unloads a module.

fn replicaof(&self, options: ReplicaOfOptions) -> CommandResult<'_, T, ()>

This command can change the replication settings of a replica on the fly.

fn role(&self) -> CommandResult<'_, T, RoleResult>

Provide information on the role of a Redis instance in the context of replication, by returning if the instance is currently a master, slave, or sentinel.

fn save(&self) -> CommandResult<'_, T, ()>

This command performs a synchronous save of the dataset producing a point in time snapshot of all the data inside the Redis instance, in the form of an RDB file.

fn shutdown(&self, options: ShutdownOptions) -> CommandResult<'_, T, ()>

Shutdown the server

fn slowlog_get(
    &self,
    options: SlowLogOptions
) -> CommandResult<'_, T, Vec<SlowLogEntry>>

This command returns entries from the slow log in chronological order.

fn slowlog_len(&self) -> CommandResult<'_, T, usize>

This command returns the current number of entries in the slow log.

fn slowlog_reset(&self) -> CommandResult<'_, T, ()>

This command resets the slow log, clearing all entries in it.

fn swapdb(&self, index1: usize, index2: usize) -> CommandResult<'_, T, ()>

This command swaps two Redis databases, so that immediately all the clients connected to a given database will see the data of the other database, and the other way around.

fn time(&self) -> CommandResult<'_, T, (u32, u32)>

The TIME command returns the current server time as a two items lists: a Unix timestamp and the amount of microseconds already elapsed in the current second.

impl SetCommands<ClientResult> for Client

fn sadd<K, M, C>(&self, key: K, members: C) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,
    M: Into<BulkString>,
    C: SingleArgOrCollection<M>,

Add the specified members to the set stored at key.

fn scard<K>(&self, key: K) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,

Returns the set cardinality (number of elements) of the set stored at key.

fn sdiff<K, M, C, A>(&self, keys: C) -> CommandResult<'_, T, A>where
    K: Into<BulkString>,
    M: FromValue + Eq + Hash,
    C: SingleArgOrCollection<K>,
    A: FromSingleValueArray<M>,

Returns the members of the set resulting from the difference between the first set and all the successive sets.

fn sdiffstore<D, K, C>(
    &self,
    destination: D,
    keys: C
) -> CommandResult<'_, T, usize>where
    D: Into<BulkString>,
    K: Into<BulkString>,
    C: SingleArgOrCollection<K>,

This command is equal to sdiff, but instead of returning the resulting set, it is stored in destination.

fn sinter<K, M, C, A>(&self, keys: C) -> CommandResult<'_, T, A>where
    K: Into<BulkString>,
    M: FromValue + Eq + Hash,
    C: SingleArgOrCollection<K>,
    A: FromSingleValueArray<M>,

Returns the members of the set resulting from the intersection of all the given sets.

fn sintercard<K, C>(&self, keys: C, limit: usize) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,
    C: SingleArgOrCollection<K>,

This command is similar to sinter, but instead of returning the result set, it returns just the cardinality of the result.

fn sinterstore<D, K, C>(
    &self,
    destination: D,
    keys: C
) -> CommandResult<'_, T, usize>where
    D: Into<BulkString>,
    K: Into<BulkString>,
    C: SingleArgOrCollection<K>,

This command is equal to sinter, but instead of returning the resulting set, it is stored in destination.

fn sismember<K, M>(&self, key: K, member: M) -> CommandResult<'_, T, bool>where
    K: Into<BulkString>,
    M: Into<BulkString>,

Returns if member is a member of the set stored at key.

fn smembers<K, M, A>(&self, key: K) -> CommandResult<'_, T, A>where
    K: Into<BulkString>,
    M: FromValue + Eq + Hash,
    A: FromSingleValueArray<M>,

Returns all the members of the set value stored at key.

fn smismember<K, M, C>(
    &self,
    key: K,
    members: C
) -> CommandResult<'_, T, Vec<bool>>where
    K: Into<BulkString>,
    M: Into<BulkString>,
    C: SingleArgOrCollection<M>,

Returns whether each member is a member of the set stored at key.

fn smove<S, D, M>(
    &self,
    source: S,
    destination: D,
    member: M
) -> CommandResult<'_, T, bool>where
    S: Into<BulkString>,
    D: Into<BulkString>,
    M: Into<BulkString>,

Move member from the set at source to the set at destination.

fn spop<K, M, A>(&self, key: K, count: usize) -> CommandResult<'_, T, A>where
    K: Into<BulkString>,
    M: FromValue + Eq + Hash,
    A: FromSingleValueArray<M>,

Removes and returns one or more random members from the set value store at key.

fn srandmember<K, M, A>(&self, key: K, count: usize) -> CommandResult<'_, T, A>where
    K: Into<BulkString>,
    M: FromValue + Eq + Hash,
    A: FromSingleValueArray<M>,

Removes and returns one or more random members from the set value store at key.

fn srem<K, M, C>(&self, key: K, members: C) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,
    M: Into<BulkString>,
    C: SingleArgOrCollection<M>,

Remove the specified members from the set stored at key.

fn sscan<K, M>(
    &self,
    key: K,
    cursor: u64,
    options: SScanOptions
) -> CommandResult<'_, T, (u64, Vec<M>)>where
    K: Into<BulkString>,
    M: FromValue,

Iterates elements of Sets types.

fn sunion<K, M, C, A>(&self, keys: C) -> CommandResult<'_, T, A>where
    K: Into<BulkString>,
    M: FromValue + Eq + Hash,
    C: SingleArgOrCollection<K>,
    A: FromSingleValueArray<M>,

Returns the members of the set resulting from the union of all the given sets.

fn sunionstore<D, K, C>(
    &self,
    destination: D,
    keys: C
) -> CommandResult<'_, T, usize>where
    D: Into<BulkString>,
    K: Into<BulkString>,
    C: SingleArgOrCollection<K>,

This command is equal to sunion, but instead of returning the resulting set, it is stored in destination.

impl SortedSetCommands<ClientResult> for Client

fn bzmpop<K, C, E>(
    &self,
    timeout: f64,
    keys: C,
    where_: ZWhere,
    count: usize
) -> CommandResult<'_, T, Option<ZMPopResult<E>>>where
    K: Into<BulkString>,
    C: SingleArgOrCollection<K>,
    E: FromValue,

This command is the blocking variant of zmpop.

fn bzpopmax<K, KK, E, K1>(
    &self,
    keys: KK,
    timeout: f64
) -> CommandResult<'_, T, Option<Vec<(K1, E, f64)>>>where
    K: Into<BulkString>,
    KK: SingleArgOrCollection<K>,
    K1: FromValue,
    E: FromValue,

This command is the blocking variant of zpopmax.

fn bzpopmin<K, KK, E, K1>(
    &self,
    keys: KK,
    timeout: f64
) -> CommandResult<'_, T, Option<Vec<(K1, E, f64)>>>where
    K: Into<BulkString>,
    KK: SingleArgOrCollection<K>,
    K1: FromValue,
    E: FromValue,

This command is the blocking variant of zpopmin.

fn zadd<K, M, I>(
    &self,
    key: K,
    items: I,
    options: ZAddOptions
) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,
    M: Into<BulkString>,
    I: ArgsOrCollection<(f64, M)>,

Adds all the specified members with the specified scores to the sorted set stored at key.

fn zadd_incr<K, M>(
    &self,
    key: K,
    condition: ZAddCondition,
    comparison: ZAddComparison,
    change: bool,
    score: f64,
    member: M
) -> CommandResult<'_, T, Option<f64>>where
    K: Into<BulkString>,
    M: Into<BulkString>,

In this mode ZADD acts like ZINCRBY. Only one score-element pair can be specified in this mode.

fn zcard<K>(&self, key: K) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,

Returns the sorted set cardinality (number of elements) of the sorted set stored at key.

fn zcount<K, M1, M2>(
    &self,
    key: K,
    min: M1,
    max: M2
) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,
    M1: Into<BulkString>,
    M2: Into<BulkString>,

Returns the number of elements in the sorted set at key with a score between min and max.

fn zdiff<K, C, E>(&self, keys: C) -> CommandResult<'_, T, Vec<E>>where
    K: Into<BulkString>,
    C: SingleArgOrCollection<K>,
    E: FromValue,

This command is similar to zdiffstore, but instead of storing the resulting sorted set, it is returned to the client.

fn zdiff_with_scores<K, C, E>(
    &self,
    keys: C
) -> CommandResult<'_, T, Vec<(E, f64)>>where
    K: Into<BulkString>,
    C: SingleArgOrCollection<K>,
    E: FromValue,

This command is similar to zdiffstore, but instead of storing the resulting sorted set, it is returned to the client.

fn zdiffstore<D, K, C>(
    &self,
    destination: D,
    keys: C
) -> CommandResult<'_, T, usize>where
    D: Into<BulkString>,
    K: Into<BulkString>,
    C: SingleArgOrCollection<K>,

Computes the difference between the first and all successive input sorted sets and stores the result in destination.

fn zincrby<K, M>(
    &self,
    key: K,
    increment: f64,
    member: M
) -> CommandResult<'_, T, f64>where
    K: Into<BulkString>,
    M: Into<BulkString>,

Increments the score of member in the sorted set stored at key by increment.

fn zinter<K, C, W, E>(
    &self,
    keys: C,
    weights: Option<W>,
    aggregate: ZAggregate
) -> CommandResult<'_, T, Vec<E>>where
    K: Into<BulkString>,
    C: SingleArgOrCollection<K>,
    W: SingleArgOrCollection<f64>,
    E: FromValue,

This command is similar to zinterstore, but instead of storing the resulting sorted set, it is returned to the client.

fn zinter_with_scores<K, C, W, E>(
    &self,
    keys: C,
    weights: Option<W>,
    aggregate: ZAggregate
) -> CommandResult<'_, T, Vec<(E, f64)>>where
    K: Into<BulkString>,
    C: SingleArgOrCollection<K>,
    W: SingleArgOrCollection<f64>,
    E: FromValue,

This command is similar to zinterstore, but instead of storing the resulting sorted set, it is returned to the client.

fn zintercard<K, C>(&self, keys: C, limit: usize) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,
    C: SingleArgOrCollection<K>,

This command is similar to zinter, but instead of returning the result set, it returns just the cardinality of the result.

fn zinterstore<D, K, C, W>(
    &self,
    destination: D,
    keys: C,
    weights: Option<W>,
    aggregate: ZAggregate
) -> CommandResult<'_, T, usize>where
    D: Into<BulkString>,
    K: Into<BulkString>,
    C: SingleArgOrCollection<K>,
    W: SingleArgOrCollection<f64>,

Computes the intersection of numkeys sorted sets given by the specified keys, and stores the result in destination.

fn zlexcount<K, M1, M2>(
    &self,
    key: K,
    min: M1,
    max: M2
) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,
    M1: Into<BulkString>,
    M2: Into<BulkString>,

When all the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering, this command returns the number of elements in the sorted set at key with a value between min and max.

fn zmpop<K, C, E>(
    &self,
    keys: C,
    where_: ZWhere,
    count: usize
) -> CommandResult<'_, T, Option<ZMPopResult<E>>>where
    K: Into<BulkString>,
    C: SingleArgOrCollection<K>,
    E: FromValue,

Pops one or more elements, that are member-score pairs, from the first non-empty sorted set in the provided list of key names.

fn zmscore<K, M, C>(
    &self,
    key: K,
    members: C
) -> CommandResult<'_, T, Vec<Option<f64>>>where
    K: Into<BulkString>,
    M: Into<BulkString>,
    C: SingleArgOrCollection<M>,

Returns the scores associated with the specified members in the sorted set stored at key.

fn zpopmax<K, M>(
    &self,
    key: K,
    count: usize
) -> CommandResult<'_, T, Vec<(M, f64)>>where
    K: Into<BulkString>,
    M: FromValue,

Removes and returns up to count members with the highest scores in the sorted set stored at key.

fn zpopmin<K, M>(
    &self,
    key: K,
    count: usize
) -> CommandResult<'_, T, Vec<(M, f64)>>where
    K: Into<BulkString>,
    M: FromValue,

Removes and returns up to count members with the lowest scores in the sorted set stored at key.

fn zrandmember<K, E>(&self, key: K) -> CommandResult<'_, T, E>where
    K: Into<BulkString>,
    E: FromValue,

Return a random element from the sorted set value stored at key.

fn zrandmembers<K, E>(&self, key: K, count: isize) -> CommandResult<'_, T, Vec<E>>where
    K: Into<BulkString>,
    E: FromValue,

Return random elements from the sorted set value stored at key.

fn zrandmembers_with_scores<K, E>(
    &self,
    key: K,
    count: isize
) -> CommandResult<'_, T, Vec<E>>where
    K: Into<BulkString>,
    E: FromValue,

Return random elements with their scores from the sorted set value stored at key.

fn zrange<K, S, E>(
    &self,
    key: K,
    start: S,
    stop: S,
    options: ZRangeOptions
) -> CommandResult<'_, T, Vec<E>>where
    K: Into<BulkString>,
    S: Into<BulkString>,
    E: FromValue,

Returns the specified range of elements in the sorted set stored at key.

fn zrange_with_scores<K, S, E>(
    &self,
    key: K,
    start: S,
    stop: S,
    options: ZRangeOptions
) -> CommandResult<'_, T, Vec<(E, f64)>>where
    K: Into<BulkString>,
    S: Into<BulkString>,
    E: FromValue,

Returns the specified range of elements in the sorted set stored at key.

fn zrangestore<D, S, SS>(
    &self,
    dst: D,
    src: S,
    start: SS,
    stop: SS,
    options: ZRangeOptions
) -> CommandResult<'_, T, usize>where
    D: Into<BulkString>,
    S: Into<BulkString>,
    SS: Into<BulkString>,

This command is like zrange, but stores the result in the dst destination key.

fn zrank<K, M>(&self, key: K, member: M) -> CommandResult<'_, T, Option<usize>>where
    K: Into<BulkString>,
    M: Into<BulkString>,

Returns the rank of member in the sorted set stored at key, with the scores ordered from low to high.

fn zrem<K, M, C>(&self, key: K, members: C) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,
    M: Into<BulkString>,
    C: SingleArgOrCollection<M>,

Removes the specified members from the sorted set stored at key.

fn zremrangebylex<K, S>(
    &self,
    key: K,
    start: S,
    stop: S
) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,
    S: Into<BulkString>,

When all the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering, this command removes all elements in the sorted set stored at key between the lexicographical range specified by min and max.

fn zremrangebyrank<K>(
    &self,
    key: K,
    start: isize,
    stop: isize
) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,

Removes all elements in the sorted set stored at key with rank between start and stop.

fn zremrangebyscore<K, S>(
    &self,
    key: K,
    start: S,
    stop: S
) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,
    S: Into<BulkString>,

Removes all elements in the sorted set stored at key with a score between min and max (inclusive).

fn zrevrank<K, M>(&self, key: K, member: M) -> CommandResult<'_, T, Option<usize>>where
    K: Into<BulkString>,
    M: Into<BulkString>,

Returns the rank of member in the sorted set stored at key, with the scores ordered from high to low.

fn zscan<K, M>(
    &self,
    key: K,
    cursor: usize,
    options: ZScanOptions
) -> CommandResult<'_, T, (u64, Vec<(M, f64)>)>where
    K: Into<BulkString>,
    M: FromValue,

Iterates elements of Sorted Set types and their associated scores.

fn zscore<K, M>(&self, key: K, member: M) -> CommandResult<'_, T, Option<f64>>where
    K: Into<BulkString>,
    M: Into<BulkString>,

Returns the score of member in the sorted set at key.

fn zunion<K, C, W, E>(
    &self,
    keys: C,
    weights: Option<W>,
    aggregate: ZAggregate
) -> CommandResult<'_, T, Vec<E>>where
    K: Into<BulkString>,
    C: SingleArgOrCollection<K>,
    W: SingleArgOrCollection<f64>,
    E: FromValue,

This command is similar to zunionstore, but instead of storing the resulting sorted set, it is returned to the client.

fn zunion_with_scores<K, C, W, E>(
    &self,
    keys: C,
    weights: Option<W>,
    aggregate: ZAggregate
) -> CommandResult<'_, T, Vec<(E, f64)>>where
    K: Into<BulkString>,
    C: SingleArgOrCollection<K>,
    W: SingleArgOrCollection<f64>,
    E: FromValue,

This command is similar to zunionstore, but instead of storing the resulting sorted set, it is returned to the client.

fn zunionstore<D, K, C, W>(
    &self,
    destination: D,
    keys: C,
    weights: Option<W>,
    aggregate: ZAggregate
) -> CommandResult<'_, T, usize>where
    D: Into<BulkString>,
    K: Into<BulkString>,
    C: SingleArgOrCollection<K>,
    W: SingleArgOrCollection<f64>,

Computes the unionsection of numkeys sorted sets given by the specified keys, and stores the result in destination.

impl StreamCommands<ClientResult> for Client

fn xack<K, G, I, II>(
    &self,
    key: K,
    group: G,
    ids: II
) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,
    G: Into<BulkString>,
    I: Into<BulkString>,
    II: SingleArgOrCollection<I>,

The XACK command removes one or multiple messages from the Pending Entries List (PEL) of a stream consumer group

fn xadd<K, I, F, V, FFVV, R>(
    &self,
    key: K,
    stream_id: I,
    items: FFVV,
    options: XAddOptions
) -> CommandResult<'_, T, R>where
    K: Into<BulkString>,
    I: Into<BulkString>,
    F: Into<BulkString>,
    V: Into<BulkString>,
    FFVV: KeyValueArgOrCollection<F, V>,
    R: FromValue,

Appends the specified stream entry to the stream at the specified key.

fn xautoclaim<K, G, C, I, V>(
    &self,
    key: K,
    group: G,
    consumer: C,
    min_idle_time: u64,
    start: I,
    options: XAutoClaimOptions
) -> CommandResult<'_, T, XAutoClaimResult<V>>where
    K: Into<BulkString>,
    G: Into<BulkString>,
    C: Into<BulkString>,
    I: Into<BulkString>,
    V: FromValue,

This command transfers ownership of pending stream entries that match the specified criteria.

fn xclaim<K, G, C, I, II, V>(
    &self,
    key: K,
    group: G,
    consumer: C,
    min_idle_time: u64,
    ids: II,
    options: XClaimOptions
) -> CommandResult<'_, T, Vec<StreamEntry<V>>>where
    K: Into<BulkString>,
    G: Into<BulkString>,
    C: Into<BulkString>,
    I: Into<BulkString>,
    II: SingleArgOrCollection<I>,
    V: FromValue,

In the context of a stream consumer group, this command changes the ownership of a pending message, so that the new owner is the consumer specified as the command argument.

fn xdel<K, I, II>(&self, key: K, ids: II) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,
    I: Into<BulkString>,
    II: SingleArgOrCollection<I>,

Removes the specified entries from a stream, and returns the number of entries deleted.

fn xgroup_create<K, G, I>(
    &self,
    key: K,
    groupname: G,
    id: I,
    options: XGroupCreateOptions
) -> CommandResult<'_, T, bool>where
    K: Into<BulkString>,
    G: Into<BulkString>,
    I: Into<BulkString>,

This command creates a new consumer group uniquely identified by for the stream stored at .

fn xgroup_createconsumer<K, G, C>(
    &self,
    key: K,
    groupname: G,
    consumername: C
) -> CommandResult<'_, T, bool>where
    K: Into<BulkString>,
    G: Into<BulkString>,
    C: Into<BulkString>,

Create a consumer named consumername in the consumer group groupname`` of the stream that's stored at key.

fn xgroup_delconsumer<K, G, C>(
    &self,
    key: K,
    groupname: G,
    consumername: C
) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,
    G: Into<BulkString>,
    C: Into<BulkString>,

The XGROUP DELCONSUMER command deletes a consumer from the consumer group.

fn xgroup_destroy<K, G>(&self, key: K, groupname: G) -> CommandResult<'_, T, bool>where
    K: Into<BulkString>,
    G: Into<BulkString>,

The XGROUP DESTROY command completely destroys a consumer group.

fn xgroup_setid<K, G, I>(
    &self,
    key: K,
    groupname: G,
    id: I,
    entries_read: Option<usize>
) -> CommandResult<'_, T, ()>where
    K: Into<BulkString>,
    G: Into<BulkString>,
    I: Into<BulkString>,

Set the last delivered ID for a consumer group.

fn xinfo_consumers<K, G>(
    &self,
    key: K,
    groupname: G
) -> CommandResult<'_, T, Vec<XConsumerInfo>>where
    K: Into<BulkString>,
    G: Into<BulkString>,

This command returns the list of consumers that belong to the groupname consumer group of the stream stored at key.

fn xinfo_groups<K>(&self, key: K) -> CommandResult<'_, T, Vec<XGroupInfo>>where
    K: Into<BulkString>,

This command returns the list of consumers that belong to the groupname consumer group of the stream stored at key.

fn xinfo_stream<K>(
    &self,
    key: K,
    options: XInfoStreamOptions
) -> CommandResult<'_, T, XStreamInfo>where
    K: Into<BulkString>,

This command returns information about the stream stored at key.

fn xlen<K>(&self, key: K) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,

Returns the number of entries inside a stream.

fn xpending<K, G>(&self, key: K, group: G) -> CommandResult<'_, T, XPendingResult>where
    K: Into<BulkString>,
    G: Into<BulkString>,

The XPENDING command is the interface to inspect the list of pending messages.

fn xpending_with_options<K, G>(
    &self,
    key: K,
    group: G,
    options: XPendingOptions
) -> CommandResult<'_, T, Vec<XPendingMessageResult>>where
    K: Into<BulkString>,
    G: Into<BulkString>,

The XPENDING command is the interface to inspect the list of pending messages.

fn xrange<K, S, E, V>(
    &self,
    key: K,
    start: S,
    end: E,
    count: Option<usize>
) -> CommandResult<'_, T, Vec<StreamEntry<V>>>where
    K: Into<BulkString>,
    S: Into<BulkString>,
    E: Into<BulkString>,
    V: FromValue,

The command returns the stream entries matching a given range of IDs.

fn xread<K, KK, I, II, V>(
    &self,
    options: XReadOptions,
    keys: KK,
    ids: II
) -> CommandResult<'_, T, Vec<XReadStreamResult<V>>>where
    K: Into<BulkString>,
    KK: SingleArgOrCollection<K>,
    I: Into<BulkString>,
    II: SingleArgOrCollection<I>,
    V: FromValue,

Read data from one or multiple streams, only returning entries with an ID greater than the last received ID reported by the caller.

fn xreadgroup<G, C, K, KK, I, II, V>(
    &self,
    group: G,
    consumer: C,
    options: XReadGroupOptions,
    keys: KK,
    ids: II
) -> CommandResult<'_, T, Vec<XReadStreamResult<V>>>where
    G: Into<BulkString>,
    C: Into<BulkString>,
    K: Into<BulkString>,
    KK: SingleArgOrCollection<K>,
    I: Into<BulkString>,
    II: SingleArgOrCollection<I>,
    V: FromValue,

The XREADGROUP command is a special version of the xread command with support for consumer groups.

fn xrevrange<K, E, S, V>(
    &self,
    key: K,
    end: E,
    start: S,
    count: Option<usize>
) -> CommandResult<'_, T, Vec<StreamEntry<V>>>where
    K: Into<BulkString>,
    E: Into<BulkString>,
    S: Into<BulkString>,
    V: FromValue,

This command is exactly like xrange, but with the notable difference of returning the entries in reverse order, and also taking the start-end range in reverse order

fn xtrim<K>(&self, key: K, options: XTrimOptions) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,

XTRIM trims the stream by evicting older entries (entries with lower IDs) if needed.

impl StringCommands<ClientResult> for Client

fn append<K, V>(&self, key: K, value: V) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,
    V: Into<BulkString>,

If key already exists and is a string, this command appends the value at the end of the string. If key does not exist it is created and set as an empty string, so APPEND will be similar to SET in this special case.

fn decr<K>(&self, key: K) -> CommandResult<'_, T, i64>where
    K: Into<BulkString>,

Decrements the number stored at key by one.

fn decrby<K>(&self, key: K, decrement: i64) -> CommandResult<'_, T, i64>where
    K: Into<BulkString>,

Decrements the number stored at key by one.

fn get<K, V>(&self, key: K) -> CommandResult<'_, T, V>where
    K: Into<BulkString>,
    V: FromValue,
    Self: Sized,

Get the value of key.

fn getdel<K, V>(&self, key: K) -> CommandResult<'_, T, V>where
    K: Into<BulkString>,
    V: FromValue,

Get the value of key and delete the key.

fn getex<K, V>(&self, key: K, options: GetExOptions) -> CommandResult<'_, T, V>where
    K: Into<BulkString>,
    V: FromValue,

Get the value of key and optionally set its expiration. GETEX is similar to GET, but is a write command with additional options.

fn getrange<K, V>(
    &self,
    key: K,
    start: usize,
    end: isize
) -> CommandResult<'_, T, V>where
    K: Into<BulkString>,
    V: FromValue,

Returns the substring of the string value stored at key, determined by the offsets start and end (both are inclusive).

fn getset<K, V, R>(&self, key: K, value: V) -> CommandResult<'_, T, R>where
    K: Into<BulkString>,
    V: Into<BulkString>,
    R: FromValue,

Atomically sets key to value and returns the old value stored at key. Returns an error when key exists but does not hold a string value. Any previous time to live associated with the key is discarded on successful SET operation.

fn incr<K>(&self, key: K) -> CommandResult<'_, T, i64>where
    K: Into<BulkString>,

Increments the number stored at key by one.

fn incrby<K>(&self, key: K, increment: i64) -> CommandResult<'_, T, i64>where
    K: Into<BulkString>,

Increments the number stored at key by increment.

fn incrbyfloat<K>(&self, key: K, increment: f64) -> CommandResult<'_, T, f64>where
    K: Into<BulkString>,

Increment the string representing a floating point number stored at key by the specified increment. By using a negative increment value, the result is that the value stored at the key is decremented (by the obvious properties of addition). If the key does not exist, it is set to 0 before performing the operation. An error is returned if one of the following conditions occur:

fn lcs<K, V>(&self, key1: K, key2: K) -> CommandResult<'_, T, V>where
    K: Into<BulkString>,
    V: FromValue,

The LCS command implements the longest common subsequence algorithm

fn lcs_len<K>(&self, key1: K, key2: K) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,

The LCS command implements the longest common subsequence algorithm

fn lcs_idx<K>(
    &self,
    key1: K,
    key2: K,
    min_match_len: Option<usize>,
    with_match_len: bool
) -> CommandResult<'_, T, LcsResult>where
    K: Into<BulkString>,

The LCS command implements the longest common subsequence algorithm

fn mget<K, V, C>(&self, keys: C) -> CommandResult<'_, T, Vec<Option<V>>>where
    K: Into<BulkString>,
    V: FromValue,
    C: SingleArgOrCollection<K>,

Returns the values of all specified keys.

fn mset<K, V, C>(&self, items: C) -> CommandResult<'_, T, ()>where
    C: KeyValueArgOrCollection<K, V>,
    K: Into<BulkString>,
    V: Into<BulkString>,

Sets the given keys to their respective values.

fn msetnx<K, V, C>(&self, items: C) -> CommandResult<'_, T, bool>where
    C: KeyValueArgOrCollection<K, V>,
    K: Into<BulkString>,
    V: Into<BulkString>,

Sets the given keys to their respective values. MSETNX will not perform any operation at all even if just a single key already exists.

fn psetex<K, V>(
    &self,
    key: K,
    milliseconds: u64,
    value: V
) -> CommandResult<'_, T, ()>where
    K: Into<BulkString>,
    V: Into<BulkString>,

Works exactly like setex with the sole difference that the expire time is specified in milliseconds instead of seconds.

fn set<K, V>(&self, key: K, value: V) -> CommandResult<'_, T, ()>where
    K: Into<BulkString>,
    V: Into<BulkString>,
    Self: Sized,

Set key to hold the string value.

fn set_with_options<K, V>(
    &self,
    key: K,
    value: V,
    condition: SetCondition,
    expiration: SetExpiration,
    keep_ttl: bool
) -> CommandResult<'_, T, bool>where
    K: Into<BulkString>,
    V: Into<BulkString>,

Set key to hold the string value.

fn set_get_with_options<K, V1, V2>(
    &self,
    key: K,
    value: V1,
    condition: SetCondition,
    expiration: SetExpiration,
    keep_ttl: bool
) -> CommandResult<'_, T, V2>where
    K: Into<BulkString>,
    V1: Into<BulkString>,
    V2: FromValue,

Set key to hold the string value wit GET option enforced

fn setex<K, V>(&self, key: K, seconds: u64, value: V) -> CommandResult<'_, T, ()>where
    K: Into<BulkString>,
    V: Into<BulkString>,

Set key to hold the string value and set key to timeout after a given number of seconds.

fn setnx<K, V>(&self, key: K, value: V) -> CommandResult<'_, T, bool>where
    K: Into<BulkString>,
    V: Into<BulkString>,

Set key to hold string value if key does not exist.

fn setrange<K, V>(
    &self,
    key: K,
    offset: usize,
    value: V
) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,
    V: Into<BulkString>,

Overwrites part of the string stored at key, starting at the specified offset, for the entire length of value.

fn strlen<K>(&self, key: K) -> CommandResult<'_, T, usize>where
    K: Into<BulkString>,

Returns the length of the string value stored at key.

impl TransactionCommands<ClientResult> for Client

fn watch<K, KK>(&self, keys: KK) -> CommandResult<'_, T, ()>where
    K: Into<BulkString>,
    KK: SingleArgOrCollection<K>,

Marks the given keys to be watched for conditional execution of a transaction.

fn unwatch(&self) -> CommandResult<'_, T, ()>

Flushes all the previously watched keys for a transaction.