redis::aio

Struct ConnectionManager

Source 
pub struct ConnectionManager(/* private fields */);
Expand description

A ConnectionManager is a proxy that wraps a multiplexed connection and automatically reconnects to the server when necessary.

Like the MultiplexedConnection, this manager can be cloned, allowing requests to be sent concurrently on the same underlying connection (tcp/unix socket).

§Behavior

  • When creating an instance of the ConnectionManager, an initial connection will be established and awaited. Connection errors will be returned directly.
  • When a command sent to the server fails with an error that represents a “connection dropped” condition, that error will be passed on to the user, but it will trigger a reconnection in the background.
  • The reconnect code will atomically swap the current (dead) connection with a future that will eventually resolve to a MultiplexedConnection or to a RedisError
  • All commands that are issued after the reconnect process has been initiated, will have to await the connection future.
  • If reconnecting fails, all pending commands will be failed as well. A new reconnection attempt will be triggered if the error is an I/O error.

Implementations§

Source§

impl ConnectionManager

Source

pub async fn new(client: Client) -> RedisResult<Self>

Connect to the server and store the connection inside the returned ConnectionManager.

This requires the connection-manager feature, which will also pull in the Tokio executor.

Source

pub async fn new_with_backoff( client: Client, exponent_base: u64, factor: u64, number_of_retries: usize, ) -> RedisResult<Self>

👎Deprecated: Use new_with_config

Connect to the server and store the connection inside the returned ConnectionManager.

This requires the connection-manager feature, which will also pull in the Tokio executor.

In case of reconnection issues, the manager will retry reconnection number_of_retries times, with an exponentially increasing delay, calculated as rand(0 .. factor * (exponent_base ^ current-try)).

Source

pub async fn new_with_backoff_and_timeouts( client: Client, exponent_base: u64, factor: u64, number_of_retries: usize, response_timeout: Duration, connection_timeout: Duration, ) -> RedisResult<Self>

👎Deprecated: Use new_with_config

Connect to the server and store the connection inside the returned ConnectionManager.

This requires the connection-manager feature, which will also pull in the Tokio executor.

In case of reconnection issues, the manager will retry reconnection number_of_retries times, with an exponentially increasing delay, calculated as rand(0 .. factor * (exponent_base ^ current-try)).

The new connection will time out operations after response_timeout has passed. Each connection attempt to the server will time out after connection_timeout.

Source

pub async fn new_with_config( client: Client, config: ConnectionManagerConfig, ) -> RedisResult<Self>

Connect to the server and store the connection inside the returned ConnectionManager.

This requires the connection-manager feature, which will also pull in the Tokio executor.

In case of reconnection issues, the manager will retry reconnection number_of_retries times, with an exponentially increasing delay, calculated as rand(0 .. factor * (exponent_base ^ current-try)).

Apply a maximum delay. No retry delay will be longer than this ConnectionManagerConfig.max_delay` .

The new connection will time out operations after response_timeout has passed. Each connection attempt to the server will time out after connection_timeout.

Source

pub async fn send_packed_command(&mut self, cmd: &Cmd) -> RedisResult<Value>

Sends an already encoded (packed) command into the TCP socket and reads the single response from it.

Source

pub async fn send_packed_commands( &mut self, cmd: &Pipeline, offset: usize, count: usize, ) -> RedisResult<Vec<Value>>

Sends multiple already encoded (packed) command into the TCP socket and reads count responses from it. This is used to implement pipelining.

Source

pub async fn subscribe( &mut self, channel_name: impl ToRedisArgs, ) -> RedisResult<()>

Subscribes to a new channel(s).

Updates from the sender will be sent on the push sender that was passed to the manager. If the manager was configured without a push sender, the connection won’t be able to pass messages back to the user.

This method is only available when the connection is using RESP3 protocol, and will return an error otherwise. It should be noted that unless ConnectionManagerConfig::set_automatic_resubscription was called, the subscription will be removed on a disconnect and must be re-subscribed.

Source

pub async fn unsubscribe( &mut self, channel_name: impl ToRedisArgs, ) -> RedisResult<()>

Unsubscribes from channel(s).

This method is only available when the connection is using RESP3 protocol, and will return an error otherwise.

Source

pub async fn psubscribe( &mut self, channel_pattern: impl ToRedisArgs, ) -> RedisResult<()>

Subscribes to new channel(s) with pattern(s).

Updates from the sender will be sent on the push sender that was passed to the manager. If the manager was configured without a push sender, the manager won’t be able to pass messages back to the user.

This method is only available when the connection is using RESP3 protocol, and will return an error otherwise. It should be noted that unless ConnectionManagerConfig::set_automatic_resubscription was called, the subscription will be removed on a disconnect and must be re-subscribed.

Source

pub async fn punsubscribe( &mut self, channel_pattern: impl ToRedisArgs, ) -> RedisResult<()>

Unsubscribes from channel pattern(s).

This method is only available when the connection is using RESP3 protocol, and will return an error otherwise.

Trait Implementations§

Source§

impl Clone for ConnectionManager

Source§

fn clone(&self) -> ConnectionManager

Returns a copy of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from source. Read more
Source§

impl ConnectionLike for ConnectionManager

Source§

fn req_packed_command<'a>(&'a mut self, cmd: &'a Cmd) -> RedisFuture<'a, Value>

Sends an already encoded (packed) command into the TCP socket and reads the single response from it.
Source§

fn get_db(&self) -> i64

Returns the database this connection is bound to. Note that this information might be unreliable because it’s initially cached and also might be incorrect if the connection like object is not actually connected.

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> AsyncCommands for T
where T: ConnectionLike + Send + Sync,

Source§

fn get<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Get the value of a key. If key is a vec this becomes an MGET.
Source§

fn mget<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Get values of keys
Source§

fn keys<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Gets all keys matching pattern
Source§

fn set<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, value: V, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Set the string value of a key.
Source§

fn set_options<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, value: V, options: SetOptions, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Set the string value of a key with options.
Source§

fn set_multiple<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, items: &'a [(K, V)], ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

👎Deprecated since 0.22.4: Renamed to mset() to reflect Redis name
Sets multiple keys to their values.
Source§

fn mset<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, items: &'a [(K, V)], ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Sets multiple keys to their values.
Source§

fn set_ex<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, value: V, seconds: u64, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Set the value and expiration of a key.
Source§

fn pset_ex<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, value: V, milliseconds: u64, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Set the value and expiration in milliseconds of a key.
Source§

fn set_nx<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, value: V, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Set the value of a key, only if the key does not exist
Source§

fn mset_nx<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, items: &'a [(K, V)], ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Sets multiple keys to their values failing if at least one already exists.
Source§

fn getset<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, value: V, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Set the string value of a key and return its old value.
Source§

fn getrange<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, from: isize, to: isize, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Get a range of bytes/substring from the value of a key. Negative values provide an offset from the end of the value.
Source§

fn setrange<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, offset: isize, value: V, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Overwrite the part of the value stored in key at the specified offset.
Source§

fn del<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Delete one or more keys.
Source§

fn exists<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Determine if a key exists.
Source§

fn key_type<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Determine the type of a key.
Source§

fn expire<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, seconds: i64, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Set a key’s time to live in seconds.
Source§

fn expire_at<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ts: i64, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Set the expiration for a key as a UNIX timestamp.
Source§

fn pexpire<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ms: i64, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Set a key’s time to live in milliseconds.
Source§

fn pexpire_at<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ts: i64, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Set the expiration for a key as a UNIX timestamp in milliseconds.
Source§

fn expire_time<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Get the absolute Unix expiration timestamp in seconds.
Source§

fn pexpire_time<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Get the absolute Unix expiration timestamp in milliseconds.
Source§

fn persist<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Remove the expiration from a key.
Source§

fn ttl<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Get the time to live for a key in seconds.
Source§

fn pttl<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Get the time to live for a key in milliseconds.
Source§

fn get_ex<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, expire_at: Expiry, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Get the value of a key and set expiration
Source§

fn get_del<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Get the value of a key and delete it
Source§

fn rename<'a, K: ToRedisArgs + Send + Sync + 'a, N: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, new_key: N, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Rename a key.
Source§

fn rename_nx<'a, K: ToRedisArgs + Send + Sync + 'a, N: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, new_key: N, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Rename a key, only if the new key does not exist.
Unlink one or more keys.
Source§

fn append<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, value: V, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Append a value to a key.
Source§

fn incr<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, delta: V, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Increment the numeric value of a key by the given amount. This issues a INCRBY or INCRBYFLOAT depending on the type.
Source§

fn decr<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, delta: V, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Decrement the numeric value of a key by the given amount.
Source§

fn setbit<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, offset: usize, value: bool, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

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

fn getbit<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, offset: usize, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

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

fn bitcount<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Count set bits in a string.
Source§

fn bitcount_range<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, start: usize, end: usize, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Count set bits in a string in a range.
Source§

fn bit_and<'a, D: ToRedisArgs + Send + Sync + 'a, S: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, srckeys: S, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

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

fn bit_or<'a, D: ToRedisArgs + Send + Sync + 'a, S: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, srckeys: S, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

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

fn bit_xor<'a, D: ToRedisArgs + Send + Sync + 'a, S: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, srckeys: S, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

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

fn bit_not<'a, D: ToRedisArgs + Send + Sync + 'a, S: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, srckey: S, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Perform a bitwise NOT of the key (containing string values) and store the result in the destination key.
Source§

fn strlen<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Get the length of the value stored in a key.
Source§

fn hget<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, field: F, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Gets a single (or multiple) fields from a hash.
Source§

fn hdel<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, field: F, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Deletes a single (or multiple) fields from a hash.
Source§

fn hset<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, field: F, value: V, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Sets a single field in a hash.
Source§

fn hset_nx<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, field: F, value: V, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Sets a single field in a hash if it does not exist.
Source§

fn hset_multiple<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, items: &'a [(F, V)], ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Sets multiple fields in a hash.
Source§

fn hincr<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, D: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, field: F, delta: D, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Increments a value.
Source§

fn hexists<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, field: F, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Checks if a field in a hash exists.
Source§

fn httl<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, fields: F, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Get one or more fields’ TTL in seconds.
Source§

fn hpttl<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, fields: F, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Get one or more fields’ TTL in milliseconds.
Source§

fn hexpire<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, seconds: i64, opt: ExpireOption, fields: F, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Set one or more fields’ time to live in seconds.
Source§

fn hexpire_at<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ts: i64, opt: ExpireOption, fields: F, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Set the expiration for one or more fields as a UNIX timestamp in milliseconds.
Source§

fn hexpire_time<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, fields: F, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Returns the absolute Unix expiration timestamp in seconds.
Source§

fn hpersist<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, fields: F, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Remove the expiration from a key.
Source§

fn hpexpire<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, milliseconds: i64, opt: ExpireOption, fields: F, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Set one or more fields’ time to live in milliseconds.
Source§

fn hpexpire_at<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ts: i64, opt: ExpireOption, fields: F, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Set the expiration for one or more fields as a UNIX timestamp in milliseconds.
Source§

fn hpexpire_time<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, fields: F, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Returns the absolute Unix expiration timestamp in seconds.
Source§

fn hkeys<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Gets all the keys in a hash.
Source§

fn hvals<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Gets all the values in a hash.
Source§

fn hgetall<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Gets all the fields and values in a hash.
Source§

fn hlen<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Gets the length of a hash.
Source§

fn blmove<'a, S: ToRedisArgs + Send + Sync + 'a, D: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, srckey: S, dstkey: D, src_dir: Direction, dst_dir: Direction, timeout: f64, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Pop an element from a list, push it to another list and return it; or block until one is available
Source§

fn blmpop<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, timeout: f64, numkeys: usize, key: K, dir: Direction, count: usize, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Pops count elements from the first non-empty list key from the list of provided key names; or blocks until one is available.
Source§

fn blpop<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, timeout: f64, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Remove and get the first element in a list, or block until one is available.
Source§

fn brpop<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, timeout: f64, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Remove and get the last element in a list, or block until one is available.
Source§

fn brpoplpush<'a, S: ToRedisArgs + Send + Sync + 'a, D: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, srckey: S, dstkey: D, timeout: f64, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Pop a value from a list, push it to another list and return it; or block until one is available.
Source§

fn lindex<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, index: isize, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Get an element from a list by its index.
Source§

fn linsert_before<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, pivot: P, value: V, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Insert an element before another element in a list.
Source§

fn linsert_after<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, pivot: P, value: V, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Insert an element after another element in a list.
Source§

fn llen<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Returns the length of the list stored at key.
Source§

fn lmove<'a, S: ToRedisArgs + Send + Sync + 'a, D: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, srckey: S, dstkey: D, src_dir: Direction, dst_dir: Direction, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Pop an element a list, push it to another list and return it
Source§

fn lmpop<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, numkeys: usize, key: K, dir: Direction, count: usize, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Pops count elements from the first non-empty list key from the list of provided key names.
Source§

fn lpop<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, count: Option<NonZeroUsize>, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Removes and returns the up to count first elements of the list stored at key. Read more
Source§

fn lpos<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, value: V, options: LposOptions, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Returns the index of the first matching value of the list stored at key.
Source§

fn lpush<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, value: V, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Insert all the specified values at the head of the list stored at key.
Source§

fn lpush_exists<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, value: V, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Inserts a value at the head of the list stored at key, only if key already exists and holds a list.
Source§

fn lrange<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, start: isize, stop: isize, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Returns the specified elements of the list stored at key.
Source§

fn lrem<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, count: isize, value: V, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Removes the first count occurrences of elements equal to value from the list stored at key.
Source§

fn ltrim<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, start: isize, stop: isize, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

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

fn lset<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, index: isize, value: V, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Sets the list element at index to value
Source§

fn ping<'a, RV>(&'a mut self) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Sends a ping to the server
Source§

fn ping_message<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, message: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Sends a ping with a message to the server
Source§

fn rpop<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, count: Option<NonZeroUsize>, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Removes and returns the up to count last elements of the list stored at key Read more
Source§

fn rpoplpush<'a, K: ToRedisArgs + Send + Sync + 'a, D: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, dstkey: D, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Pop a value from a list, push it to another list and return it.
Source§

fn rpush<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, value: V, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Insert all the specified values at the tail of the list stored at key.
Source§

fn rpush_exists<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, value: V, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Inserts value at the tail of the list stored at key, only if key already exists and holds a list.
Source§

fn sadd<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, member: M, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Add one or more members to a set.
Source§

fn scard<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Get the number of members in a set.
Source§

fn sdiff<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, keys: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Subtract multiple sets.
Source§

fn sdiffstore<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, keys: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Subtract multiple sets and store the resulting set in a key.
Source§

fn sinter<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, keys: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Intersect multiple sets.
Source§

fn sinterstore<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, keys: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Intersect multiple sets and store the resulting set in a key.
Source§

fn sismember<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, member: M, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Determine if a given value is a member of a set.
Source§

fn smismember<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, members: M, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Determine if given values are members of a set.
Source§

fn smembers<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Get all the members in a set.
Source§

fn smove<'a, S: ToRedisArgs + Send + Sync + 'a, D: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, srckey: S, dstkey: D, member: M, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Move a member from one set to another.
Source§

fn spop<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Remove and return a random member from a set.
Source§

fn srandmember<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Get one random member from a set.
Source§

fn srandmember_multiple<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, count: usize, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Get multiple random members from a set.
Source§

fn srem<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, member: M, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Remove one or more members from a set.
Source§

fn sunion<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, keys: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Add multiple sets.
Source§

fn sunionstore<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, keys: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Add multiple sets and store the resulting set in a key.
Source§

fn zadd<'a, K: ToRedisArgs + Send + Sync + 'a, S: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, member: M, score: S, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Add one member to a sorted set, or update its score if it already exists.
Source§

fn zadd_multiple<'a, K: ToRedisArgs + Send + Sync + 'a, S: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, items: &'a [(S, M)], ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Add multiple members to a sorted set, or update its score if it already exists.
Source§

fn zcard<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Get the number of members in a sorted set.
Source§

fn zcount<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, min: M, max: MM, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Count the members in a sorted set with scores within the given values.
Source§

fn zincr<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, D: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, member: M, delta: D, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Increments the member in a sorted set at key by delta. If the member does not exist, it is added with delta as its score.
Source§

fn zinterstore<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, keys: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Intersect multiple sorted sets and store the resulting sorted set in a new key using SUM as aggregation function.
Source§

fn zinterstore_min<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, keys: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Intersect multiple sorted sets and store the resulting sorted set in a new key using MIN as aggregation function.
Source§

fn zinterstore_max<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, keys: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Intersect multiple sorted sets and store the resulting sorted set in a new key using MAX as aggregation function.
Source§

fn zinterstore_weights<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, W: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, keys: &'a [(K, W)], ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Commands::zinterstore, but with the ability to specify a multiplication factor for each sorted set by pairing one with each key in a tuple.
Source§

fn zinterstore_min_weights<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, W: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, keys: &'a [(K, W)], ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Commands::zinterstore_min, but with the ability to specify a multiplication factor for each sorted set by pairing one with each key in a tuple.
Source§

fn zinterstore_max_weights<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, W: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, keys: &'a [(K, W)], ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Commands::zinterstore_max, but with the ability to specify a multiplication factor for each sorted set by pairing one with each key in a tuple.
Source§

fn zlexcount<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, min: M, max: MM, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Count the number of members in a sorted set between a given lexicographical range.
Source§

fn bzpopmax<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, timeout: f64, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Removes and returns the member with the highest score in a sorted set. Blocks until a member is available otherwise.
Source§

fn zpopmax<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, count: isize, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Removes and returns up to count members with the highest scores in a sorted set
Source§

fn bzpopmin<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, timeout: f64, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Removes and returns the member with the lowest score in a sorted set. Blocks until a member is available otherwise.
Source§

fn zpopmin<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, count: isize, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Removes and returns up to count members with the lowest scores in a sorted set
Source§

fn bzmpop_max<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, timeout: f64, keys: K, count: isize, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Removes and returns up to count members with the highest scores, from the first non-empty sorted set in the provided list of key names. Blocks until a member is available otherwise.
Source§

fn zmpop_max<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, keys: K, count: isize, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Removes and returns up to count members with the highest scores, from the first non-empty sorted set in the provided list of key names.
Source§

fn bzmpop_min<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, timeout: f64, keys: K, count: isize, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Removes and returns up to count members with the lowest scores, from the first non-empty sorted set in the provided list of key names. Blocks until a member is available otherwise.
Source§

fn zmpop_min<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, keys: K, count: isize, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Removes and returns up to count members with the lowest scores, from the first non-empty sorted set in the provided list of key names.
Source§

fn zrandmember<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, count: Option<isize>, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Return up to count random members in a sorted set (or 1 if count == None)
Source§

fn zrandmember_withscores<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, count: isize, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Return up to count random members in a sorted set with scores
Source§

fn zrange<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, start: isize, stop: isize, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Return a range of members in a sorted set, by index
Source§

fn zrange_withscores<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, start: isize, stop: isize, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Return a range of members in a sorted set, by index with scores.
Source§

fn zrangebylex<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, min: M, max: MM, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Return a range of members in a sorted set, by lexicographical range.
Source§

fn zrangebylex_limit<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, min: M, max: MM, offset: isize, count: isize, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Return a range of members in a sorted set, by lexicographical range with offset and limit.
Source§

fn zrevrangebylex<'a, K: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, max: MM, min: M, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Return a range of members in a sorted set, by lexicographical range.
Source§

fn zrevrangebylex_limit<'a, K: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, max: MM, min: M, offset: isize, count: isize, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Return a range of members in a sorted set, by lexicographical range with offset and limit.
Source§

fn zrangebyscore<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, min: M, max: MM, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Return a range of members in a sorted set, by score.
Source§

fn zrangebyscore_withscores<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, min: M, max: MM, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Return a range of members in a sorted set, by score with scores.
Source§

fn zrangebyscore_limit<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, min: M, max: MM, offset: isize, count: isize, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Return a range of members in a sorted set, by score with limit.
Source§

fn zrangebyscore_limit_withscores<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, min: M, max: MM, offset: isize, count: isize, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Return a range of members in a sorted set, by score with limit with scores.
Source§

fn zrank<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, member: M, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Determine the index of a member in a sorted set.
Source§

fn zrem<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, members: M, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Remove one or more members from a sorted set.
Source§

fn zrembylex<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, min: M, max: MM, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Remove all members in a sorted set between the given lexicographical range.
Source§

fn zremrangebyrank<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, start: isize, stop: isize, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Remove all members in a sorted set within the given indexes.
Source§

fn zrembyscore<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, min: M, max: MM, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Remove all members in a sorted set within the given scores.
Source§

fn zrevrange<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, start: isize, stop: isize, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Return a range of members in a sorted set, by index, with scores ordered from high to low.
Source§

fn zrevrange_withscores<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, start: isize, stop: isize, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Return a range of members in a sorted set, by index, with scores ordered from high to low.
Source§

fn zrevrangebyscore<'a, K: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, max: MM, min: M, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Return a range of members in a sorted set, by score.
Source§

fn zrevrangebyscore_withscores<'a, K: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, max: MM, min: M, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Return a range of members in a sorted set, by score with scores.
Source§

fn zrevrangebyscore_limit<'a, K: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, max: MM, min: M, offset: isize, count: isize, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Return a range of members in a sorted set, by score with limit.
Source§

fn zrevrangebyscore_limit_withscores<'a, K: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, max: MM, min: M, offset: isize, count: isize, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Return a range of members in a sorted set, by score with limit with scores.
Source§

fn zrevrank<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, member: M, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Determine the index of a member in a sorted set, with scores ordered from high to low.
Source§

fn zscore<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, member: M, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Get the score associated with the given member in a sorted set.
Source§

fn zscore_multiple<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, members: &'a [M], ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Get the scores associated with multiple members in a sorted set.
Source§

fn zunionstore<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, keys: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Unions multiple sorted sets and store the resulting sorted set in a new key using SUM as aggregation function.
Source§

fn zunionstore_min<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, keys: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Unions multiple sorted sets and store the resulting sorted set in a new key using MIN as aggregation function.
Source§

fn zunionstore_max<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, keys: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Unions multiple sorted sets and store the resulting sorted set in a new key using MAX as aggregation function.
Source§

fn zunionstore_weights<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, W: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, keys: &'a [(K, W)], ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Commands::zunionstore, but with the ability to specify a multiplication factor for each sorted set by pairing one with each key in a tuple.
Source§

fn zunionstore_min_weights<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, W: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, keys: &'a [(K, W)], ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Commands::zunionstore_min, but with the ability to specify a multiplication factor for each sorted set by pairing one with each key in a tuple.
Source§

fn zunionstore_max_weights<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, W: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, keys: &'a [(K, W)], ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Commands::zunionstore_max, but with the ability to specify a multiplication factor for each sorted set by pairing one with each key in a tuple.
Source§

fn pfadd<'a, K: ToRedisArgs + Send + Sync + 'a, E: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, element: E, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Adds the specified elements to the specified HyperLogLog.
Source§

fn pfcount<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

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

fn pfmerge<'a, D: ToRedisArgs + Send + Sync + 'a, S: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, srckeys: S, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Merge N different HyperLogLogs into a single one.
Source§

fn publish<'a, K: ToRedisArgs + Send + Sync + 'a, E: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, channel: K, message: E, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Posts a message to the given channel.
Source§

fn spublish<'a, K: ToRedisArgs + Send + Sync + 'a, E: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, channel: K, message: E, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Posts a message to the given sharded channel.
Source§

fn object_encoding<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Returns the encoding of a key.
Source§

fn object_idletime<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Returns the time in seconds since the last access of a key.
Source§

fn object_freq<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Returns the logarithmic access frequency counter of a key.
Source§

fn object_refcount<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Returns the reference count of a key.
Source§

fn client_getname<'a, RV>(&'a mut self) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Returns the name of the current connection as set by CLIENT SETNAME.
Source§

fn client_id<'a, RV>(&'a mut self) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Returns the ID of the current connection.
Source§

fn client_setname<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, connection_name: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Command assigns a name to the current connection.
Source§

fn xrevrange_all<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

This is the reverse version of xrange_all. The same rules apply for start and end here. Read more
Source§

fn flushall<'a, RV>(&'a mut self) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Deletes all the keys of all databases Read more
Source§

fn flushall_options<'a, RV>( &'a mut self, options: &'a FlushAllOptions, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Deletes all the keys of all databases with options Read more
Source§

fn flushdb<'a, RV>(&'a mut self) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Deletes all the keys of the current database Read more
Source§

fn flushdb_options<'a, RV>( &'a mut self, options: &'a FlushDbOptions, ) -> RedisFuture<'a, RV>
where RV: FromRedisValue,

Deletes all the keys of the current database with options Read more
Source§

fn scan<RV: FromRedisValue>(&mut self) -> RedisFuture<'_, AsyncIter<'_, RV>>

Incrementally iterate the keys space.
Source§

fn scan_options<RV: FromRedisValue>( &mut self, opts: ScanOptions, ) -> RedisFuture<'_, AsyncIter<'_, RV>>

Incrementally iterate the keys space with options.
Source§

fn scan_match<P: ToRedisArgs, RV: FromRedisValue>( &mut self, pattern: P, ) -> RedisFuture<'_, AsyncIter<'_, RV>>

Incrementally iterate set elements for elements matching a pattern.
Source§

fn hscan<K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ) -> RedisFuture<'_, AsyncIter<'_, RV>>

Incrementally iterate hash fields and associated values.
Source§

fn hscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, pattern: P, ) -> RedisFuture<'_, AsyncIter<'_, RV>>

Incrementally iterate hash fields and associated values for field names matching a pattern.
Source§

fn sscan<K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ) -> RedisFuture<'_, AsyncIter<'_, RV>>

Incrementally iterate set elements.
Source§

fn sscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, pattern: P, ) -> RedisFuture<'_, AsyncIter<'_, RV>>

Incrementally iterate set elements for elements matching a pattern.
Source§

fn zscan<K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ) -> RedisFuture<'_, AsyncIter<'_, RV>>

Incrementally iterate sorted set elements.
Source§

fn zscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, pattern: P, ) -> RedisFuture<'_, AsyncIter<'_, RV>>

Incrementally iterate sorted set elements for elements matching a pattern.
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dst: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<T> ErasedDestructor for T
where T: 'static,

Source§

impl<T> MaybeSendSync for T