Struct rustis::client::Client

pub struct Client { /* private fields */ }

Client with a unique connection to a Redis server.

Implementations

impl Client

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

Connects asynchronously to the Redis server.

Errors

Any Redis driver Error that occurs during the connection operation

pub async fn close(self) -> Result<()>

if this client is the last client on the shared connection, the channel to send messages to the underlying network handler will be closed explicitely.

Then, this function will await for the network handler to be ended

pub fn on_reconnect(&self) -> Receiver<()>

Used to receive notifications when the client reconnects to the Redis server.

To turn this receiver into a Stream, you can use the BroadcastStream wrapper.

pub fn get_client_state(&self) -> RwLockReadGuard<'_, ClientState>

Give an immutable generic access to attach any state to a client instance

pub fn get_client_state_mut(&self) -> RwLockWriteGuard<'_, ClientState>

Give a mutable generic access to attach any state to a client instance

pub async fn send( &self, command: Command, retry_on_error: Option<bool> ) -> Result<RespBuf>

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

• command - generic Command meant to be sent to the Redis server.
• retry_on_error - retry to send the command on network error.
  • None - default behaviour defined in Config::retry_on_error
  • Some(true) - retry sending command on network error
  • Some(false) - do not retry sending command on network error

Errors

Any Redis driver Error that occurs during the send operation

Example

use rustis::{client::Client, resp::cmd, Result};

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

    client
        .send(
            cmd("MSET")
                .arg("key1")
                .arg("value1")
                .arg("key2")
                .arg("value2")
                 .arg("key3")
                .arg("value3")
                .arg("key4")
                .arg("value4"),
            None,
        )
        .await?
        .to::<()>()?;

    let values: Vec<String> = client
        .send(
            cmd("MGET").arg("key1").arg("key2").arg("key3").arg("key4"),
            None,
        )
        .await?
        .to()?;

    assert_eq!(vec!["value1".to_owned(), "value2".to_owned(), "value3".to_owned(), "value4".to_owned()], values);

    Ok(())
}

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

Send command to the Redis server and forget its response.

Arguments

• command - generic Command meant to be sent to the Redis server.
• retry_on_error - retry to send the command on network error.
  • None - default behaviour defined in Config::retry_on_error
  • Some(true) - retry sending command on network error
  • Some(false) - do not retry sending command on network error

Errors

Any Redis driver Error that occurs during the send operation

pub async fn send_batch( &self, commands: Vec<Command>, retry_on_error: Option<bool> ) -> Result<Vec<RespBuf>>

Send a batch of commands to the Redis server.

Arguments

• commands - batch of generic Commands meant to be sent to the Redis server.
• retry_on_error - retry to send the command batch on network error.
  • None - default behaviour defined in Config::retry_on_error
  • Some(true) - retry sending batch on network error
  • Some(false) - do not retry sending batch on network error

Errors

Any Redis driver Error that occurs during the send operation

pub fn create_transaction(&self) -> Transaction

Create a new transaction

pub fn create_pipeline(&self) -> Pipeline<'_>

Create a new pipeline

pub fn create_pub_sub(&self) -> PubSubStream

Create a new pub sub stream with no upfront subscription

pub fn create_client_tracking_invalidation_stream( &self ) -> Result<impl Stream<Item = Vec<String>>>

Trait Implementations

impl<'a> BitmapCommands<'a> for &'a Client

fn bitcount<K>( self, key: K, range: BitRange ) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg,

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

fn bitfield<K, C, E, O>( self, key: K, sub_commands: C ) -> PreparedCommand<'a, Self, Vec<u64>>

where Self: Sized, K: SingleArg, E: SingleArg, O: SingleArg, C: MultipleArgsCollection<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 ) -> PreparedCommand<'a, Self, Vec<u64>>

where Self: Sized, K: SingleArg, E: SingleArg, O: SingleArg, C: MultipleArgsCollection<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 ) -> PreparedCommand<'a, Self, usize>

where Self: Sized, D: SingleArg, K: SingleArg, KK: SingleArgCollection<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 ) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg,

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) -> PreparedCommand<'a, Self, u64>

where Self: Sized, K: SingleArg,

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

fn setbit<K>( self, key: K, offset: u64, value: u64 ) -> PreparedCommand<'a, Self, u64>

where Self: Sized, K: SingleArg,

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

impl<'a> BlockingCommands<'a> for &'a Client

async fn monitor(self) -> Result<MonitorStream>

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

fn blmove<S, D, E>( self, source: S, destination: D, where_from: LMoveWhere, where_to: LMoveWhere, timeout: f64 ) -> PreparedCommand<'a, Self, E>

where Self: Sized, S: SingleArg, D: SingleArg, E: PrimitiveResponse,

This command is the blocking variant of lmove.

fn blmpop<K, KK, E>( self, timeout: f64, keys: KK, where_: LMoveWhere, count: usize ) -> PreparedCommand<'a, Self, Option<(String, Vec<E>)>>

where Self: Sized, K: SingleArg, KK: SingleArgCollection<K>, E: PrimitiveResponse + DeserializeOwned,

This command is the blocking variant of lmpop.

fn blpop<K, KK, K1, V>( self, keys: KK, timeout: f64 ) -> PreparedCommand<'a, Self, Option<(K1, V)>>

where Self: Sized, K: SingleArg, KK: SingleArgCollection<K>, K1: PrimitiveResponse + DeserializeOwned, V: PrimitiveResponse + DeserializeOwned,

This command is a blocking list pop primitive.

fn brpop<K, KK, K1, V>( self, keys: KK, timeout: f64 ) -> PreparedCommand<'a, Self, Option<(K1, V)>>

where Self: Sized, K: SingleArg, KK: SingleArgCollection<K>, K1: PrimitiveResponse + DeserializeOwned, V: PrimitiveResponse + DeserializeOwned,

This command is a blocking list pop primitive.

fn bzmpop<K, KK, E>( self, timeout: f64, keys: KK, where_: ZWhere, count: usize ) -> PreparedCommand<'a, Self, Option<ZMPopResult<E>>>

where Self: Sized, K: SingleArg, KK: SingleArgCollection<K>, E: PrimitiveResponse + DeserializeOwned,

This command is the blocking variant of zmpop.

fn bzpopmax<K, KK, E, K1>( self, keys: KK, timeout: f64 ) -> PreparedCommand<'a, Self, BZpopMinMaxResult<K1, E>>

where Self: Sized, K: SingleArg, KK: SingleArgCollection<K>, K1: PrimitiveResponse + DeserializeOwned, E: PrimitiveResponse + DeserializeOwned,

This command is the blocking variant of zpopmax.

fn bzpopmin<K, KK, E, K1>( self, keys: KK, timeout: f64 ) -> PreparedCommand<'a, Self, BZpopMinMaxResult<K1, E>>

where Self: Sized, K: SingleArg, KK: SingleArgCollection<K>, K1: PrimitiveResponse + DeserializeOwned, E: PrimitiveResponse + DeserializeOwned,

This command is the blocking variant of zpopmin.

impl<'a> BloomCommands<'a> for &'a Client

Available on crate feature redis-bloom only.

fn bf_add( self, key: impl SingleArg, item: impl SingleArg ) -> PreparedCommand<'a, Self, bool>

where Self: Sized,

Adds an item to a bloom filter

fn bf_exists( self, key: impl SingleArg, item: impl SingleArg ) -> PreparedCommand<'a, Self, bool>

where Self: Sized,

Determines whether an item may exist in the Bloom Filter or not.

fn bf_info_all( self, key: impl SingleArg ) -> PreparedCommand<'a, Self, BfInfoResult>

where Self: Sized,

Return information about key filter.

fn bf_info( self, key: impl SingleArg, param: BfInfoParameter ) -> PreparedCommand<'a, Self, usize>

where Self: Sized,

Return information about key filter for a specific information parameter

fn bf_insert<I: SingleArg, R: CollectionResponse<bool>>( self, key: impl SingleArg, items: impl SingleArgCollection<I>, options: BfInsertOptions ) -> PreparedCommand<'a, Self, R>

where Self: Sized,

bf_insert is a sugarcoated combination of bf_reserve and bf_add.

fn bf_loadchunk( self, key: impl SingleArg, iterator: i64, data: impl SingleArg ) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

Restores a filter previously saved using bf_scandump.

fn bf_madd<I: SingleArg, R: CollectionResponse<bool>>( self, key: impl SingleArg, items: impl SingleArgCollection<I> ) -> PreparedCommand<'a, Self, R>

where Self: Sized,

Adds one or more items to the Bloom Filter and creates the filter if it does not exist yet.

fn bf_mexists<I: SingleArg, R: CollectionResponse<bool>>( self, key: impl SingleArg, items: impl SingleArgCollection<I> ) -> PreparedCommand<'a, Self, R>

where Self: Sized,

Determines if one or more items may exist in the filter or not.

fn bf_reserve( self, key: impl SingleArg, error_rate: f64, capacity: usize, options: BfReserveOptions ) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

Creates an empty Bloom Filter with a single sub-filter for the initial capacity requested and with an upper bound error_rate.

fn bf_scandump( self, key: impl SingleArg, iterator: i64 ) -> PreparedCommand<'a, Self, BfScanDumpResult>

where Self: Sized,

Begins an incremental save of the bloom filter. This is useful for large bloom filters which cannot fit into the normal dump and restore model.

impl Clone for Client

fn clone(&self) -> Client

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> ClusterCommands<'a> for &'a Client

fn asking(self) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

When a cluster client receives an -ASK redirect, the ASKING command is sent to the target node followed by the command which was redirected. This is normally done automatically by cluster clients.

fn cluster_addslots<S>(self, slots: S) -> PreparedCommand<'a, Self, ()>

where Self: Sized, S: SingleArgCollection<u16>,

This command is useful in order to modify a node’s view of the cluster configuration.

fn cluster_addslotsrange<S>(self, slots: S) -> PreparedCommand<'a, Self, ()>

where Self: Sized, S: KeyValueArgsCollection<u16, u16>,

This command is similar to the cluster_addslots command in that they both assign hash slots to nodes.

fn cluster_bumpepoch(self) -> PreparedCommand<'a, Self, ClusterBumpEpochResult>

where Self: Sized,

Advances the cluster config epoch.

fn cluster_count_failure_reports<I>( self, node_id: I ) -> PreparedCommand<'a, Self, usize>

where Self: Sized, I: SingleArg,

The command returns the number of failure reports for the specified node.

fn cluster_countkeysinslot( self, slot: usize ) -> PreparedCommand<'a, Self, usize>

where Self: Sized,

Returns the number of keys in the specified Redis Cluster hash slot.

fn cluster_delslots<S>(self, slots: S) -> PreparedCommand<'a, Self, ()>

where Self: Sized, S: SingleArgCollection<u16>,

In Redis Cluster, each node keeps track of which master is serving a particular hash slot. This command asks a particular Redis Cluster node to forget which master is serving the hash slots specified as arguments.

fn cluster_delslotsrange<S>(self, slots: S) -> PreparedCommand<'a, Self, ()>

where Self: Sized, S: KeyValueArgsCollection<u16, u16>,

This command is similar to the cluster_delslotsrange command in that they both remove hash slots from the node.

fn cluster_failover( self, option: ClusterFailoverOption ) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

This command, that can only be sent to a Redis Cluster replica node, forces the replica to start a manual failover of its master instance.

fn cluster_flushslots(self) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

Deletes all slots from a node.

fn cluster_forget<I>(self, node_id: I) -> PreparedCommand<'a, Self, ()>

where Self: Sized, I: SingleArg,

The command is used in order to remove a node, specified via its node ID, from the set of known nodes of the Redis Cluster node receiving the command. In other words the specified node is removed from the nodes table of the node receiving the command.

fn cluster_getkeysinslot( self, slot: u16, count: usize ) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

The command returns an array of keys names stored in the contacted node and hashing to the specified hash slot.

fn cluster_info( self, slot: u16, count: usize ) -> PreparedCommand<'a, Self, ClusterInfo>

where Self: Sized,

This command provides info style information about Redis Cluster vital parameters.

fn cluster_keyslot<K>(self, key: K) -> PreparedCommand<'a, Self, u16>

where Self: Sized, K: SingleArg,

Returns an integer identifying the hash slot the specified key hashes to.

fn cluster_links<I>(self) -> PreparedCommand<'a, Self, Vec<I>>

where Self: Sized, I: CollectionResponse<ClusterLinkInfo> + DeserializeOwned,

Each node in a Redis Cluster maintains a pair of long-lived TCP link with each peer in the cluster:

fn cluster_meet<IP>( self, ip: IP, port: u16, cluster_bus_port: Option<u16> ) -> PreparedCommand<'a, Self, ()>

where Self: Sized, IP: SingleArg,

This command is used in order to connect different Redis nodes with cluster support enabled, into a working cluster.

fn cluster_myid<N>(self) -> PreparedCommand<'a, Self, N>

where Self: Sized, N: PrimitiveResponse,

This command returns the unique, auto-generated identifier that is associated with the connected cluster node.

fn cluster_nodes<R>(self) -> PreparedCommand<'a, Self, R>

where Self: Sized, R: PrimitiveResponse,

Each node in a Redis Cluster has its view of the current cluster configuration, given by the set of known nodes, the state of the connection we have with such nodes, their flags, properties and assigned slots, and so forth.

fn cluster_replicas<I, R>(self, node_id: I) -> PreparedCommand<'a, Self, R>

where Self: Sized, I: SingleArg, R: PrimitiveResponse,

The command provides a list of replica nodes replicating from the specified master node.

fn cluster_replicate<I>(self, node_id: I) -> PreparedCommand<'a, Self, ()>

where Self: Sized, I: SingleArg,

The command reconfigures a node as a replica of the specified master. If the node receiving the command is an empty master, as a side effect of the command, the node role is changed from master to replica.

fn cluster_reset( self, reset_type: ClusterResetType ) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

Reset a Redis Cluster node, in a more or less drastic way depending on the reset type, that can be hard or soft.

fn cluster_saveconfig(self) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

Forces a node to save the nodes.conf configuration on disk. Before to return the command calls fsync(2) in order to make sure the configuration is flushed on the computer disk.

fn cluster_set_config_epoch( self, config_epoch: u64 ) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

This command sets a specific config epoch in a fresh node.

fn cluster_setslot( self, slot: u16, subcommand: ClusterSetSlotSubCommand ) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

This command is responsible of changing the state of a hash slot in the receiving node in different ways.

fn cluster_shards<S>(self) -> PreparedCommand<'a, Self, S>

where Self: Sized, S: CollectionResponse<ClusterShardResult>,

This command returns details about the shards of the cluster.

fn cluster_slots<S>(self) -> PreparedCommand<'a, Self, S>

where Self: Sized, S: CollectionResponse<LegacyClusterShardResult>,

This command returns details details about which cluster slots map to which Redis instances.

fn readonly(self) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

Enables read queries for a connection to a Redis Cluster replica node.

fn readwrite(self) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

Disables read queries for a connection to a Redis Cluster replica node.

impl<'a> ConnectionCommands<'a> for &'a Client

fn auth<U, P>( self, username: Option<U>, password: P ) -> PreparedCommand<'a, Self, ()>

where Self: Sized, U: SingleArg, P: SingleArg,

Authenticates the current connection.

fn client_caching( self, mode: ClientCachingMode ) -> PreparedCommand<'a, Self, Option<()>>

where Self: Sized,

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) -> PreparedCommand<'a, Self, Option<CN>>

where Self: Sized, CN: PrimitiveResponse + DeserializeOwned,

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

fn client_getredir(self) -> PreparedCommand<'a, Self, i64>

where Self: Sized,

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

fn client_id(self) -> PreparedCommand<'a, Self, i64>

where Self: Sized,

The command just returns the ID of the current connection.

fn client_info(self) -> PreparedCommand<'a, Self, ClientInfo>

where Self: Sized,

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

fn client_kill( self, options: ClientKillOptions ) -> PreparedCommand<'a, Self, usize>

where Self: Sized,

Closes a given clients connection based on a filter list

fn client_list( self, options: ClientListOptions ) -> PreparedCommand<'a, Self, ClientListResult>

where Self: Sized,

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

fn client_no_evict(self, no_evict: bool) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

sets the client eviction mode for the current connection.

fn client_pause( self, timeout: u64, mode: ClientPauseMode ) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

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

fn client_reply(self, mode: ClientReplyMode) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

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

fn client_setname<CN>( self, connection_name: CN ) -> PreparedCommand<'a, Self, ()>

where Self: Sized, CN: SingleArg,

Assigns a name to the current connection.

fn client_tracking( self, status: ClientTrackingStatus, options: ClientTrackingOptions ) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

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

fn client_trackinginfo(self) -> PreparedCommand<'a, Self, ClientTrackingInfo>

where Self: Sized,

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 ) -> PreparedCommand<'a, Self, bool>

where Self: Sized,

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) -> PreparedCommand<'a, Self, bool>

where Self: Sized,

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

fn echo<M, R>(self, message: M) -> PreparedCommand<'a, Self, R>

where Self: Sized, M: SingleArg, R: PrimitiveResponse,

Returns message.

fn hello(self, options: HelloOptions) -> PreparedCommand<'a, Self, HelloResult>

where Self: Sized,

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) -> PreparedCommand<'a, Self, R>

where Self: Sized, R: PrimitiveResponse,

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

fn quit(self) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

Ask the server to close the connection.

fn reset(self) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

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) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

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

impl<'a> CountMinSketchCommands<'a> for &'a Client

Available on crate feature redis-bloom only.

fn cms_incrby<I: SingleArg, R: CollectionResponse<usize>>( self, key: impl SingleArg, items: impl KeyValueArgsCollection<I, usize> ) -> PreparedCommand<'a, Self, R>

where Self: Sized,

Increases the count of item by increment.

fn cms_info( self, key: impl SingleArg ) -> PreparedCommand<'a, Self, CmsInfoResult>

where Self: Sized,

Returns width, depth and total count of the sketch.

fn cms_initbydim( self, key: impl SingleArg, width: usize, depth: usize ) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

Initializes a Count-Min Sketch to dimensions specified by user.

fn cms_initbyprob( self, key: impl SingleArg, error: f64, probability: f64 ) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

Initializes a Count-Min Sketch to accommodate requested tolerances.

fn cms_merge<S: SingleArg, W: SingleArgCollection<usize>>( self, destination: impl SingleArg, sources: impl SingleArgCollection<S>, weights: Option<W> ) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

Returns the count for one or more items in a sketch.

fn cms_query<I: SingleArg, C: CollectionResponse<usize>>( self, key: impl SingleArg, items: impl SingleArgCollection<I> ) -> PreparedCommand<'a, Self, C>

where Self: Sized,

Merges several sketches into one sketch.

impl<'a> CuckooCommands<'a> for &'a Client

Available on crate feature redis-bloom only.

fn cf_add( self, key: impl SingleArg, item: impl SingleArg ) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

Adds an item to the cuckoo filter, creating the filter if it does not exist.

fn cf_addnx( self, key: impl SingleArg, item: impl SingleArg ) -> PreparedCommand<'a, Self, bool>

where Self: Sized,

Adds an item to a cuckoo filter if the item did not exist previously.

fn cf_count( self, key: impl SingleArg, item: impl SingleArg ) -> PreparedCommand<'a, Self, usize>

where Self: Sized,

Returns the number of times an item may be in the filter.

fn cf_del( self, key: impl SingleArg, item: impl SingleArg ) -> PreparedCommand<'a, Self, bool>

where Self: Sized,

Deletes an item once from the filter.

fn cf_exists( self, key: impl SingleArg, item: impl SingleArg ) -> PreparedCommand<'a, Self, bool>

where Self: Sized,

Check if an item exists in a Cuckoo Filter key

fn cf_info(self, key: impl SingleArg) -> PreparedCommand<'a, Self, CfInfoResult>

where Self: Sized,

Return information about key

fn cf_insert<I: SingleArg>( self, key: impl SingleArg, options: CfInsertOptions, item: impl SingleArgCollection<I> ) -> PreparedCommand<'a, Self, Vec<usize>>

where Self: Sized,

Adds one or more items to a cuckoo filter, allowing the filter to be created with a custom capacity if it does not exist yet.

fn cf_insertnx<I: SingleArg, R: CollectionResponse<i64>>( self, key: impl SingleArg, options: CfInsertOptions, item: impl SingleArgCollection<I> ) -> PreparedCommand<'a, Self, R>

where Self: Sized,

Adds one or more items to a cuckoo filter, allowing the filter to be created with a custom capacity if it does not exist yet.

fn cf_loadchunk( self, key: impl SingleArg, iterator: i64, data: impl SingleArg ) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

Restores a filter previously saved using cf_scandump.

fn cf_mexists<I: SingleArg, R: CollectionResponse<bool>>( self, key: impl SingleArg, items: impl SingleArgCollection<I> ) -> PreparedCommand<'a, Self, R>

where Self: Sized,

Check if one or more items exists in a Cuckoo Filter key

fn cf_reserve( self, key: impl SingleArg, capacity: usize, options: CfReserveOptions ) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

Create a Cuckoo Filter as key with a single sub-filter for the initial amount of capacity for items. Because of how Cuckoo Filters work, the filter is likely to declare itself full before capacity is reached and therefore fill rate will likely never reach 100%. The fill rate can be improved by using a larger bucketsize at the cost of a higher error rate. When the filter self-declare itself full, it will auto-expand by generating additional sub-filters at the cost of reduced performance and increased error rate. The new sub-filter is created with size of the previous sub-filter multiplied by expansion. Like bucket size, additional sub-filters grow the error rate linearly. The size of the new sub-filter is the size of the last sub-filter multiplied by expansion.

fn cf_scandump( self, key: impl SingleArg, iterator: i64 ) -> PreparedCommand<'a, Self, CfScanDumpResult>

where Self: Sized,

Begins an incremental save of the cuckoo filter. This is useful for large cuckoo filters which cannot fit into the normal dump and restore model.

impl Drop for Client

fn drop(&mut self)

if this client is the last client on the shared connection, the channel to send messages to the underlying network handler will be closed explicitely

impl<'a> GenericCommands<'a> for &'a Client

fn copy<S, D>( self, source: S, destination: D, destination_db: Option<usize>, replace: bool ) -> PreparedCommand<'a, Self, bool>

where Self: Sized, S: SingleArg, D: SingleArg,

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

fn del<K, C>(self, keys: C) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg, C: SingleArgCollection<K>,

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

fn dump<K>(self, key: K) -> PreparedCommand<'a, Self, DumpResult>

where Self: Sized, K: SingleArg,

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

fn exists<K, C>(self, keys: C) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg, C: SingleArgCollection<K>,

Returns if keys exist.

fn expire<K>( self, key: K, seconds: u64, option: ExpireOption ) -> PreparedCommand<'a, Self, bool>

where Self: Sized, K: SingleArg,

Set a timeout on key in seconds

fn expireat<K>( self, key: K, unix_time_seconds: u64, option: ExpireOption ) -> PreparedCommand<'a, Self, bool>

where Self: Sized, K: SingleArg,

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) -> PreparedCommand<'a, Self, i64>

where Self: Sized, K: SingleArg,

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) -> PreparedCommand<'a, Self, A>

where Self: Sized, P: SingleArg, K: PrimitiveResponse + DeserializeOwned, A: CollectionResponse<K> + DeserializeOwned,

Returns all keys matching pattern.

fn migrate<H, K>( self, host: H, port: u16, key: K, destination_db: usize, timeout: u64, options: MigrateOptions ) -> PreparedCommand<'a, Self, MigrateResult>

where Self: Sized, H: SingleArg, K: SingleArg,

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) -> PreparedCommand<'a, Self, i64>

where Self: Sized, K: SingleArg,

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

fn object_encoding<K, E>(self, key: K) -> PreparedCommand<'a, Self, E>

where Self: Sized, K: SingleArg, E: PrimitiveResponse,

Returns the internal encoding for the Redis object stored at key

fn object_freq<K>(self, key: K) -> PreparedCommand<'a, Self, i64>

where Self: Sized, K: SingleArg,

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

fn object_idle_time<K>(self, key: K) -> PreparedCommand<'a, Self, i64>

where Self: Sized, K: SingleArg,

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

fn object_refcount<K>(self, key: K) -> PreparedCommand<'a, Self, i64>

where Self: Sized, K: SingleArg,

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

fn persist<K>(self, key: K) -> PreparedCommand<'a, Self, bool>

where Self: Sized, K: SingleArg,

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 ) -> PreparedCommand<'a, Self, bool>

where Self: Sized, K: SingleArg,

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 ) -> PreparedCommand<'a, Self, bool>

where Self: Sized, K: SingleArg,

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) -> PreparedCommand<'a, Self, i64>

where Self: Sized, K: SingleArg,

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) -> PreparedCommand<'a, Self, i64>

where Self: Sized, K: SingleArg,

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

fn randomkey<R>(self) -> PreparedCommand<'a, Self, R>

where Self: Sized, R: PrimitiveResponse,

Return a random key from the currently selected database.

fn rename<K1, K2>(self, key: K1, new_key: K2) -> PreparedCommand<'a, Self, ()>

where Self: Sized, K1: SingleArg, K2: SingleArg,

Renames key to newkey.

fn renamenx<K1, K2>( self, key: K1, new_key: K2 ) -> PreparedCommand<'a, Self, bool>

where Self: Sized, K1: SingleArg, K2: SingleArg,

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 ) -> PreparedCommand<'a, Self, ()>

where Self: Sized, K: SingleArg,

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 ) -> PreparedCommand<'a, Self, (u64, A)>

where Self: Sized, K: PrimitiveResponse + DeserializeOwned, A: CollectionResponse<K> + DeserializeOwned,

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

fn sort<K, M, A>( self, key: K, options: SortOptions ) -> PreparedCommand<'a, Self, A>

where Self: Sized, K: SingleArg, M: PrimitiveResponse + DeserializeOwned, A: CollectionResponse<M> + DeserializeOwned,

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 ) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg, D: SingleArg,

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

fn sort_readonly<K, M, A>( self, key: K, options: SortOptions ) -> PreparedCommand<'a, Self, A>

where Self: Sized, K: SingleArg, M: PrimitiveResponse + DeserializeOwned, A: CollectionResponse<M> + DeserializeOwned,

Read-only variant of the SORT command.

fn touch<K, KK>(self, keys: KK) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg, KK: SingleArgCollection<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) -> PreparedCommand<'a, Self, i64>

where Self: Sized, K: SingleArg,

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

fn type_<K>(self, key: K) -> PreparedCommand<'a, Self, String>

where Self: Sized, K: SingleArg,

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

fn unlink<K, C>(self, keys: C) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg, C: SingleArgCollection<K>,

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

fn wait( self, num_replicas: usize, timeout: u64 ) -> PreparedCommand<'a, Self, usize>

where Self: Sized,

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<'a> GeoCommands<'a> for &'a Client

fn geoadd<K, M, I>( self, key: K, condition: GeoAddCondition, change: bool, items: I ) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg, M: SingleArg, I: MultipleArgsCollection<(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 ) -> PreparedCommand<'a, Self, Option<f64>>

where Self: Sized, K: SingleArg, M: SingleArg,

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 ) -> PreparedCommand<'a, Self, Vec<String>>

where Self: Sized, K: SingleArg, M: SingleArg, C: SingleArgCollection<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 ) -> PreparedCommand<'a, Self, Vec<Option<(f64, f64)>>>

where Self: Sized, K: SingleArg, M: SingleArg, C: SingleArgCollection<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 ) -> PreparedCommand<'a, Self, A>

where Self: Sized, K: SingleArg, M1: SingleArg, M2: PrimitiveResponse + DeserializeOwned, A: CollectionResponse<GeoSearchResult<M2>> + DeserializeOwned,

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 ) -> PreparedCommand<'a, Self, usize>

where Self: Sized, D: SingleArg, S: SingleArg, M: SingleArg,

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

impl<'a> GraphCommands<'a> for &'a Client

Available on crate feature redis-graph only.

fn graph_config_get<N, V, R>( self, name: impl SingleArg ) -> PreparedCommand<'a, Self, R>

where Self: Sized, N: PrimitiveResponse, V: PrimitiveResponse, R: KeyValueCollectionResponse<N, V>,

Retrieves the current value of a RedisGraph configuration parameter.

fn graph_config_set( self, name: impl SingleArg, value: impl SingleArg ) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

Set the value of a RedisGraph configuration parameter.

fn graph_delete( self, graph: impl SingleArg ) -> PreparedCommand<'a, Self, String>

where Self: Sized,

Completely removes the graph and all of its entities.

fn graph_explain<R: PrimitiveResponse + DeserializeOwned, RR: CollectionResponse<R>>( self, graph: impl SingleArg, query: impl SingleArg ) -> PreparedCommand<'a, Self, RR>

where Self: Sized,

Constructs a query execution plan but does not run it.

fn graph_list<R: PrimitiveResponse + DeserializeOwned, RR: CollectionResponse<R>>( self ) -> PreparedCommand<'a, Self, RR>

where Self: Sized,

Lists all graph keys in the keyspace.

fn graph_profile<R: PrimitiveResponse + DeserializeOwned, RR: CollectionResponse<R>>( self, graph: impl SingleArg, query: impl SingleArg, options: GraphQueryOptions ) -> PreparedCommand<'a, Self, RR>

where Self: Sized,

Executes a query and produces an execution plan augmented with metrics for each operation’s execution.

fn graph_query( self, graph: impl SingleArg, query: impl SingleArg, options: GraphQueryOptions ) -> PreparedCommand<'a, Self, GraphResultSet>

where Self: Sized,

Executes the given query against a specified graph.

fn graph_ro_query( self, graph: impl SingleArg, query: impl SingleArg, options: GraphQueryOptions ) -> PreparedCommand<'a, Self, GraphResultSet>

where Self: Sized,

Executes a given read only query against a specified graph

fn graph_slowlog<R: CollectionResponse<GraphSlowlogResult>>( self, graph: impl SingleArg ) -> PreparedCommand<'a, Self, R>

where Self: Sized,

Returns a list containing up to 10 of the slowest queries issued against the given graph ID.

impl<'a> HashCommands<'a> for &'a Client

fn hdel<K, F, C>(self, key: K, fields: C) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg, F: SingleArg, C: SingleArgCollection<F>,

Removes the specified fields from the hash stored at key.

fn hexists<K, F>(self, key: K, field: F) -> PreparedCommand<'a, Self, bool>

where Self: Sized, K: SingleArg, F: SingleArg,

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

fn hget<K, F, V>(self, key: K, field: F) -> PreparedCommand<'a, Self, V>

where Self: Sized, K: SingleArg, F: SingleArg, V: PrimitiveResponse,

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

fn hgetall<K, F, V, A>(self, key: K) -> PreparedCommand<'a, Self, A>

where Self: Sized, K: SingleArg, F: PrimitiveResponse, V: PrimitiveResponse, A: KeyValueCollectionResponse<F, V>,

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

fn hincrby<K, F>( self, key: K, field: F, increment: i64 ) -> PreparedCommand<'a, Self, i64>

where Self: Sized, K: SingleArg, F: SingleArg,

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 ) -> PreparedCommand<'a, Self, f64>

where Self: Sized, K: SingleArg, F: SingleArg,

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) -> PreparedCommand<'a, Self, A>

where Self: Sized, K: SingleArg, F: PrimitiveResponse + DeserializeOwned, A: CollectionResponse<F> + DeserializeOwned,

Returns all field names in the hash stored at key.

fn hlen<K>(self, key: K) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg,

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

fn hmget<K, F, V, C, A>(self, key: K, fields: C) -> PreparedCommand<'a, Self, A>

where Self: Sized, K: SingleArg, F: SingleArg, C: SingleArgCollection<F>, V: PrimitiveResponse + DeserializeOwned, A: CollectionResponse<V> + DeserializeOwned,

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

fn hrandfield<K, F>(self, key: K) -> PreparedCommand<'a, Self, F>

where Self: Sized, K: SingleArg, F: PrimitiveResponse,

return random fields from the hash value stored at key.

fn hrandfields<K, F, A>( self, key: K, count: isize ) -> PreparedCommand<'a, Self, A>

where Self: Sized, K: SingleArg, F: PrimitiveResponse + DeserializeOwned, A: CollectionResponse<F> + DeserializeOwned,

return random fields from the hash value stored at key.

fn hrandfields_with_values<K, F, V, A>( self, key: K, count: isize ) -> PreparedCommand<'a, Self, A>

where Self: Sized, K: SingleArg, F: PrimitiveResponse, V: PrimitiveResponse, A: KeyValueCollectionResponse<F, V>,

return random fields from the hash value stored at key.

fn hscan<K, F, V>( self, key: K, cursor: u64, options: HScanOptions ) -> PreparedCommand<'a, Self, HScanResult<F, V>>

where Self: Sized, K: SingleArg, F: PrimitiveResponse + DeserializeOwned, V: PrimitiveResponse + DeserializeOwned,

Iterates fields of Hash types and their associated values.

fn hset<K, F, V, I>(self, key: K, items: I) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg, F: SingleArg, V: SingleArg, I: KeyValueArgsCollection<F, V>,

Sets field in the hash stored at key to value.

fn hsetnx<K, F, V>( self, key: K, field: F, value: V ) -> PreparedCommand<'a, Self, bool>

where Self: Sized, K: SingleArg, F: SingleArg, V: SingleArg,

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) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg, F: SingleArg,

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

fn hvals<K, V, A>(self, key: K) -> PreparedCommand<'a, Self, A>

where Self: Sized, K: SingleArg, V: PrimitiveResponse + DeserializeOwned, A: CollectionResponse<V> + DeserializeOwned,

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

impl<'a> HyperLogLogCommands<'a> for &'a Client

fn pfadd<K, E, EE>( self, key: K, elements: EE ) -> PreparedCommand<'a, Self, bool>

where Self: Sized, K: SingleArg, E: SingleArg, EE: SingleArgCollection<E>,

Adds the specified elements to the specified HyperLogLog.

fn pfcount<K, KK>(self, keys: KK) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg, KK: SingleArgCollection<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 ) -> PreparedCommand<'a, Self, ()>

where Self: Sized, D: SingleArg, S: SingleArg, SS: SingleArgCollection<S>,

Merge N different HyperLogLogs into a single one.

impl<'a> JsonCommands<'a> for &'a Client

Available on crate feature redis-json only.

fn json_arrappend<K, P, V, VV, R>( self, key: K, path: P, values: VV ) -> PreparedCommand<'a, Self, R>

where Self: Sized, K: SingleArg, P: SingleArg, V: SingleArg, VV: SingleArgCollection<V>, R: CollectionResponse<Option<usize>>,

Append the json values into the array at path after the last element in it

fn json_arrindex<K, P, V, R>( self, key: K, path: P, value: V, options: JsonArrIndexOptions ) -> PreparedCommand<'a, Self, R>

where Self: Sized, K: SingleArg, P: SingleArg, V: SingleArg, R: CollectionResponse<Option<isize>>,

Search for the first occurrence of a scalar JSON value in an array

fn json_arrinsert<K, P, V, VV, R>( self, key: K, path: P, index: isize, values: VV ) -> PreparedCommand<'a, Self, R>

where Self: Sized, K: SingleArg, P: SingleArg, V: SingleArg, VV: SingleArgCollection<V>, R: CollectionResponse<Option<usize>>,

Insert the json values into the array at path before the index (shifts to the right)

fn json_arrlen<K, P, R>(self, key: K, path: P) -> PreparedCommand<'a, Self, R>

where Self: Sized, K: SingleArg, P: SingleArg, R: CollectionResponse<Option<usize>>,

Report the length of the JSON array at path in key

fn json_arrpop<K, P, R, RR>( self, key: K, path: P, index: isize ) -> PreparedCommand<'a, Self, RR>

where Self: Sized, K: SingleArg, P: SingleArg, R: PrimitiveResponse + DeserializeOwned, RR: CollectionResponse<R>,

Remove and return an element from the index in the array

fn json_arrtrim<K, P, R>( self, key: K, path: P, start: isize, stop: isize ) -> PreparedCommand<'a, Self, R>

where Self: Sized, K: SingleArg, P: SingleArg, R: CollectionResponse<Option<usize>>,

Remove and return an element from the index in the array

fn json_clear<K, P>(self, key: K, path: P) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg, P: SingleArg,

Clear container values (arrays/objects) and set numeric values to 0

fn json_debug_memory<K, P, R>( self, key: K, path: P ) -> PreparedCommand<'a, Self, R>

where Self: Sized, K: SingleArg, P: SingleArg, R: CollectionResponse<usize>,

Report a value’s memory usage in bytes

fn json_del<K, P>(self, key: K, path: P) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg, P: SingleArg,

Delete a value

fn json_forget<K, P>(self, key: K, path: P) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg, P: SingleArg,

See json_del

fn json_get<K, V>( self, key: K, options: JsonGetOptions ) -> PreparedCommand<'a, Self, V>

where Self: Sized, K: SingleArg, V: PrimitiveResponse,

Return the value at path in JSON serialized form

fn json_mget<K, KK, P, V, VV>( self, keys: KK, path: P ) -> PreparedCommand<'a, Self, VV>

where Self: Sized, K: SingleArg, KK: SingleArgCollection<K>, P: SingleArg, V: PrimitiveResponse + DeserializeOwned, VV: CollectionResponse<V>,

Return the values at path from multiple key arguments

fn json_numincrby<K, P, V, R>( self, key: K, path: P, value: V ) -> PreparedCommand<'a, Self, R>

where Self: Sized, K: SingleArg, P: SingleArg, V: SingleArg, R: PrimitiveResponse,

Increment the number value stored at path by number

fn json_nummultby<K, P, V, R>( self, key: K, path: P, value: V ) -> PreparedCommand<'a, Self, R>

where Self: Sized, K: SingleArg, P: SingleArg, V: SingleArg, R: PrimitiveResponse,

Multiply the number value stored at path by number

fn json_objkeys<K, P, R, RR>( self, key: K, path: P ) -> PreparedCommand<'a, Self, RR>

where Self: Sized, K: SingleArg, P: SingleArg, R: PrimitiveResponse + DeserializeOwned, RR: CollectionResponse<Vec<R>>,

Return the keys in the object that’s referenced by path

fn json_objlen<K, P, R>(self, key: K, path: P) -> PreparedCommand<'a, Self, R>

where Self: Sized, K: SingleArg, P: SingleArg, R: CollectionResponse<Option<usize>>,

Report the number of keys in the JSON object at path in key

fn json_resp<K, P, VV>(self, key: K, path: P) -> PreparedCommand<'a, Self, VV>

where Self: Sized, K: SingleArg, P: SingleArg, VV: CollectionResponse<Value>,

Return the JSON in key in Redis serialization protocol specification form

fn json_set<K, P, V>( self, key: K, path: P, value: V, condition: SetCondition ) -> PreparedCommand<'a, Self, ()>

where Self: Sized, K: SingleArg, P: SingleArg, V: SingleArg,

Set the JSON value at path in key

fn json_strappend<K, P, V, R>( self, key: K, path: P, value: V ) -> PreparedCommand<'a, Self, R>

where Self: Sized, K: SingleArg, P: SingleArg, V: SingleArg, R: CollectionResponse<Option<usize>>,

Append the json-string values to the string at path

fn json_strlen<K, P, R>(self, key: K, path: P) -> PreparedCommand<'a, Self, R>

where Self: Sized, K: SingleArg, P: SingleArg, R: CollectionResponse<Option<usize>>,

Report the length of the JSON String at path in key

fn json_toggle<K, P, R>(self, key: K, path: P) -> PreparedCommand<'a, Self, R>

where Self: Sized, K: SingleArg, P: SingleArg, R: CollectionResponse<Option<usize>>,

Toggle a Boolean value stored at path

fn json_type<K, P, R, RR>( self, key: K, path: P ) -> PreparedCommand<'a, Self, RR>

where Self: Sized, K: SingleArg, P: SingleArg, R: PrimitiveResponse + DeserializeOwned, RR: CollectionResponse<R>,

Report the type of JSON value at path

impl<'a> ListCommands<'a> for &'a Client

fn lindex<K, E>(self, key: K, index: isize) -> PreparedCommand<'a, Self, E>

where Self: Sized, K: SingleArg, E: PrimitiveResponse,

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 ) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg, E: SingleArg,

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

fn llen<K>(self, key: K) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg,

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 ) -> PreparedCommand<'a, Self, E>

where Self: Sized, S: SingleArg, D: SingleArg, E: PrimitiveResponse,

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 ) -> PreparedCommand<'a, Self, (String, Vec<E>)>

where Self: Sized, K: SingleArg, E: PrimitiveResponse + DeserializeOwned, C: SingleArgCollection<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) -> PreparedCommand<'a, Self, A>

where Self: Sized, K: SingleArg, E: PrimitiveResponse + DeserializeOwned, A: CollectionResponse<E> + DeserializeOwned,

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> ) -> PreparedCommand<'a, Self, Option<usize>>

where Self: Sized, K: SingleArg, E: SingleArg,

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> ) -> PreparedCommand<'a, Self, A>

where Self: Sized, K: SingleArg, E: SingleArg, A: CollectionResponse<usize>,

Returns the index of matching elements inside a Redis list.

fn lpush<K, E, C>(self, key: K, elements: C) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg, E: SingleArg, C: SingleArgCollection<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 ) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg, E: SingleArg, C: SingleArgCollection<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 ) -> PreparedCommand<'a, Self, A>

where Self: Sized, K: SingleArg, E: PrimitiveResponse + DeserializeOwned, A: CollectionResponse<E> + DeserializeOwned,

Returns the specified elements of the list stored at key.

fn lrem<K, E>( self, key: K, count: isize, element: E ) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg, E: SingleArg,

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 ) -> PreparedCommand<'a, Self, ()>

where Self: Sized, K: SingleArg, E: SingleArg,

Sets the list element at index to element.

fn ltrim<K>( self, key: K, start: isize, stop: isize ) -> PreparedCommand<'a, Self, ()>

where Self: Sized, K: SingleArg,

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) -> PreparedCommand<'a, Self, C>

where Self: Sized, K: SingleArg, E: PrimitiveResponse + DeserializeOwned, C: CollectionResponse<E> + DeserializeOwned,

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

fn rpush<K, E, C>(self, key: K, elements: C) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg, E: SingleArg, C: SingleArgCollection<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 ) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg, E: SingleArg, C: SingleArgCollection<E>,

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

impl<'a> PubSubCommands<'a> for &'a Client

async fn subscribe<C, CC>(self, channels: CC) -> Result<PubSubStream>

where C: SingleArg + Send + 'a, CC: SingleArgCollection<C>,

Subscribes the client to the specified channels.

async fn psubscribe<P, PP>(self, patterns: PP) -> Result<PubSubStream>

where P: SingleArg + Send + 'a, PP: SingleArgCollection<P>,

Subscribes the client to the given patterns.

async fn ssubscribe<C, CC>(self, shardchannels: CC) -> Result<PubSubStream>

where C: SingleArg + Send + 'a, CC: SingleArgCollection<C>,

Subscribes the client to the specified channels.

fn publish<C, M>( self, channel: C, message: M ) -> PreparedCommand<'a, Self, usize>

where Self: Sized, C: SingleArg, M: SingleArg,

Posts a message to the given channel.

fn pub_sub_channels<C, CC>( self, options: PubSubChannelsOptions ) -> PreparedCommand<'a, Self, CC>

where Self: Sized, C: PrimitiveResponse + DeserializeOwned, CC: CollectionResponse<C>,

Lists the currently active channels.

fn pub_sub_numpat(self) -> PreparedCommand<'a, Self, usize>

where Self: Sized,

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 ) -> PreparedCommand<'a, Self, RR>

where Self: Sized, C: SingleArg, CC: SingleArgCollection<C>, R: PrimitiveResponse, RR: KeyValueCollectionResponse<R, usize>,

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

fn pub_sub_shardchannels<C, CC>( self, options: PubSubChannelsOptions ) -> PreparedCommand<'a, Self, CC>

where Self: Sized, C: PrimitiveResponse + DeserializeOwned, CC: CollectionResponse<C>,

Lists the currently active shard channels.

fn pub_sub_shardnumsub<C, CC, R, RR>( self, channels: CC ) -> PreparedCommand<'a, Self, RR>

where Self: Sized, C: SingleArg, CC: SingleArgCollection<C>, R: PrimitiveResponse, RR: KeyValueCollectionResponse<R, usize>,

Returns the number of subscribers for the specified shard channels.

fn spublish<C, M>( self, shardchannel: C, message: M ) -> PreparedCommand<'a, Self, usize>

where Self: Sized, C: SingleArg, M: SingleArg,

Posts a message to the given shard channel.

impl<'a> ScriptingCommands<'a> for &'a Client

fn eval<R>(self, builder: CallBuilder) -> PreparedCommand<'a, Self, R>

where Self: Sized, R: Response,

Invoke the execution of a server-side Lua script.

fn eval_readonly<R>(self, builder: CallBuilder) -> PreparedCommand<'a, Self, R>

where Self: Sized, R: Response,

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

fn evalsha<R>(self, builder: CallBuilder) -> PreparedCommand<'a, Self, R>

where Self: Sized, R: Response,

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

fn evalsha_readonly<R>( self, builder: CallBuilder ) -> PreparedCommand<'a, Self, R>

where Self: Sized, R: Response,

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

fn fcall<R>(self, builder: CallBuilder) -> PreparedCommand<'a, Self, R>

where Self: Sized, R: Response,

Invoke a function.

fn fcall_readonly<R>(self, builder: CallBuilder) -> PreparedCommand<'a, Self, R>

where Self: Sized, R: Response,

Invoke a function.

fn function_delete<L>(self, library_name: L) -> PreparedCommand<'a, Self, ()>

where Self: Sized, L: SingleArg,

Delete a library and all its functions.

fn function_dump(self) -> PreparedCommand<'a, Self, FunctionDumpResult>

where Self: Sized,

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 ) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

Deletes all the libraries.

fn function_kill(self) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

Kill a function that is currently executing.

fn function_list( self, options: FunctionListOptions ) -> PreparedCommand<'a, Self, Vec<LibraryInfo>>

where Self: Sized,

Return information about the functions and libraries.

fn function_load<F, L>( self, replace: bool, function_code: F ) -> PreparedCommand<'a, Self, L>

where Self: Sized, F: SingleArg, L: PrimitiveResponse,

Load a library to Redis.

fn function_restore<P>( self, serialized_payload: P, policy: FunctionRestorePolicy ) -> PreparedCommand<'a, Self, ()>

where Self: Sized, P: SingleArg,

Restore libraries from the serialized payload.

fn function_stats(self) -> PreparedCommand<'a, Self, FunctionStats>

where Self: Sized,

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

fn script_debug( self, debug_mode: ScriptDebugMode ) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

Set the debug mode for subsequent scripts executed with EVAL.

fn script_exists<S, C>(self, sha1s: C) -> PreparedCommand<'a, Self, Vec<bool>>

where Self: Sized, S: SingleArg, C: SingleArgCollection<S>,

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

fn script_flush( self, flushing_mode: FlushingMode ) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

Flush the Lua scripts cache.

fn script_kill(self) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

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

fn script_load<S, V>(self, script: S) -> PreparedCommand<'a, Self, V>

where Self: Sized, S: SingleArg, V: PrimitiveResponse,

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

impl<'a> SearchCommands<'a> for &'a Client

Available on crate feature redis-search only.

fn ft_aggregate<I, Q>( self, index: I, query: Q, options: FtAggregateOptions ) -> PreparedCommand<'a, Self, FtAggregateResult>

where Self: Sized, I: SingleArg, Q: SingleArg,

Run a search query on an index, and perform aggregate transformations on the results, extracting statistics etc from them

fn ft_aliasadd<A, I>(self, alias: A, index: I) -> PreparedCommand<'a, Self, ()>

where Self: Sized, A: SingleArg, I: SingleArg,

Add an alias to an index

fn ft_aliasdel<A>(self, alias: A) -> PreparedCommand<'a, Self, ()>

where Self: Sized, A: SingleArg,

Remove an alias from an index

fn ft_aliasupdate<A, I>( self, alias: A, index: I ) -> PreparedCommand<'a, Self, ()>

where Self: Sized, A: SingleArg, I: SingleArg,

Add an alias to an index.

fn ft_alter<I>( self, index: I, skip_initial_scan: bool, attribute: FtFieldSchema ) -> PreparedCommand<'a, Self, ()>

where Self: Sized, I: SingleArg,

Add a new attribute to the index.

fn ft_config_get<O, N, V, R>(self, option: O) -> PreparedCommand<'a, Self, R>

where Self: Sized, O: SingleArg, N: PrimitiveResponse, V: PrimitiveResponse, R: KeyValueCollectionResponse<N, V>,

Retrieve configuration options

fn ft_config_set<O, V>( self, option: O, value: V ) -> PreparedCommand<'a, Self, ()>

where Self: Sized, O: SingleArg, V: SingleArg,

Set configuration options

fn ft_create<I, S>( self, index: I, options: FtCreateOptions, schema: S ) -> PreparedCommand<'a, Self, ()>

where Self: Sized, I: SingleArg, S: MultipleArgsCollection<FtFieldSchema>,

Create an index with the given specification

fn ft_cursor_del<I>( self, index: I, cursor_id: u64 ) -> PreparedCommand<'a, Self, ()>

where Self: Sized, I: SingleArg,

Delete a cursor

fn ft_cursor_read<I>( self, index: I, cursor_id: u64 ) -> PreparedCommand<'a, Self, FtAggregateResult>

where Self: Sized, I: SingleArg,

Read next results from an existing cursor

fn ft_dictadd<D, T, TT>( self, dict: D, terms: TT ) -> PreparedCommand<'a, Self, usize>

where Self: Sized, D: SingleArg, T: SingleArg, TT: SingleArgCollection<T>,

Add terms to a dictionary

fn ft_dictdel<D, T, TT>( self, dict: D, terms: TT ) -> PreparedCommand<'a, Self, usize>

where Self: Sized, D: SingleArg, T: SingleArg, TT: SingleArgCollection<T>,

Delete terms from a dictionary

fn ft_dictdump<D, T, TT>(self, dict: D) -> PreparedCommand<'a, Self, TT>

where Self: Sized, D: SingleArg, T: PrimitiveResponse + DeserializeOwned, TT: CollectionResponse<T>,

Dump all terms in the given dictionary

fn ft_dropindex<I>(self, index: I, dd: bool) -> PreparedCommand<'a, Self, ()>

where Self: Sized, I: SingleArg,

Delete an index

fn ft_explain<I, Q, R>( self, index: I, query: Q, dialect_version: Option<u64> ) -> PreparedCommand<'a, Self, R>

where Self: Sized, I: SingleArg, Q: SingleArg, R: PrimitiveResponse,

Return the execution plan for a complex query

fn ft_explaincli<I, Q, R, RR>( self, index: I, query: Q, dialect_version: Option<u64> ) -> PreparedCommand<'a, Self, RR>

where Self: Sized, I: SingleArg, Q: SingleArg, R: PrimitiveResponse + DeserializeOwned, RR: CollectionResponse<R>,

Return the execution plan for a complex query but formatted for easier reading without using redis-cli --raw

fn ft_info( self, index: impl SingleArg ) -> PreparedCommand<'a, Self, FtInfoResult>

where Self: Sized,

Return information and statistics on the index

fn ft_list<R, RR>(self) -> PreparedCommand<'a, Self, RR>

where Self: Sized, R: PrimitiveResponse + DeserializeOwned, RR: CollectionResponse<R>,

Returns a list of all existing indexes.

fn ft_profile_search<I, Q, QQ>( self, index: I, limited: bool, query: QQ ) -> PreparedCommand<'a, Self, FtProfileSearchResult>

where Self: Sized, I: SingleArg, Q: SingleArg, QQ: SingleArgCollection<Q>,

Perform a ft_search command and collects performance information

fn ft_profile_aggregate<I, Q, QQ>( self, index: I, limited: bool, query: QQ ) -> PreparedCommand<'a, Self, FtProfileAggregateResult>

where Self: Sized, I: SingleArg, Q: SingleArg, QQ: SingleArgCollection<Q>,

Perform a ft_aggregate command and collects performance information

fn ft_search<I, Q>( self, index: I, query: Q, options: FtSearchOptions ) -> PreparedCommand<'a, Self, FtSearchResult>

where Self: Sized, I: SingleArg, Q: SingleArg,

Search the index with a textual query, returning either documents or just ids

fn ft_spellcheck<I, Q>( self, index: I, query: Q, options: FtSpellCheckOptions ) -> PreparedCommand<'a, Self, FtSpellCheckResult>

where Self: Sized, I: SingleArg, Q: SingleArg,

Perform spelling correction on a query, returning suggestions for misspelled terms

fn ft_syndump<I, R>(self, index: I) -> PreparedCommand<'a, Self, R>

where Self: Sized, I: SingleArg, R: KeyValueCollectionResponse<String, Vec<String>>,

Dump the contents of a synonym group

fn ft_synupdate<T: SingleArg>( self, index: impl SingleArg, synonym_group_id: impl SingleArg, skip_initial_scan: bool, terms: impl SingleArgCollection<T> ) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

Update a synonym group

fn ft_tagvals<R: PrimitiveResponse + DeserializeOwned, RR: CollectionResponse<R>>( self, index: impl SingleArg, field_name: impl SingleArg ) -> PreparedCommand<'a, Self, RR>

where Self: Sized,

Return a distinct set of values indexed in a Tag field

fn ft_sugadd( self, key: impl SingleArg, string: impl SingleArg, score: f64, options: FtSugAddOptions ) -> PreparedCommand<'a, Self, usize>

where Self: Sized,

Add a suggestion string to an auto-complete suggestion dictionary

fn ft_sugdel( self, key: impl SingleArg, string: impl SingleArg ) -> PreparedCommand<'a, Self, bool>

where Self: Sized,

Delete a string from a suggestion index

fn ft_sugget( self, key: impl SingleArg, prefix: impl SingleArg, options: FtSugGetOptions ) -> PreparedCommand<'a, Self, Vec<FtSuggestion>>

where Self: Sized,

Get completion suggestions for a prefix

fn ft_suglen(self, key: impl SingleArg) -> PreparedCommand<'a, Self, usize>

where Self: Sized,

Get the size of an auto-complete suggestion dictionary

impl<'a> SentinelCommands<'a> for &'a Client

fn sentinel_config_get<N, RN, RV, R>( self, name: N ) -> PreparedCommand<'a, Self, R>

where Self: Sized, N: SingleArg, RN: PrimitiveResponse, RV: PrimitiveResponse, R: KeyValueCollectionResponse<RN, RV>,

Get the current value of a global Sentinel configuration parameter.

fn sentinel_config_set<N, V>( self, name: N, value: V ) -> PreparedCommand<'a, Self, ()>

where Self: Sized, N: SingleArg, V: SingleArg,

Set the value of a global Sentinel configuration parameter.

fn sentinel_ckquorum<N>(self, master_name: N) -> PreparedCommand<'a, Self, ()>

where Self: Sized, N: SingleArg,

Check if the current Sentinel configuration is able to reach the quorum needed to failover a master, and the majority needed to authorize the failover.

fn sentinel_failover<N>(self, master_name: N) -> PreparedCommand<'a, Self, ()>

where Self: Sized, N: SingleArg,

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).

fn sentinel_flushconfig(self) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

Force Sentinel to rewrite its configuration on disk, including the current Sentinel state.

fn sentinel_get_master_addr_by_name<N>( self, master_name: N ) -> PreparedCommand<'a, Self, Option<(String, u16)>>

where Self: Sized, N: SingleArg,

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

fn sentinel_info_cache<N, NN, R>( self, master_names: NN ) -> PreparedCommand<'a, Self, R>

where Self: Sized, N: SingleArg, NN: MultipleArgsCollection<N>, R: KeyValueCollectionResponse<String, Vec<(u64, String)>>,

Return cached info output from masters and replicas.

fn sentinel_master<N>( self, master_name: N ) -> PreparedCommand<'a, Self, SentinelMasterInfo>

where Self: Sized, N: SingleArg,

Show the state and info of the specified master.

fn sentinel_masters(self) -> PreparedCommand<'a, Self, Vec<SentinelMasterInfo>>

where Self: Sized,

Show a list of monitored masters and their state.

fn sentinel_monitor<N, I>( self, name: N, ip: I, port: u16, quorum: usize ) -> PreparedCommand<'a, Self, ()>

where Self: Sized, N: SingleArg, I: SingleArg,

This command tells the Sentinel to start monitoring a new master with the specified name, ip, port, and quorum.

fn sentinel_remove<N>(self, name: N) -> PreparedCommand<'a, Self, ()>

where Self: Sized, N: SingleArg,

This command is used in order to remove the specified master.

fn sentinel_set<N, O, V, C>( self, name: N, configs: C ) -> PreparedCommand<'a, Self, ()>

where Self: Sized, N: SingleArg, O: SingleArg, V: SingleArg, C: KeyValueArgsCollection<O, V>,

The SET command is very similar to the config_set command of Redis, and is used in order to change configuration parameters of a specific master.

fn sentinel_myid(self) -> PreparedCommand<'a, Self, String>

where Self: Sized,

Return the ID of the Sentinel instance.

fn sentinel_pending_scripts(self) -> PreparedCommand<'a, Self, Vec<Value>>

where Self: Sized,

This command returns information about pending scripts.

fn sentinel_replicas<N>( self, master_name: N ) -> PreparedCommand<'a, Self, Vec<SentinelReplicaInfo>>

where Self: Sized, N: SingleArg,

Show a list of replicas for this master, and their state.

fn sentinel_reset<P>(self, pattern: P) -> PreparedCommand<'a, Self, usize>

where Self: Sized, P: SingleArg,

This command will reset all the masters with matching name.

fn sentinel_sentinels<N>( self, master_name: N ) -> PreparedCommand<'a, Self, Vec<SentinelInfo>>

where Self: Sized, N: SingleArg,

Show a list of sentinel instances for this master, and their state.

fn sentinel_simulate_failure( self, mode: SentinelSimulateFailureMode ) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

This command simulates different Sentinel crash scenarios.

impl<'a> ServerCommands<'a> for &'a Client

fn acl_cat<C, CC>(self, options: AclCatOptions) -> PreparedCommand<'a, Self, CC>

where Self: Sized, C: PrimitiveResponse + DeserializeOwned, CC: CollectionResponse<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) -> PreparedCommand<'a, Self, usize>

where Self: Sized, U: SingleArg, UU: SingleArgCollection<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 ) -> PreparedCommand<'a, Self, R>

where Self: Sized, U: SingleArg, C: SingleArg, R: PrimitiveResponse,

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

fn acl_genpass<R: PrimitiveResponse>( self, options: AclGenPassOptions ) -> PreparedCommand<'a, Self, R>

where Self: Sized,

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) -> PreparedCommand<'a, Self, RR>

where Self: Sized, U: SingleArg, RR: KeyValueCollectionResponse<String, Value>,

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

fn acl_list(self) -> PreparedCommand<'a, Self, Vec<String>>

where Self: Sized,

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

fn acl_load(self) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

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 ) -> PreparedCommand<'a, Self, Vec<EE>>

where Self: Sized, EE: KeyValueCollectionResponse<String, Value> + DeserializeOwned,

The command shows a list of recent ACL security events

fn acl_save(self) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

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 ) -> PreparedCommand<'a, Self, ()>

where Self: Sized, U: SingleArg, R: SingleArg, RR: SingleArgCollection<R>,

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

fn acl_users<U, UU>(self) -> PreparedCommand<'a, Self, UU>

where Self: Sized, U: PrimitiveResponse + DeserializeOwned, UU: CollectionResponse<U>,

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

fn acl_whoami<U: PrimitiveResponse>(self) -> PreparedCommand<'a, Self, U>

where Self: Sized,

Return the username the current connection is authenticated with.

fn command(self) -> PreparedCommand<'a, Self, Vec<CommandInfo>>

where Self: Sized,

Return an array with details about every Redis command.

fn command_count(self) -> PreparedCommand<'a, Self, usize>

where Self: Sized,

Number of total commands in this Redis server.

fn command_docs<N, NN, DD>( self, command_names: NN ) -> PreparedCommand<'a, Self, DD>

where Self: Sized, N: SingleArg, NN: SingleArgCollection<N>, DD: KeyValueCollectionResponse<String, CommandDoc>,

Number of total commands in this Redis server.

fn command_getkeys<A, AA, KK>(self, args: AA) -> PreparedCommand<'a, Self, KK>

where Self: Sized, A: SingleArg, AA: SingleArgCollection<A>, KK: CollectionResponse<String>,

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

fn command_getkeysandflags<A, AA, KK>( self, args: AA ) -> PreparedCommand<'a, Self, KK>

where Self: Sized, A: SingleArg, AA: SingleArgCollection<A>, KK: KeyValueCollectionResponse<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 ) -> PreparedCommand<'a, Self, Vec<CommandInfo>>

where Self: Sized, N: SingleArg, NN: SingleArgCollection<N>,

Return an array with details about multiple Redis command.

fn command_list<CC>( self, options: CommandListOptions ) -> PreparedCommand<'a, Self, CC>

where Self: Sized, CC: CollectionResponse<String>,

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

fn config_get<P, PP, V, VV>(self, params: PP) -> PreparedCommand<'a, Self, VV>

where Self: Sized, P: SingleArg, PP: SingleArgCollection<P>, V: PrimitiveResponse, VV: KeyValueCollectionResponse<String, V>,

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

fn config_resetstat(self) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

Resets the statistics reported by Redis using the info command.

fn config_rewrite(self) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

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) -> PreparedCommand<'a, Self, ()>

where Self: Sized, P: SingleArg, V: SingleArg, C: KeyValueArgsCollection<P, V>,

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

fn dbsize(self) -> PreparedCommand<'a, Self, usize>

where Self: Sized,

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

fn failover(self, options: FailOverOptions) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

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

fn flushdb(self, flushing_mode: FlushingMode) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

Delete all the keys of the currently selected DB.

fn flushall(self, flushing_mode: FlushingMode) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

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

fn info<SS>(self, sections: SS) -> PreparedCommand<'a, Self, String>

where Self: Sized, SS: SingleArgCollection<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) -> PreparedCommand<'a, Self, u64>

where Self: Sized,

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

fn latency_doctor(self) -> PreparedCommand<'a, Self, String>

where Self: Sized,

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

fn latency_graph( self, event: LatencyHistoryEvent ) -> PreparedCommand<'a, Self, String>

where Self: Sized,

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

fn latency_histogram<C, CC, RR>( self, commands: CC ) -> PreparedCommand<'a, Self, RR>

where Self: Sized, C: SingleArg, CC: SingleArgCollection<C>, RR: KeyValueCollectionResponse<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 ) -> PreparedCommand<'a, Self, RR>

where Self: Sized, RR: CollectionResponse<(u32, u32)>,

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

fn latency_latest<RR>(self) -> PreparedCommand<'a, Self, RR>

where Self: Sized, RR: CollectionResponse<(String, u32, u32, u32)>,

This command reports the latest latency events logged.

fn latency_reset<EE>(self, events: EE) -> PreparedCommand<'a, Self, usize>

where Self: Sized, EE: SingleArgCollection<LatencyHistoryEvent>,

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

fn lolwut(self, options: LolWutOptions) -> PreparedCommand<'a, Self, String>

where Self: Sized,

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) -> PreparedCommand<'a, Self, String>

where Self: Sized,

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

fn memory_malloc_stats(self) -> PreparedCommand<'a, Self, String>

where Self: Sized,

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

fn memory_purge(self) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

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

fn memory_stats(self) -> PreparedCommand<'a, Self, MemoryStats>

where Self: Sized,

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

fn memory_usage<K>( self, key: K, options: MemoryUsageOptions ) -> PreparedCommand<'a, Self, Option<usize>>

where Self: Sized, K: SingleArg,

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

fn module_list<MM>(self) -> PreparedCommand<'a, Self, MM>

where Self: Sized, MM: CollectionResponse<ModuleInfo>,

Returns information about the modules loaded to the server.

fn module_load<P>( self, path: P, options: ModuleLoadOptions ) -> PreparedCommand<'a, Self, ()>

where Self: Sized, P: SingleArg,

Loads a module from a dynamic library at runtime.

fn module_unload<N>(self, name: N) -> PreparedCommand<'a, Self, ()>

where Self: Sized, N: SingleArg,

Unloads a module.

fn replicaof(self, options: ReplicaOfOptions) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

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

fn role(self) -> PreparedCommand<'a, Self, RoleResult>

where Self: Sized,

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) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

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) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

Shutdown the server

fn slowlog_get( self, options: SlowLogOptions ) -> PreparedCommand<'a, Self, Vec<SlowLogEntry>>

where Self: Sized,

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

fn slowlog_len(self) -> PreparedCommand<'a, Self, usize>

where Self: Sized,

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

fn slowlog_reset(self) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

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

fn swapdb(self, index1: usize, index2: usize) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

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) -> PreparedCommand<'a, Self, (u32, u32)>

where Self: Sized,

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<'a> SetCommands<'a> for &'a Client

fn sadd<K, M, C>(self, key: K, members: C) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg, M: SingleArg, C: SingleArgCollection<M>,

Add the specified members to the set stored at key.

fn scard<K>(self, key: K) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg,

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

fn sdiff<K, M, C, A>(self, keys: C) -> PreparedCommand<'a, Self, A>

where Self: Sized, K: SingleArg, M: PrimitiveResponse + Eq + Hash + DeserializeOwned, C: SingleArgCollection<K>, A: CollectionResponse<M> + DeserializeOwned,

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 ) -> PreparedCommand<'a, Self, usize>

where Self: Sized, D: SingleArg, K: SingleArg, C: SingleArgCollection<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) -> PreparedCommand<'a, Self, A>

where Self: Sized, K: SingleArg, M: PrimitiveResponse + Eq + Hash + DeserializeOwned, C: SingleArgCollection<K>, A: CollectionResponse<M> + DeserializeOwned,

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

fn sintercard<K, C>( self, keys: C, limit: usize ) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg, C: SingleArgCollection<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 ) -> PreparedCommand<'a, Self, usize>

where Self: Sized, D: SingleArg, K: SingleArg, C: SingleArgCollection<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) -> PreparedCommand<'a, Self, bool>

where Self: Sized, K: SingleArg, M: SingleArg,

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

fn smembers<K, M, A>(self, key: K) -> PreparedCommand<'a, Self, A>

where Self: Sized, K: SingleArg, M: PrimitiveResponse + Eq + Hash + DeserializeOwned, A: CollectionResponse<M> + DeserializeOwned,

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

fn smismember<K, M, C>( self, key: K, members: C ) -> PreparedCommand<'a, Self, Vec<bool>>

where Self: Sized, K: SingleArg, M: SingleArg, C: SingleArgCollection<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 ) -> PreparedCommand<'a, Self, bool>

where Self: Sized, S: SingleArg, D: SingleArg, M: SingleArg,

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

fn spop<K, M, A>(self, key: K, count: usize) -> PreparedCommand<'a, Self, A>

where Self: Sized, K: SingleArg, M: PrimitiveResponse + Eq + Hash + DeserializeOwned, A: CollectionResponse<M> + DeserializeOwned,

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 ) -> PreparedCommand<'a, Self, A>

where Self: Sized, K: SingleArg, M: PrimitiveResponse + Eq + Hash + DeserializeOwned, A: CollectionResponse<M> + DeserializeOwned,

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) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg, M: SingleArg, C: SingleArgCollection<M>,

Remove the specified members from the set stored at key.

fn sscan<K, M>( self, key: K, cursor: u64, options: SScanOptions ) -> PreparedCommand<'a, Self, (u64, Vec<M>)>

where Self: Sized, K: SingleArg, M: PrimitiveResponse + DeserializeOwned,

Iterates elements of Sets types.

fn sunion<K, M, C, A>(self, keys: C) -> PreparedCommand<'a, Self, A>

where Self: Sized, K: SingleArg, M: PrimitiveResponse + Eq + Hash + DeserializeOwned, C: SingleArgCollection<K>, A: CollectionResponse<M> + DeserializeOwned,

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 ) -> PreparedCommand<'a, Self, usize>

where Self: Sized, D: SingleArg, K: SingleArg, C: SingleArgCollection<K>,

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

impl<'a> SortedSetCommands<'a> for &'a Client

fn zadd<K, M, I>( self, key: K, items: I, options: ZAddOptions ) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg, M: SingleArg, I: MultipleArgsCollection<(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 ) -> PreparedCommand<'a, Self, Option<f64>>

where Self: Sized, K: SingleArg, M: SingleArg,

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

fn zcard<K>(self, key: K) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg,

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 ) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg, M1: SingleArg, M2: SingleArg,

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) -> PreparedCommand<'a, Self, Vec<E>>

where Self: Sized, K: SingleArg, C: SingleArgCollection<K>, E: PrimitiveResponse + DeserializeOwned,

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 ) -> PreparedCommand<'a, Self, Vec<(E, f64)>>

where Self: Sized, K: SingleArg, C: SingleArgCollection<K>, E: PrimitiveResponse + DeserializeOwned,

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 ) -> PreparedCommand<'a, Self, usize>

where Self: Sized, D: SingleArg, K: SingleArg, C: SingleArgCollection<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 ) -> PreparedCommand<'a, Self, f64>

where Self: Sized, K: SingleArg, M: SingleArg,

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 ) -> PreparedCommand<'a, Self, Vec<E>>

where Self: Sized, K: SingleArg, C: SingleArgCollection<K>, W: SingleArgCollection<f64>, E: PrimitiveResponse + DeserializeOwned,

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 ) -> PreparedCommand<'a, Self, Vec<(E, f64)>>

where Self: Sized, K: SingleArg, C: SingleArgCollection<K>, W: SingleArgCollection<f64>, E: PrimitiveResponse + DeserializeOwned,

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 ) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg, C: SingleArgCollection<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 ) -> PreparedCommand<'a, Self, usize>

where Self: Sized, D: SingleArg, K: SingleArg, C: SingleArgCollection<K>, W: SingleArgCollection<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 ) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg, M1: SingleArg, M2: SingleArg,

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 ) -> PreparedCommand<'a, Self, Option<ZMPopResult<E>>>

where Self: Sized, K: SingleArg, C: SingleArgCollection<K>, E: PrimitiveResponse + DeserializeOwned,

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 ) -> PreparedCommand<'a, Self, Vec<Option<f64>>>

where Self: Sized, K: SingleArg, M: SingleArg, C: SingleArgCollection<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 ) -> PreparedCommand<'a, Self, Vec<(M, f64)>>

where Self: Sized, K: SingleArg, M: PrimitiveResponse + DeserializeOwned,

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 ) -> PreparedCommand<'a, Self, Vec<(M, f64)>>

where Self: Sized, K: SingleArg, M: PrimitiveResponse + DeserializeOwned,

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) -> PreparedCommand<'a, Self, E>

where Self: Sized, K: SingleArg, E: PrimitiveResponse,

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

fn zrandmembers<K, E>( self, key: K, count: isize ) -> PreparedCommand<'a, Self, Vec<E>>

where Self: Sized, K: SingleArg, E: PrimitiveResponse + DeserializeOwned,

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

fn zrandmembers_with_scores<K, E>( self, key: K, count: isize ) -> PreparedCommand<'a, Self, Vec<E>>

where Self: Sized, K: SingleArg, E: DeserializeOwned,

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 ) -> PreparedCommand<'a, Self, Vec<E>>

where Self: Sized, K: SingleArg, S: SingleArg, E: PrimitiveResponse + DeserializeOwned,

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 ) -> PreparedCommand<'a, Self, Vec<(E, f64)>>

where Self: Sized, K: SingleArg, S: SingleArg, E: PrimitiveResponse + DeserializeOwned,

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 ) -> PreparedCommand<'a, Self, usize>

where Self: Sized, D: SingleArg, S: SingleArg, SS: SingleArg,

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

fn zrank<K, M>( self, key: K, member: M ) -> PreparedCommand<'a, Self, Option<usize>>

where Self: Sized, K: SingleArg, M: SingleArg,

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) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg, M: SingleArg, C: SingleArgCollection<M>,

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

fn zremrangebylex<K, S>( self, key: K, start: S, stop: S ) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg, S: SingleArg,

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 ) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg,

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 ) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg, S: SingleArg,

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 ) -> PreparedCommand<'a, Self, Option<usize>>

where Self: Sized, K: SingleArg, M: SingleArg,

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 ) -> PreparedCommand<'a, Self, ZScanResult<M>>

where Self: Sized, K: SingleArg, M: PrimitiveResponse + DeserializeOwned,

Iterates elements of Sorted Set types and their associated scores.

fn zscore<K, M>( self, key: K, member: M ) -> PreparedCommand<'a, Self, Option<f64>>

where Self: Sized, K: SingleArg, M: SingleArg,

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 ) -> PreparedCommand<'a, Self, Vec<E>>

where Self: Sized, K: SingleArg, C: SingleArgCollection<K>, W: SingleArgCollection<f64>, E: PrimitiveResponse + DeserializeOwned,

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 ) -> PreparedCommand<'a, Self, Vec<(E, f64)>>

where Self: Sized, K: SingleArg, C: SingleArgCollection<K>, W: SingleArgCollection<f64>, E: PrimitiveResponse + DeserializeOwned,

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 ) -> PreparedCommand<'a, Self, usize>

where Self: Sized, D: SingleArg, K: SingleArg, C: SingleArgCollection<K>, W: SingleArgCollection<f64>,

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

impl<'a> StreamCommands<'a> for &'a Client

fn xack<K, G, I, II>( self, key: K, group: G, ids: II ) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg, G: SingleArg, I: SingleArg, II: SingleArgCollection<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 ) -> PreparedCommand<'a, Self, R>

where Self: Sized, K: SingleArg, I: SingleArg, F: SingleArg, V: SingleArg, FFVV: KeyValueArgsCollection<F, V>, R: PrimitiveResponse,

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 ) -> PreparedCommand<'a, Self, XAutoClaimResult<V>>

where Self: Sized, K: SingleArg, G: SingleArg, C: SingleArg, I: SingleArg, V: PrimitiveResponse + DeserializeOwned,

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 ) -> PreparedCommand<'a, Self, Vec<StreamEntry<V>>>

where Self: Sized, K: SingleArg, G: SingleArg, C: SingleArg, I: SingleArg, II: SingleArgCollection<I>, V: PrimitiveResponse + DeserializeOwned,

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) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg, I: SingleArg, II: SingleArgCollection<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 ) -> PreparedCommand<'a, Self, bool>

where Self: Sized, K: SingleArg, G: SingleArg, I: SingleArg,

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

fn xgroup_createconsumer<K, G, C>( self, key: K, groupname: G, consumername: C ) -> PreparedCommand<'a, Self, bool>

where Self: Sized, K: SingleArg, G: SingleArg, C: SingleArg,

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 ) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg, G: SingleArg, C: SingleArg,

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

fn xgroup_destroy<K, G>( self, key: K, groupname: G ) -> PreparedCommand<'a, Self, bool>

where Self: Sized, K: SingleArg, G: SingleArg,

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> ) -> PreparedCommand<'a, Self, ()>

where Self: Sized, K: SingleArg, G: SingleArg, I: SingleArg,

Set the last delivered ID for a consumer group.

fn xinfo_consumers<K, G>( self, key: K, groupname: G ) -> PreparedCommand<'a, Self, Vec<XConsumerInfo>>

where Self: Sized, K: SingleArg, G: SingleArg,

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) -> PreparedCommand<'a, Self, Vec<XGroupInfo>>

where Self: Sized, K: SingleArg,

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 ) -> PreparedCommand<'a, Self, XStreamInfo>

where Self: Sized, K: SingleArg,

This command returns information about the stream stored at key.

fn xlen<K>(self, key: K) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg,

Returns the number of entries inside a stream.

fn xpending<K, G>( self, key: K, group: G ) -> PreparedCommand<'a, Self, XPendingResult>

where Self: Sized, K: SingleArg, G: SingleArg,

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 ) -> PreparedCommand<'a, Self, Vec<XPendingMessageResult>>

where Self: Sized, K: SingleArg, G: SingleArg,

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> ) -> PreparedCommand<'a, Self, Vec<StreamEntry<V>>>

where Self: Sized, K: SingleArg, S: SingleArg, E: SingleArg, V: PrimitiveResponse + DeserializeOwned,

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

fn xread<K, KK, I, II, V, R>( self, options: XReadOptions, keys: KK, ids: II ) -> PreparedCommand<'a, Self, R>

where Self: Sized, K: SingleArg, KK: SingleArgCollection<K>, I: SingleArg, II: SingleArgCollection<I>, V: PrimitiveResponse + DeserializeOwned, R: KeyValueCollectionResponse<String, Vec<StreamEntry<V>>>,

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, R>( self, group: G, consumer: C, options: XReadGroupOptions, keys: KK, ids: II ) -> PreparedCommand<'a, Self, R>

where Self: Sized, G: SingleArg, C: SingleArg, K: SingleArg, KK: SingleArgCollection<K>, I: SingleArg, II: SingleArgCollection<I>, V: PrimitiveResponse + DeserializeOwned, R: KeyValueCollectionResponse<String, Vec<StreamEntry<V>>>,

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> ) -> PreparedCommand<'a, Self, Vec<StreamEntry<V>>>

where Self: Sized, K: SingleArg, E: SingleArg, S: SingleArg, V: PrimitiveResponse + DeserializeOwned,

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 ) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg,

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

impl<'a> StringCommands<'a> for &'a Client

fn append<K, V>(self, key: K, value: V) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg, V: SingleArg,

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) -> PreparedCommand<'a, Self, i64>

where Self: Sized, K: SingleArg,

Decrements the number stored at key by one.

fn decrby<K>(self, key: K, decrement: i64) -> PreparedCommand<'a, Self, i64>

where Self: Sized, K: SingleArg,

Decrements the number stored at key by one.

fn get<K, V>(self, key: K) -> PreparedCommand<'a, Self, V>

where Self: Sized, K: SingleArg, V: PrimitiveResponse,

Get the value of key.

fn getdel<K, V>(self, key: K) -> PreparedCommand<'a, Self, V>

where Self: Sized, K: SingleArg, V: PrimitiveResponse,

Get the value of key and delete the key.

fn getex<K, V>( self, key: K, options: GetExOptions ) -> PreparedCommand<'a, Self, V>

where Self: Sized, K: SingleArg, V: PrimitiveResponse,

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 ) -> PreparedCommand<'a, Self, V>

where Self: Sized, K: SingleArg, V: PrimitiveResponse,

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) -> PreparedCommand<'a, Self, R>

where Self: Sized, K: SingleArg, V: SingleArg, R: PrimitiveResponse,

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) -> PreparedCommand<'a, Self, i64>

where Self: Sized, K: SingleArg,

Increments the number stored at key by one.

fn incrby<K>(self, key: K, increment: i64) -> PreparedCommand<'a, Self, i64>

where Self: Sized, K: SingleArg,

Increments the number stored at key by increment.

fn incrbyfloat<K>( self, key: K, increment: f64 ) -> PreparedCommand<'a, Self, f64>

where Self: Sized, K: SingleArg,

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) -> PreparedCommand<'a, Self, V>

where Self: Sized, K: SingleArg, V: PrimitiveResponse,

The LCS command implements the longest common subsequence algorithm

fn lcs_len<K>(self, key1: K, key2: K) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg,

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 ) -> PreparedCommand<'a, Self, LcsResult>

where Self: Sized, K: SingleArg,

The LCS command implements the longest common subsequence algorithm

fn mget<K, KK, V, VV>(self, keys: KK) -> PreparedCommand<'a, Self, VV>

where Self: Sized, K: SingleArg, KK: SingleArgCollection<K>, V: PrimitiveResponse + DeserializeOwned, VV: CollectionResponse<V>,

Returns the values of all specified keys.

fn mset<K, V, C>(self, items: C) -> PreparedCommand<'a, Self, ()>

where Self: Sized, C: KeyValueArgsCollection<K, V>, K: SingleArg, V: SingleArg,

Sets the given keys to their respective values.

fn msetnx<K, V, C>(self, items: C) -> PreparedCommand<'a, Self, bool>

where Self: Sized, C: KeyValueArgsCollection<K, V>, K: SingleArg, V: SingleArg,

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 ) -> PreparedCommand<'a, Self, ()>

where Self: Sized, K: SingleArg, V: SingleArg,

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) -> PreparedCommand<'a, Self, ()>

where Self: Sized, K: SingleArg, V: SingleArg,

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 ) -> PreparedCommand<'a, Self, bool>

where Self: Sized, K: SingleArg, V: SingleArg,

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 ) -> PreparedCommand<'a, Self, V2>

where Self: Sized, K: SingleArg, V1: SingleArg, V2: PrimitiveResponse,

Set key to hold the string value wit GET option enforced

fn setex<K, V>( self, key: K, seconds: u64, value: V ) -> PreparedCommand<'a, Self, ()>

where Self: Sized, K: SingleArg, V: SingleArg,

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) -> PreparedCommand<'a, Self, bool>

where Self: Sized, K: SingleArg, V: SingleArg,

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

fn setrange<K, V>( self, key: K, offset: usize, value: V ) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg, V: SingleArg,

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) -> PreparedCommand<'a, Self, usize>

where Self: Sized, K: SingleArg,

Returns the length of the string value stored at key.

impl<'a> TDigestCommands<'a> for &'a Client

Available on crate feature redis-bloom only.

fn tdigest_add( self, key: impl SingleArg, values: impl SingleArgCollection<f64> ) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

Adds one or more observations to a t-digest sketch.

fn tdigest_byrank<R: CollectionResponse<f64>>( self, key: impl SingleArg, ranks: impl SingleArgCollection<usize> ) -> PreparedCommand<'a, Self, R>

where Self: Sized,

Returns, for each input rank, an estimation of the value (floating-point) with that rank.

fn tdigest_byrevrank<R: CollectionResponse<f64>>( self, key: impl SingleArg, ranks: impl SingleArgCollection<usize> ) -> PreparedCommand<'a, Self, R>

where Self: Sized,

Returns, for each input reverse rank, an estimation of the value (floating-point) with that reverse rank.

fn tdigest_cdf<V: SingleArg, R: CollectionResponse<f64>>( self, key: impl SingleArg, values: impl SingleArgCollection<V> ) -> PreparedCommand<'a, Self, R>

where Self: Sized,

Returns, for each input reverse rank, an estimation of the value (floating-point) with that reverse rank.

fn tdigest_create( self, key: impl SingleArg, compression: Option<i64> ) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

Allocates memory and initializes a new t-digest sketch.

fn tdigest_info( self, key: impl SingleArg ) -> PreparedCommand<'a, Self, TDigestInfoResult>

where Self: Sized,

Returns information and statistics about a t-digest sketch

fn tdigest_max(self, key: impl SingleArg) -> PreparedCommand<'a, Self, f64>

where Self: Sized,

Returns the maximum observation value from a t-digest sketch.

fn tdigest_merge<S: SingleArg>( self, destination: impl SingleArg, sources: impl SingleArgCollection<S>, options: TDigestMergeOptions ) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

Merges multiple t-digest sketches into a single sketch.

fn tdigest_min(self, key: impl SingleArg) -> PreparedCommand<'a, Self, f64>

where Self: Sized,

Returns the minimum observation value from a t-digest sketch.

fn tdigest_quantile<Q: SingleArg, R: CollectionResponse<f64>>( self, key: impl SingleArg, quantiles: impl SingleArgCollection<Q> ) -> PreparedCommand<'a, Self, R>

where Self: Sized,

Returns, for each input fraction, an estimation of the value (floating point) that is smaller than the given fraction of observations.

fn tdigest_rank<V: SingleArg, R: CollectionResponse<isize>>( self, key: impl SingleArg, values: impl SingleArgCollection<V> ) -> PreparedCommand<'a, Self, R>

where Self: Sized,

Returns, for each input value (floating-point), the estimated rank of the value (the number of observations in the sketch that are smaller than the value + half the number of observations that are equal to the value).

fn tdigest_reset(self, key: impl SingleArg) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

Resets a t-digest sketch: empty the sketch and re-initializes it.

fn tdigest_revrank<V: SingleArg, R: CollectionResponse<isize>>( self, key: impl SingleArg, values: impl SingleArgCollection<V> ) -> PreparedCommand<'a, Self, R>

where Self: Sized,

Returns, for each input value (floating-point), the estimated reverse rank of the value (the number of observations in the sketch that are smaller than the value + half the number of observations that are equal to the value).

fn tdigest_trimmed_mean( self, key: impl SingleArg, low_cut_quantile: f64, high_cut_quantile: f64 ) -> PreparedCommand<'a, Self, f64>

where Self: Sized,

Returns an estimation of the mean value from the sketch, excluding observation values outside the low and high cutoff quantiles.

impl<'a> TimeSeriesCommands<'a> for &'a Client

Available on crate feature redis-time-series only.

fn ts_add( self, key: impl SingleArg, timestamp: impl SingleArg, value: f64, options: TsAddOptions ) -> PreparedCommand<'a, Self, u64>

where Self: Sized,

Append a sample to a time series

fn ts_alter( self, key: impl SingleArg, options: TsCreateOptions ) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

Update the retention, chunk size, duplicate policy, and labels of an existing time series

fn ts_create( self, key: impl SingleArg, options: TsCreateOptions ) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

Create a new time series

fn ts_createrule( self, src_key: impl SingleArg, dst_key: impl SingleArg, aggregator: TsAggregationType, bucket_duration: u64, options: TsCreateRuleOptions ) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

Create a compaction rule

fn ts_decrby( self, key: impl SingleArg, value: f64, options: TsIncrByDecrByOptions ) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

Decrease the value of the sample with the maximum existing timestamp, or create a new sample with a value equal to the value of the sample with the maximum existing timestamp with a given decrement

fn ts_del( self, key: impl SingleArg, from_timestamp: u64, to_timestamp: u64 ) -> PreparedCommand<'a, Self, usize>

where Self: Sized,

Delete all samples between two timestamps for a given time series

fn ts_deleterule( self, src_key: impl SingleArg, dst_key: impl SingleArg ) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

Delete a compaction rule

fn ts_get( self, key: impl SingleArg, options: TsGetOptions ) -> PreparedCommand<'a, Self, Option<(u64, f64)>>

where Self: Sized,

Get the last sample

fn ts_incrby( self, key: impl SingleArg, value: f64, options: TsIncrByDecrByOptions ) -> PreparedCommand<'a, Self, u64>

where Self: Sized,

Increase the value of the sample with the maximum existing timestamp, or create a new sample with a value equal to the value of the sample with the maximum existing timestamp with a given increment

fn ts_info( self, key: impl SingleArg, debug: bool ) -> PreparedCommand<'a, Self, TsInfoResult>

where Self: Sized,

Return information and statistics for a time series.

fn ts_madd<K: SingleArg, T: SingleArg, R: CollectionResponse<u64>>( self, items: impl MultipleArgsCollection<(K, T, f64)> ) -> PreparedCommand<'a, Self, R>

where Self: Sized,

Append new samples to one or more time series

fn ts_mget<F: SingleArg, R: CollectionResponse<TsSample>>( self, options: TsMGetOptions, filters: impl SingleArgCollection<F> ) -> PreparedCommand<'a, Self, R>

where Self: Sized,

Get the last samples matching a specific filter

fn ts_mrange<F: SingleArg, R: CollectionResponse<TsRangeSample>>( self, from_timestamp: impl SingleArg, to_timestamp: impl SingleArg, options: TsMRangeOptions, filters: impl SingleArgCollection<F>, groupby_options: TsGroupByOptions ) -> PreparedCommand<'a, Self, R>

where Self: Sized,

Query a range across multiple time series by filters in forward direction

fn ts_mrevrange<F: SingleArg, R: CollectionResponse<TsRangeSample>>( self, from_timestamp: impl SingleArg, to_timestamp: impl SingleArg, options: TsMRangeOptions, filters: impl SingleArgCollection<F>, groupby_options: TsGroupByOptions ) -> PreparedCommand<'a, Self, R>

where Self: Sized,

Query a range across multiple time series by filters in reverse direction

fn ts_queryindex<F: SingleArg, R: PrimitiveResponse + DeserializeOwned, RR: CollectionResponse<R>>( self, filters: impl SingleArgCollection<F> ) -> PreparedCommand<'a, Self, RR>

where Self: Sized,

Get all time series keys matching a filter list

fn ts_range<R: CollectionResponse<(u64, f64)>>( self, key: impl SingleArg, from_timestamp: impl SingleArg, to_timestamp: impl SingleArg, options: TsRangeOptions ) -> PreparedCommand<'a, Self, R>

where Self: Sized,

Query a range in forward direction

fn ts_revrange<R: CollectionResponse<(u64, f64)>>( self, key: impl SingleArg, from_timestamp: impl SingleArg, to_timestamp: impl SingleArg, options: TsRangeOptions ) -> PreparedCommand<'a, Self, R>

where Self: Sized,

Query a range in reverse direction

impl<'a> TopKCommands<'a> for &'a Client

Available on crate feature redis-bloom only.

fn topk_add<I: SingleArg, R: PrimitiveResponse + DeserializeOwned, RR: CollectionResponse<R>>( self, key: impl SingleArg, items: impl SingleArgCollection<I> ) -> PreparedCommand<'a, Self, RR>

where Self: Sized,

Adds an item to the data structure.

fn topk_incrby<I: SingleArg, R: PrimitiveResponse + DeserializeOwned, RR: CollectionResponse<R>>( self, key: impl SingleArg, items: impl KeyValueArgsCollection<I, i64> ) -> PreparedCommand<'a, Self, RR>

where Self: Sized,

Increase the score of an item in the data structure by increment.

fn topk_info( self, key: impl SingleArg ) -> PreparedCommand<'a, Self, TopKInfoResult>

where Self: Sized,

Returns number of required items (k), width, depth and decay values.

fn topk_list<R: PrimitiveResponse + DeserializeOwned, RR: CollectionResponse<R>>( self, key: impl SingleArg ) -> PreparedCommand<'a, Self, RR>

where Self: Sized,

Return full list of items in Top K list.

fn topk_list_with_count<N: PrimitiveResponse + DeserializeOwned>( self, key: impl SingleArg ) -> PreparedCommand<'a, Self, TopKListWithCountResult<N>>

where Self: Sized,

Return full list of items in Top K list.

fn topk_query<I: SingleArg, R: CollectionResponse<bool>>( self, key: impl SingleArg, items: impl SingleArgCollection<I> ) -> PreparedCommand<'a, Self, R>

where Self: Sized,

Return full list of items in Top K list.

fn topk_reserve( self, key: impl SingleArg, topk: usize, width_depth_decay: Option<(usize, usize, f64)> ) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

Initializes a TopK with specified parameters.

impl<'a> TransactionCommands<'a> for &'a Client

fn watch<K, KK>(self, keys: KK) -> PreparedCommand<'a, Self, ()>

where Self: Sized, K: SingleArg, KK: SingleArgCollection<K>,

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

fn unwatch(self) -> PreparedCommand<'a, Self, ()>

where Self: Sized,

Flushes all the previously watched keys for a transaction.