Struct redis::aio::ConnectionManager
source · pub struct ConnectionManager { /* private fields */ }
aio
and connection-manager
only.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 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 aRedisError
- 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
impl ConnectionManager
sourcepub async fn new(client: Client) -> RedisResult<Self>
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.
sourcepub async fn new_with_backoff(
client: Client,
exponent_base: u64,
factor: u64,
number_of_retries: usize
) -> RedisResult<Self>
pub async fn new_with_backoff( client: Client, exponent_base: u64, factor: u64, number_of_retries: usize ) -> 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)).
sourcepub 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>
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>
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 timeout operations after response_timeout
has passed.
Each connection attempt to the server will timeout after connection_timeout
.
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.
Trait Implementations§
source§impl Clone for ConnectionManager
impl Clone for ConnectionManager
source§fn clone(&self) -> ConnectionManager
fn clone(&self) -> ConnectionManager
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read moresource§impl ConnectionLike for ConnectionManager
impl ConnectionLike for ConnectionManager
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 ConnectionManager
impl !RefUnwindSafe for ConnectionManager
impl Send for ConnectionManager
impl Sync for ConnectionManager
impl Unpin for ConnectionManager
impl !UnwindSafe for ConnectionManager
Blanket Implementations§
source§impl<T> AsyncCommands for Twhere
T: ConnectionLike + Send,
impl<T> AsyncCommands for Twhere
T: ConnectionLike + Send,
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 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 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 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: &'a [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: &'a [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: &'a [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: &'a [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: &'a [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: &'a [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: &'a [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: &'a [K],
count: isize
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
source§fn zmpop_max<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
keys: &'a [K],
count: isize
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn zmpop_max<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
keys: &'a [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: &'a [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: &'a [K],
count: isize
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
source§fn zmpop_min<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
keys: &'a [K],
count: isize
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn zmpop_min<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
keys: &'a [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: &'a [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: &'a [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: &'a [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: &'a [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: &'a [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: &'a [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.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,
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,
source§fn pfcount<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn pfcount<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
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,
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,
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,
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,
source§fn object_encoding<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn object_encoding<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
source§fn object_idletime<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn object_idletime<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
source§fn object_freq<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn object_freq<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
source§fn object_refcount<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn object_refcount<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
source§fn acl_load<'a, RV>(&'a mut self) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn acl_load<'a, RV>(&'a mut self) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
acl
only.source§fn acl_save<'a, RV>(&'a mut self) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn acl_save<'a, RV>(&'a mut self) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
acl
only.source§fn acl_list<'a, RV>(&'a mut self) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn acl_list<'a, RV>(&'a mut self) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
acl
only.source§fn acl_users<'a, RV>(&'a mut self) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn acl_users<'a, RV>(&'a mut self) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
acl
only.source§fn acl_getuser<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
username: K
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn acl_getuser<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
username: K
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
acl
only.source§fn acl_setuser<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
username: K
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn acl_setuser<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
username: K
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
acl
only.source§fn acl_setuser_rules<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
username: K,
rules: &'a [Rule]
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn acl_setuser_rules<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
username: K,
rules: &'a [Rule]
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
acl
only.source§fn acl_deluser<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
usernames: &'a [K]
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn acl_deluser<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
usernames: &'a [K]
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
acl
only.source§fn acl_cat<'a, RV>(&'a mut self) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn acl_cat<'a, RV>(&'a mut self) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
acl
only.source§fn acl_cat_categoryname<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
categoryname: K
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn acl_cat_categoryname<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
categoryname: K
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
acl
only.source§fn acl_genpass<'a, RV>(&'a mut self) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn acl_genpass<'a, RV>(&'a mut self) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
acl
only.source§fn acl_genpass_bits<'a, RV>(&'a mut self, bits: isize) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn acl_genpass_bits<'a, RV>(&'a mut self, bits: isize) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
acl
only.source§fn acl_whoami<'a, RV>(&'a mut self) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn acl_whoami<'a, RV>(&'a mut self) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
acl
only.source§fn acl_log<'a, RV>(&'a mut self, count: isize) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn acl_log<'a, RV>(&'a mut self, count: isize) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
acl
only.source§fn acl_log_reset<'a, RV>(&'a mut self) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn acl_log_reset<'a, RV>(&'a mut self) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
acl
only.source§fn acl_help<'a, RV>(&'a mut self) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn acl_help<'a, RV>(&'a mut self) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
acl
only.source§fn geo_add<'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 geo_add<'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,
geospatial
only.source§fn geo_dist<'a, K: ToRedisArgs + Send + Sync + 'a, M1: ToRedisArgs + Send + Sync + 'a, M2: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
member1: M1,
member2: M2,
unit: Unit
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn geo_dist<'a, K: ToRedisArgs + Send + Sync + 'a, M1: ToRedisArgs + Send + Sync + 'a, M2: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
member1: M1,
member2: M2,
unit: Unit
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
geospatial
only.source§fn geo_hash<'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 geo_hash<'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,
geospatial
only.source§fn geo_pos<'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 geo_pos<'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,
geospatial
only.source§fn geo_radius<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
longitude: f64,
latitude: f64,
radius: f64,
unit: Unit,
options: RadiusOptions
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn geo_radius<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
longitude: f64,
latitude: f64,
radius: f64,
unit: Unit,
options: RadiusOptions
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
geospatial
only.source§fn geo_radius_by_member<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
member: M,
radius: f64,
unit: Unit,
options: RadiusOptions
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn geo_radius_by_member<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
member: M,
radius: f64,
unit: Unit,
options: RadiusOptions
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
geospatial
only.member
. The
member itself is always contained in the results.source§fn xack<'a, K: ToRedisArgs + Send + Sync + 'a, G: ToRedisArgs + Send + Sync + 'a, I: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
group: G,
ids: &'a [I]
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn xack<'a, K: ToRedisArgs + Send + Sync + 'a, G: ToRedisArgs + Send + Sync + 'a, I: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
group: G,
ids: &'a [I]
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
streams
only.source§fn xadd<'a, K: ToRedisArgs + Send + Sync + 'a, ID: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
id: ID,
items: &'a [(F, V)]
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn xadd<'a, K: ToRedisArgs + Send + Sync + 'a, ID: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
id: ID,
items: &'a [(F, V)]
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
streams
only.source§fn xadd_map<'a, K: ToRedisArgs + Send + Sync + 'a, ID: ToRedisArgs + Send + Sync + 'a, BTM: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
id: ID,
map: BTM
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn xadd_map<'a, K: ToRedisArgs + Send + Sync + 'a, ID: ToRedisArgs + Send + Sync + 'a, BTM: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
id: ID,
map: BTM
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
streams
only.key
.
Use *
as the id
for the current timestamp. Read moresource§fn xadd_maxlen<'a, K: ToRedisArgs + Send + Sync + 'a, ID: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
maxlen: StreamMaxlen,
id: ID,
items: &'a [(F, V)]
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn xadd_maxlen<'a, K: ToRedisArgs + Send + Sync + 'a, ID: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
maxlen: StreamMaxlen,
id: ID,
items: &'a [(F, V)]
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
streams
only.source§fn xadd_maxlen_map<'a, K: ToRedisArgs + Send + Sync + 'a, ID: ToRedisArgs + Send + Sync + 'a, BTM: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
maxlen: StreamMaxlen,
id: ID,
map: BTM
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn xadd_maxlen_map<'a, K: ToRedisArgs + Send + Sync + 'a, ID: ToRedisArgs + Send + Sync + 'a, BTM: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
maxlen: StreamMaxlen,
id: ID,
map: BTM
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
streams
only.source§fn xclaim<'a, K: ToRedisArgs + Send + Sync + 'a, G: ToRedisArgs + Send + Sync + 'a, C: ToRedisArgs + Send + Sync + 'a, MIT: ToRedisArgs + Send + Sync + 'a, ID: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
group: G,
consumer: C,
min_idle_time: MIT,
ids: &'a [ID]
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn xclaim<'a, K: ToRedisArgs + Send + Sync + 'a, G: ToRedisArgs + Send + Sync + 'a, C: ToRedisArgs + Send + Sync + 'a, MIT: ToRedisArgs + Send + Sync + 'a, ID: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
group: G,
consumer: C,
min_idle_time: MIT,
ids: &'a [ID]
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
streams
only.source§fn xclaim_options<'a, K: ToRedisArgs + Send + Sync + 'a, G: ToRedisArgs + Send + Sync + 'a, C: ToRedisArgs + Send + Sync + 'a, MIT: ToRedisArgs + Send + Sync + 'a, ID: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
group: G,
consumer: C,
min_idle_time: MIT,
ids: &'a [ID],
options: StreamClaimOptions
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn xclaim_options<'a, K: ToRedisArgs + Send + Sync + 'a, G: ToRedisArgs + Send + Sync + 'a, C: ToRedisArgs + Send + Sync + 'a, MIT: ToRedisArgs + Send + Sync + 'a, ID: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
group: G,
consumer: C,
min_idle_time: MIT,
ids: &'a [ID],
options: StreamClaimOptions
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
streams
only.source§fn xdel<'a, K: ToRedisArgs + Send + Sync + 'a, ID: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
ids: &'a [ID]
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn xdel<'a, K: ToRedisArgs + Send + Sync + 'a, ID: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
ids: &'a [ID]
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
streams
only.source§fn xgroup_create<'a, K: ToRedisArgs + Send + Sync + 'a, G: ToRedisArgs + Send + Sync + 'a, ID: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
group: G,
id: ID
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn xgroup_create<'a, K: ToRedisArgs + Send + Sync + 'a, G: ToRedisArgs + Send + Sync + 'a, ID: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
group: G,
id: ID
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
streams
only.group
. It expects the stream key
to already exist. Otherwise, use xgroup_create_mkstream
if it doesn’t.
The id
is the starting message id all consumers should read from. Use $
If you want
all consumers to read from the last message added to stream. Read moresource§fn xgroup_create_mkstream<'a, K: ToRedisArgs + Send + Sync + 'a, G: ToRedisArgs + Send + Sync + 'a, ID: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
group: G,
id: ID
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn xgroup_create_mkstream<'a, K: ToRedisArgs + Send + Sync + 'a, G: ToRedisArgs + Send + Sync + 'a, ID: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
group: G,
id: ID
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
streams
only.group
which makes the stream if it doesn’t exist. Read moresource§fn xgroup_setid<'a, K: ToRedisArgs + Send + Sync + 'a, G: ToRedisArgs + Send + Sync + 'a, ID: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
group: G,
id: ID
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn xgroup_setid<'a, K: ToRedisArgs + Send + Sync + 'a, G: ToRedisArgs + Send + Sync + 'a, ID: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
group: G,
id: ID
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
streams
only.source§fn xgroup_destroy<'a, K: ToRedisArgs + Send + Sync + 'a, G: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
group: G
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn xgroup_destroy<'a, K: ToRedisArgs + Send + Sync + 'a, G: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
group: G
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
streams
only.source§fn xgroup_delconsumer<'a, K: ToRedisArgs + Send + Sync + 'a, G: ToRedisArgs + Send + Sync + 'a, C: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
group: G,
consumer: C
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn xgroup_delconsumer<'a, K: ToRedisArgs + Send + Sync + 'a, G: ToRedisArgs + Send + Sync + 'a, C: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
group: G,
consumer: C
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
streams
only.source§fn xinfo_consumers<'a, K: ToRedisArgs + Send + Sync + 'a, G: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
group: G
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn xinfo_consumers<'a, K: ToRedisArgs + Send + Sync + 'a, G: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
group: G
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
streams
only.group
.
Take note of the StreamInfoConsumersReply return type. Read moresource§fn xinfo_groups<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn xinfo_groups<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
streams
only.group
s created for a given stream key
.
Take note of the StreamInfoGroupsReply return type. Read moresource§fn xinfo_stream<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn xinfo_stream<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
streams
only.id
, length, number of groups, etc.)
Take note of the StreamInfoStreamReply return type. Read moresource§fn xlen<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn xlen<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
streams
only.key
. Read moresource§fn xpending<'a, K: ToRedisArgs + Send + Sync + 'a, G: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
group: G
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn xpending<'a, K: ToRedisArgs + Send + Sync + 'a, G: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
group: G
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
streams
only.key
and consumer group
and it
returns details about which consumers have pending messages
that haven’t been acked. Read moresource§fn xpending_count<'a, K: ToRedisArgs + Send + Sync + 'a, G: ToRedisArgs + Send + Sync + 'a, S: ToRedisArgs + Send + Sync + 'a, E: ToRedisArgs + Send + Sync + 'a, C: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
group: G,
start: S,
end: E,
count: C
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn xpending_count<'a, K: ToRedisArgs + Send + Sync + 'a, G: ToRedisArgs + Send + Sync + 'a, S: ToRedisArgs + Send + Sync + 'a, E: ToRedisArgs + Send + Sync + 'a, C: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
group: G,
start: S,
end: E,
count: C
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
streams
only.source§fn xpending_consumer_count<'a, K: ToRedisArgs + Send + Sync + 'a, G: ToRedisArgs + Send + Sync + 'a, S: ToRedisArgs + Send + Sync + 'a, E: ToRedisArgs + Send + Sync + 'a, C: ToRedisArgs + Send + Sync + 'a, CN: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
group: G,
start: S,
end: E,
count: C,
consumer: CN
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn xpending_consumer_count<'a, K: ToRedisArgs + Send + Sync + 'a, G: ToRedisArgs + Send + Sync + 'a, S: ToRedisArgs + Send + Sync + 'a, E: ToRedisArgs + Send + Sync + 'a, C: ToRedisArgs + Send + Sync + 'a, CN: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
group: G,
start: S,
end: E,
count: C,
consumer: CN
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
streams
only.source§fn xrange<'a, K: ToRedisArgs + Send + Sync + 'a, S: ToRedisArgs + Send + Sync + 'a, E: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
start: S,
end: E
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn xrange<'a, K: ToRedisArgs + Send + Sync + 'a, S: ToRedisArgs + Send + Sync + 'a, E: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
start: S,
end: E
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
streams
only.key
. Read moresource§fn xrange_all<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn xrange_all<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
streams
only.key
.
Use with caution! Read moresource§fn xrange_count<'a, K: ToRedisArgs + Send + Sync + 'a, S: ToRedisArgs + Send + Sync + 'a, E: ToRedisArgs + Send + Sync + 'a, C: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
start: S,
end: E,
count: C
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn xrange_count<'a, K: ToRedisArgs + Send + Sync + 'a, S: ToRedisArgs + Send + Sync + 'a, E: ToRedisArgs + Send + Sync + 'a, C: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
start: S,
end: E,
count: C
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
streams
only.key
. Read moresource§fn xread<'a, K: ToRedisArgs + Send + Sync + 'a, ID: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
keys: &'a [K],
ids: &'a [ID]
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn xread<'a, K: ToRedisArgs + Send + Sync + 'a, ID: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
keys: &'a [K],
ids: &'a [ID]
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
streams
only.id
s for each stream key
.
This is the basic form of reading streams.
For more advanced control, like blocking, limiting, or reading by consumer group
,
see xread_options
. Read moresource§fn xread_options<'a, K: ToRedisArgs + Send + Sync + 'a, ID: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
keys: &'a [K],
ids: &'a [ID],
options: &'a StreamReadOptions
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn xread_options<'a, K: ToRedisArgs + Send + Sync + 'a, ID: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
keys: &'a [K],
ids: &'a [ID],
options: &'a StreamReadOptions
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
streams
only.source§fn xrevrange<'a, K: ToRedisArgs + Send + Sync + 'a, E: ToRedisArgs + Send + Sync + 'a, S: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
end: E,
start: S
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn xrevrange<'a, K: ToRedisArgs + Send + Sync + 'a, E: ToRedisArgs + Send + Sync + 'a, S: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
end: E,
start: S
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
streams
only.source§fn xrevrange_all<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn xrevrange_all<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
source§fn xrevrange_count<'a, K: ToRedisArgs + Send + Sync + 'a, E: ToRedisArgs + Send + Sync + 'a, S: ToRedisArgs + Send + Sync + 'a, C: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
end: E,
start: S,
count: C
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn xrevrange_count<'a, K: ToRedisArgs + Send + Sync + 'a, E: ToRedisArgs + Send + Sync + 'a, S: ToRedisArgs + Send + Sync + 'a, C: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
end: E,
start: S,
count: C
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
streams
only.source§fn xtrim<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
maxlen: StreamMaxlen
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn xtrim<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
maxlen: StreamMaxlen
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
streams
only.key
to a MAXLEN count. Read moresource§fn scan<RV: FromRedisValue>(&mut self) -> RedisFuture<'_, AsyncIter<'_, RV>>
fn scan<RV: FromRedisValue>(&mut self) -> RedisFuture<'_, AsyncIter<'_, RV>>
source§fn scan_match<P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
pattern: P
) -> RedisFuture<'_, AsyncIter<'_, RV>>
fn scan_match<P: ToRedisArgs, RV: FromRedisValue>( &mut self, pattern: P ) -> RedisFuture<'_, AsyncIter<'_, RV>>
source§fn hscan<K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisFuture<'_, AsyncIter<'_, RV>>
fn hscan<K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisFuture<'_, AsyncIter<'_, RV>>
source§fn hscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
pattern: P
) -> RedisFuture<'_, AsyncIter<'_, RV>>
fn hscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, pattern: P ) -> RedisFuture<'_, AsyncIter<'_, RV>>
source§fn sscan<K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisFuture<'_, AsyncIter<'_, RV>>
fn sscan<K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisFuture<'_, AsyncIter<'_, RV>>
source§fn sscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
pattern: P
) -> RedisFuture<'_, AsyncIter<'_, RV>>
fn sscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, pattern: P ) -> RedisFuture<'_, AsyncIter<'_, RV>>
source§fn zscan<K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisFuture<'_, AsyncIter<'_, RV>>
fn zscan<K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisFuture<'_, AsyncIter<'_, RV>>
source§fn zscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
pattern: P
) -> RedisFuture<'_, AsyncIter<'_, RV>>
fn zscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, pattern: P ) -> RedisFuture<'_, AsyncIter<'_, RV>>
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> Instrument for T
impl<T> Instrument for T
source§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
source§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
source§impl<T> JsonAsyncCommands for Twhere
T: ConnectionLike + Send,
impl<T> JsonAsyncCommands for Twhere
T: ConnectionLike + Send,
source§fn json_arr_append<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, V: Serialize + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P,
value: &'a V
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn json_arr_append<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, V: Serialize + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P,
value: &'a V
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
json
only.value
to the array at path
after the last element in it.source§fn json_arr_index<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, V: Serialize + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P,
value: &'a V
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn json_arr_index<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, V: Serialize + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P,
value: &'a V
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
json
only.path
, returns first occurance of value
source§fn json_arr_index_ss<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, V: Serialize + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P,
value: &'a V,
start: &'a isize,
stop: &'a isize
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn json_arr_index_ss<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, V: Serialize + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P,
value: &'a V,
start: &'a isize,
stop: &'a isize
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
json
only.json_arr_index
except takes a start
and a stop
value, setting these to 0
will mean
they make no effect on the query Read moresource§fn json_arr_insert<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, V: Serialize + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P,
index: i64,
value: &'a V
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn json_arr_insert<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, V: Serialize + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P,
index: i64,
value: &'a V
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
json
only.source§fn json_arr_len<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn json_arr_len<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
json
only.path
in key
.source§fn json_arr_pop<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P,
index: i64
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn json_arr_pop<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P,
index: i64
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
json
only.index
in the array. Read moresource§fn json_arr_trim<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P,
start: i64,
stop: i64
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn json_arr_trim<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P,
start: i64,
stop: i64
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
json
only.source§fn json_clear<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn json_clear<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
json
only.source§fn json_del<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn json_del<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
json
only.path
.source§fn json_get<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn json_get<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
json
only.path
. Read moresource§fn json_num_incr_by<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P,
value: i64
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn json_num_incr_by<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P,
value: i64
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
json
only.path
by number
.source§fn json_obj_keys<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn json_obj_keys<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
json
only.path
.source§fn json_obj_len<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn json_obj_len<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
json
only.path
in key
.source§fn json_set<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, V: Serialize + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P,
value: &'a V
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn json_set<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, V: Serialize + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P,
value: &'a V
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
json
only.path
in key
.source§fn json_str_append<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P,
value: V
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn json_str_append<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P,
value: V
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
json
only.json-string
values to the string at path
.source§fn json_str_len<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn json_str_len<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
json
only.path
in key
.source§fn json_toggle<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn json_toggle<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
json
only.boolean
value stored at path
.source§fn json_type<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
fn json_type<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, RV>(
&'a mut self,
key: K,
path: P
) -> RedisFuture<'a, RV>where
RV: FromRedisValue,
json
only.path
.