pub struct MultiplexedConnection { /* private fields */ }
Expand description
A connection object which can be cloned, allowing requests to be be sent concurrently on the same underlying connection (tcp/unix socket).
This connection object is cancellation-safe, and the user can drop request future without polling them to completion,
but this doesn’t mean that the actual request sent to the server is cancelled.
A side-effect of this is that the underlying connection won’t be closed until all sent requests have been answered,
which means that in case of blocking commands, the underlying connection resource might not be released,
even when all clones of the multiplexed connection have been dropped (see https://github.com/redis-rs/redis-rs/issues/1236).
This isn’t an issue in a connection that was created in a canonical way, which ensures that _task_handle
is set, so that
once all of the connection’s clones are dropped, the task will also be dropped. If the user creates the connection in
another way and _task_handle
isn’t set, they should manually spawn the returned driver function, keep the spawned task’s
handle and abort the task whenever they want, at the risk of effectively closing the clones of the multiplexed connection.
Implementations§
Source§impl MultiplexedConnection
impl MultiplexedConnection
Sourcepub async fn new<C>(
connection_info: &RedisConnectionInfo,
stream: C,
) -> RedisResult<(Self, impl Future<Output = ()>)>
pub async fn new<C>( connection_info: &RedisConnectionInfo, stream: C, ) -> RedisResult<(Self, impl Future<Output = ()>)>
Constructs a new MultiplexedConnection
out of a AsyncRead + AsyncWrite
object
and a RedisConnectionInfo
Sourcepub async fn new_with_response_timeout<C>(
connection_info: &RedisConnectionInfo,
stream: C,
response_timeout: Option<Duration>,
) -> RedisResult<(Self, impl Future<Output = ()>)>
pub async fn new_with_response_timeout<C>( connection_info: &RedisConnectionInfo, stream: C, response_timeout: Option<Duration>, ) -> RedisResult<(Self, impl Future<Output = ()>)>
Constructs a new MultiplexedConnection
out of a AsyncRead + AsyncWrite
object
and a RedisConnectionInfo
. The new object will wait on operations for the given response_timeout
.
Sourcepub async fn new_with_config<C>(
connection_info: &RedisConnectionInfo,
stream: C,
config: AsyncConnectionConfig,
) -> RedisResult<(Self, impl Future<Output = ()>)>
pub async fn new_with_config<C>( connection_info: &RedisConnectionInfo, stream: C, config: AsyncConnectionConfig, ) -> RedisResult<(Self, impl Future<Output = ()>)>
Constructs a new MultiplexedConnection
out of a AsyncRead + AsyncWrite
object
, a RedisConnectionInfo
and a AsyncConnectionConfig
.
Sourcepub fn set_response_timeout(&mut self, timeout: Duration)
pub fn set_response_timeout(&mut self, timeout: Duration)
Sets the time that the multiplexer will wait for responses on operations before failing.
Sourcepub async fn send_packed_command(&mut self, cmd: &Cmd) -> RedisResult<Value>
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.
Sourcepub async fn send_packed_commands(
&mut self,
cmd: &Pipeline,
offset: usize,
count: usize,
) -> RedisResult<Vec<Value>>
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§impl MultiplexedConnection
impl MultiplexedConnection
Sourcepub async fn subscribe(
&mut self,
channel_name: impl ToRedisArgs,
) -> RedisResult<()>
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 connection. If the connection 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.
§async fn func() -> redis::RedisResult<()> {
let client = redis::Client::open(“redis://127.0.0.1/?protocol=resp3”).unwrap(); let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel(); let config = redis::AsyncConnectionConfig::new().set_push_sender(tx); let mut con = client.get_multiplexed_async_connection_with_config(&config).await?; con.subscribe(&[“channel_1”, “channel_2”]).await?;
§Ok(()) }
§}
Sourcepub async fn unsubscribe(
&mut self,
channel_name: impl ToRedisArgs,
) -> RedisResult<()>
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.
§async fn func() -> redis::RedisResult<()> {
let client = redis::Client::open(“redis://127.0.0.1/?protocol=resp3”).unwrap(); let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel(); let config = redis::AsyncConnectionConfig::new().set_push_sender(tx); let mut con = client.get_multiplexed_async_connection_with_config(&config).await?; con.subscribe(&[“channel_1”, “channel_2”]).await?; con.unsubscribe(&[“channel_1”, “channel_2”]).await?;
§Ok(()) }
§}
Sourcepub async fn psubscribe(
&mut self,
channel_pattern: impl ToRedisArgs,
) -> RedisResult<()>
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 connection. If the connection 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.
§async fn func() -> redis::RedisResult<()> {
let client = redis::Client::open(“redis://127.0.0.1/?protocol=resp3”).unwrap(); let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel(); let config = redis::AsyncConnectionConfig::new().set_push_sender(tx); let mut con = client.get_multiplexed_async_connection_with_config(&config).await?; con.subscribe(&[“channel_1”, “channel_2”]).await?; con.unsubscribe(&[“channel_1”, “channel_2”]).await?;
§Ok(()) }
§}
Sourcepub async fn punsubscribe(
&mut self,
channel_pattern: impl ToRedisArgs,
) -> RedisResult<()>
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 MultiplexedConnection
impl Clone for MultiplexedConnection
Source§fn clone(&self) -> MultiplexedConnection
fn clone(&self) -> MultiplexedConnection
1.0.0 · Source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read moreSource§impl ConnectionLike for MultiplexedConnection
impl ConnectionLike for MultiplexedConnection
Source§fn req_packed_command<'a>(&'a mut self, cmd: &'a Cmd) -> RedisFuture<'a, Value>
fn req_packed_command<'a>(&'a mut self, cmd: &'a Cmd) -> RedisFuture<'a, Value>
Auto Trait Implementations§
impl Freeze for MultiplexedConnection
impl RefUnwindSafe for MultiplexedConnection
impl Send for MultiplexedConnection
impl Sync for MultiplexedConnection
impl Unpin for MultiplexedConnection
impl UnwindSafe for MultiplexedConnection
Blanket Implementations§
Source§impl<T> AsyncCommands for T
impl<T> AsyncCommands for T
Source§fn get<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn get<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
MGET
.Source§fn mget<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn mget<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
Source§fn keys<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn keys<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
fn getrange<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
from: isize,
to: isize,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
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,
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,
Source§fn del<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn del<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
Source§fn exists<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn exists<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
Source§fn key_type<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn key_type<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
Source§fn expire<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
seconds: i64,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn expire<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
seconds: i64,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
Source§fn expire_at<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
ts: i64,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn expire_at<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
ts: i64,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
Source§fn pexpire<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
ms: i64,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn pexpire<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
ms: i64,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
Source§fn pexpire_at<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
ts: i64,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn pexpire_at<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
ts: i64,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
Source§fn expire_time<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn expire_time<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
Source§fn pexpire_time<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn pexpire_time<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
Source§fn persist<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn persist<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
Source§fn ttl<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn ttl<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
Source§fn pttl<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn pttl<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
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,
fn get_ex<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
expire_at: Expiry,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
Source§fn get_del<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn get_del<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
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,
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,
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,
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,
Source§fn unlink<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn unlink<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
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,
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,
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,
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,
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,
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,
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,
fn setbit<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
offset: usize,
value: bool,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
Source§fn getbit<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
offset: usize,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn getbit<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
offset: usize,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
Source§fn bitcount<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn bitcount<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
Source§fn strlen<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn strlen<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
Source§fn hkeys<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn hkeys<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
Source§fn hvals<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn hvals<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
Source§fn hgetall<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn hgetall<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
Source§fn hlen<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn hlen<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
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,
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,
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,
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,
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,
fn blpop<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
timeout: f64,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
Source§fn brpop<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
timeout: f64,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn brpop<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
timeout: f64,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
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,
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,
Source§fn lindex<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
index: isize,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn lindex<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
index: isize,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
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,
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,
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,
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,
Source§fn llen<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn llen<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
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,
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,
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,
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,
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,
fn lpop<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
count: Option<NonZeroUsize>,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
count
first elements of the list stored at key. Read moreSource§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,
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,
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,
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,
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,
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,
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,
fn lrange<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
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,
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,
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,
fn ltrim<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
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,
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,
Source§fn ping<'a, RV>(&'a mut self) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn ping<'a, RV>(&'a mut self) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
Source§fn ping_message<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
message: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn ping_message<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
message: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
Source§fn rpop<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
count: Option<NonZeroUsize>,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn rpop<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
count: Option<NonZeroUsize>,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
count
last elements of the list stored at key Read moreSource§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,
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,
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,
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,
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,
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,
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,
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,
Source§fn scard<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn scard<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
Source§fn sdiff<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
keys: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn sdiff<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
keys: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
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,
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,
Source§fn sinter<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
keys: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn sinter<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
keys: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
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,
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,
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,
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,
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,
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,
Source§fn smembers<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn smembers<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
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,
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,
Source§fn spop<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn spop<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
Source§fn srandmember<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn srandmember<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
Source§fn srandmember_multiple<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
count: usize,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn srandmember_multiple<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
count: usize,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
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,
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,
Source§fn sunion<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
keys: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn sunion<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
keys: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
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,
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,
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,
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,
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,
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,
Source§fn zcard<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn zcard<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
Source§fn bzpopmax<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
timeout: f64,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn bzpopmax<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
timeout: f64,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
Source§fn zpopmax<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
count: isize,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn zpopmax<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
count: isize,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
Source§fn bzpopmin<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
timeout: f64,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn bzpopmin<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
timeout: f64,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
Source§fn zpopmin<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
count: isize,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn zpopmin<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
count: isize,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
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,
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,
Source§fn zmpop_max<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
keys: K,
count: isize,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn zmpop_max<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
keys: K,
count: isize,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
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,
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,
Source§fn zmpop_min<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
keys: K,
count: isize,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn zmpop_min<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
keys: K,
count: isize,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
Source§fn zrandmember<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
count: Option<isize>,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn zrandmember<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
count: Option<isize>,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
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,
fn zrandmember_withscores<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
count: isize,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
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,
fn zrange<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
fn zremrangebyrank<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
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,
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,
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,
fn zrevrange<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize,
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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.