Struct deadpool_redis::Connection
source · [−]pub struct Connection { /* private fields */ }
Expand description
Wrapper around redis::aio::Connection
.
This structure implements redis::aio::ConnectionLike
and can therefore
be used just like a regular redis::aio::Connection
.
Implementations
sourceimpl Connection
impl Connection
sourcepub fn take(this: Self) -> RedisConnection
pub fn take(this: Self) -> RedisConnection
Takes this Connection
from its Pool
permanently.
This reduces the size of the Pool
.
Trait Implementations
sourceimpl AsMut<Connection<Pin<Box<dyn AsyncStream + Sync + Send + 'static, Global>>>> for Connection
impl AsMut<Connection<Pin<Box<dyn AsyncStream + Sync + Send + 'static, Global>>>> for Connection
sourcefn as_mut(&mut self) -> &mut Connection
fn as_mut(&mut self) -> &mut Connection
Converts this type into a mutable reference of the (usually inferred) input type.
sourceimpl AsRef<Connection<Pin<Box<dyn AsyncStream + Sync + Send + 'static, Global>>>> for Connection
impl AsRef<Connection<Pin<Box<dyn AsyncStream + Sync + Send + 'static, Global>>>> for Connection
sourcefn as_ref(&self) -> &Connection
fn as_ref(&self) -> &Connection
Converts this type into a shared reference of the (usually inferred) input type.
sourceimpl ConnectionLike for Connection
impl ConnectionLike for Connection
sourcefn 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>
Sends an already encoded (packed) command into the TCP socket and
reads the single response from it. Read more
sourcefn req_packed_commands<'a>(
&'a mut self,
cmd: &'a Pipeline,
offset: usize,
count: usize
) -> RedisFuture<'a, Vec<Value>>
fn req_packed_commands<'a>(
&'a mut self,
cmd: &'a Pipeline,
offset: usize,
count: usize
) -> RedisFuture<'a, Vec<Value>>
Sends multiple already encoded (packed) command into the TCP socket
and reads
count
responses from it. This is used to implement
pipelining. Read moresourceimpl Deref for Connection
impl Deref for Connection
type Target = Connection<Pin<Box<dyn AsyncStream + Sync + Send + 'static, Global>>>
type Target = Connection<Pin<Box<dyn AsyncStream + Sync + Send + 'static, Global>>>
The resulting type after dereferencing.
sourcefn deref(&self) -> &RedisConnection
fn deref(&self) -> &RedisConnection
Dereferences the value.
sourceimpl DerefMut for Connection
impl DerefMut for Connection
sourcefn deref_mut(&mut self) -> &mut RedisConnection
fn deref_mut(&mut self) -> &mut RedisConnection
Mutably dereferences the value.
Auto Trait Implementations
impl !RefUnwindSafe for Connection
impl Send for Connection
impl Sync for Connection
impl Unpin for Connection
impl !UnwindSafe for Connection
Blanket Implementations
sourceimpl<T> AsyncCommands for Twhere
T: ConnectionLike + Send,
impl<T> AsyncCommands for Twhere
T: ConnectionLike + Send,
sourcefn get<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn get<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Get the value of a key. If key is a vec this becomes an
MGET
.sourcefn keys<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn keys<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Gets all keys matching pattern
sourcefn set<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn set<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Set the string value of a key.
sourcefn set_multiple<'a, K, V, RV>(
&'a mut self,
items: &'a [(K, V)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn set_multiple<'a, K, V, RV>(
&'a mut self,
items: &'a [(K, V)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Sets multiple keys to their values.
sourcefn set_ex<'a, K, V, RV>(
&'a mut self,
key: K,
value: V,
seconds: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn set_ex<'a, K, V, RV>(
&'a mut self,
key: K,
value: V,
seconds: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Set the value and expiration of a key.
sourcefn pset_ex<'a, K, V, RV>(
&'a mut self,
key: K,
value: V,
milliseconds: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn pset_ex<'a, K, V, RV>(
&'a mut self,
key: K,
value: V,
milliseconds: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Set the value and expiration in milliseconds of a key.
sourcefn set_nx<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn set_nx<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Set the value of a key, only if the key does not exist
sourcefn mset_nx<'a, K, V, RV>(
&'a mut self,
items: &'a [(K, V)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn mset_nx<'a, K, V, RV>(
&'a mut self,
items: &'a [(K, V)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Sets multiple keys to their values failing if at least one already exists.
sourcefn getset<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn getset<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Set the string value of a key and return its old value.
sourcefn getrange<'a, K, RV>(
&'a mut self,
key: K,
from: isize,
to: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn getrange<'a, K, RV>(
&'a mut self,
key: K,
from: isize,
to: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Get a range of bytes/substring from the value of a key. Negative values provide an offset from the end of the value.
sourcefn setrange<'a, K, V, RV>(
&'a mut self,
key: K,
offset: isize,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn setrange<'a, K, V, RV>(
&'a mut self,
key: K,
offset: isize,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Overwrite the part of the value stored in key at the specified offset.
sourcefn del<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn del<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Delete one or more keys.
sourcefn exists<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn exists<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Determine if a key exists.
sourcefn expire<'a, K, RV>(
&'a mut self,
key: K,
seconds: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn expire<'a, K, RV>(
&'a mut self,
key: K,
seconds: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Set a key’s time to live in seconds.
sourcefn expire_at<'a, K, RV>(
&'a mut self,
key: K,
ts: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn expire_at<'a, K, RV>(
&'a mut self,
key: K,
ts: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Set the expiration for a key as a UNIX timestamp.
sourcefn pexpire<'a, K, RV>(
&'a mut self,
key: K,
ms: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn pexpire<'a, K, RV>(
&'a mut self,
key: K,
ms: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Set a key’s time to live in milliseconds.
sourcefn pexpire_at<'a, K, RV>(
&'a mut self,
key: K,
ts: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn pexpire_at<'a, K, RV>(
&'a mut self,
key: K,
ts: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Set the expiration for a key as a UNIX timestamp in milliseconds.
sourcefn persist<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn persist<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Remove the expiration from a key.
sourcefn ttl<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn ttl<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Get the expiration time of a key.
sourcefn pttl<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn pttl<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Get the expiration time of a key in milliseconds.
sourcefn get_ex<'a, K, RV>(
&'a mut self,
key: K,
expire_at: Expiry
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn get_ex<'a, K, RV>(
&'a mut self,
key: K,
expire_at: Expiry
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Get the value of a key and set expiration
sourcefn get_del<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn get_del<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Get the value of a key and delete it
sourcefn rename<'a, K, RV>(
&'a mut self,
key: K,
new_key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn rename<'a, K, RV>(
&'a mut self,
key: K,
new_key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Rename a key.
sourcefn rename_nx<'a, K, RV>(
&'a mut self,
key: K,
new_key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn rename_nx<'a, K, RV>(
&'a mut self,
key: K,
new_key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Rename a key, only if the new key does not exist.
sourcefn unlink<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn unlink<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Unlink one or more keys.
sourcefn append<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn append<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Append a value to a key.
sourcefn incr<'a, K, V, RV>(
&'a mut self,
key: K,
delta: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn incr<'a, K, V, RV>(
&'a mut self,
key: K,
delta: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Increment the numeric value of a key by the given amount. This
issues a
INCRBY
or INCRBYFLOAT
depending on the type. Read moresourcefn decr<'a, K, V, RV>(
&'a mut self,
key: K,
delta: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn decr<'a, K, V, RV>(
&'a mut self,
key: K,
delta: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Decrement the numeric value of a key by the given amount.
sourcefn setbit<'a, K, RV>(
&'a mut self,
key: K,
offset: usize,
value: bool
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn setbit<'a, K, RV>(
&'a mut self,
key: K,
offset: usize,
value: bool
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Sets or clears the bit at offset in the string value stored at key.
sourcefn getbit<'a, K, RV>(
&'a mut self,
key: K,
offset: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn getbit<'a, K, RV>(
&'a mut self,
key: K,
offset: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Returns the bit value at offset in the string value stored at key.
sourcefn bitcount<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn bitcount<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Count set bits in a string.
sourcefn bitcount_range<'a, K, RV>(
&'a mut self,
key: K,
start: usize,
end: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn bitcount_range<'a, K, RV>(
&'a mut self,
key: K,
start: usize,
end: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Count set bits in a string in a range.
sourcefn bit_and<'a, K, RV>(
&'a mut self,
dstkey: K,
srckeys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn bit_and<'a, K, RV>(
&'a mut self,
dstkey: K,
srckeys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Perform a bitwise AND between multiple keys (containing string values)
and store the result in the destination key. Read more
sourcefn bit_or<'a, K, RV>(
&'a mut self,
dstkey: K,
srckeys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn bit_or<'a, K, RV>(
&'a mut self,
dstkey: K,
srckeys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Perform a bitwise OR between multiple keys (containing string values)
and store the result in the destination key. Read more
sourcefn bit_xor<'a, K, RV>(
&'a mut self,
dstkey: K,
srckeys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn bit_xor<'a, K, RV>(
&'a mut self,
dstkey: K,
srckeys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Perform a bitwise XOR between multiple keys (containing string values)
and store the result in the destination key. Read more
sourcefn bit_not<'a, K, RV>(
&'a mut self,
dstkey: K,
srckey: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn bit_not<'a, K, RV>(
&'a mut self,
dstkey: K,
srckey: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Perform a bitwise NOT of the key (containing string values)
and store the result in the destination key. Read more
sourcefn strlen<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn strlen<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Get the length of the value stored in a key.
sourcefn hget<'a, K, F, RV>(
&'a mut self,
key: K,
field: F
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
F: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn hget<'a, K, F, RV>(
&'a mut self,
key: K,
field: F
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
F: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Gets a single (or multiple) fields from a hash.
sourcefn hdel<'a, K, F, RV>(
&'a mut self,
key: K,
field: F
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
F: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn hdel<'a, K, F, RV>(
&'a mut self,
key: K,
field: F
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
F: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Deletes a single (or multiple) fields from a hash.
sourcefn hset<'a, K, F, V, RV>(
&'a mut self,
key: K,
field: F,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
F: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn hset<'a, K, F, V, RV>(
&'a mut self,
key: K,
field: F,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
F: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Sets a single field in a hash.
sourcefn hset_nx<'a, K, F, V, RV>(
&'a mut self,
key: K,
field: F,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
F: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn hset_nx<'a, K, F, V, RV>(
&'a mut self,
key: K,
field: F,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
F: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Sets a single field in a hash if it does not exist.
sourcefn hset_multiple<'a, K, F, V, RV>(
&'a mut self,
key: K,
items: &'a [(F, V)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
F: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn hset_multiple<'a, K, F, V, RV>(
&'a mut self,
key: K,
items: &'a [(F, V)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
F: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Sets a multiple fields in a hash.
sourcefn hincr<'a, K, F, D, RV>(
&'a mut self,
key: K,
field: F,
delta: D
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
F: 'a + ToRedisArgs + Send + Sync,
D: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn hincr<'a, K, F, D, RV>(
&'a mut self,
key: K,
field: F,
delta: D
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
F: 'a + ToRedisArgs + Send + Sync,
D: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Increments a value.
sourcefn hexists<'a, K, F, RV>(
&'a mut self,
key: K,
field: F
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
F: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn hexists<'a, K, F, RV>(
&'a mut self,
key: K,
field: F
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
F: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Checks if a field in a hash exists.
sourcefn hkeys<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn hkeys<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Gets all the keys in a hash.
sourcefn hvals<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn hvals<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Gets all the values in a hash.
sourcefn hgetall<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn hgetall<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Gets all the fields and values in a hash.
sourcefn hlen<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn hlen<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Gets the length of a hash.
sourcefn blmove<'a, K, RV>(
&'a mut self,
srckey: K,
dstkey: K,
src_dir: Direction,
dst_dir: Direction,
timeout: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn blmove<'a, K, RV>(
&'a mut self,
srckey: K,
dstkey: K,
src_dir: Direction,
dst_dir: Direction,
timeout: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Pop an element from a list, push it to another list
and return it; or block until one is available Read more
sourcefn blmpop<'a, K, RV>(
&'a mut self,
timeout: usize,
numkeys: usize,
key: K,
dir: Direction,
count: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn blmpop<'a, K, RV>(
&'a mut self,
timeout: usize,
numkeys: usize,
key: K,
dir: Direction,
count: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Pops
count
elements from the first non-empty list key from the list of
provided key names; or blocks until one is available. Read moresourcefn blpop<'a, K, RV>(
&'a mut self,
key: K,
timeout: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn blpop<'a, K, RV>(
&'a mut self,
key: K,
timeout: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Remove and get the first element in a list, or block until one is available.
sourcefn brpop<'a, K, RV>(
&'a mut self,
key: K,
timeout: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn brpop<'a, K, RV>(
&'a mut self,
key: K,
timeout: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Remove and get the last element in a list, or block until one is available.
sourcefn brpoplpush<'a, K, RV>(
&'a mut self,
srckey: K,
dstkey: K,
timeout: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn brpoplpush<'a, K, RV>(
&'a mut self,
srckey: K,
dstkey: K,
timeout: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Pop a value from a list, push it to another list and return it;
or block until one is available. Read more
sourcefn lindex<'a, K, RV>(
&'a mut self,
key: K,
index: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn lindex<'a, K, RV>(
&'a mut self,
key: K,
index: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Get an element from a list by its index.
sourcefn linsert_before<'a, K, P, V, RV>(
&'a mut self,
key: K,
pivot: P,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
P: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn linsert_before<'a, K, P, V, RV>(
&'a mut self,
key: K,
pivot: P,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
P: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Insert an element before another element in a list.
sourcefn linsert_after<'a, K, P, V, RV>(
&'a mut self,
key: K,
pivot: P,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
P: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn linsert_after<'a, K, P, V, RV>(
&'a mut self,
key: K,
pivot: P,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
P: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Insert an element after another element in a list.
sourcefn llen<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn llen<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Returns the length of the list stored at key.
sourcefn lmove<'a, K, RV>(
&'a mut self,
srckey: K,
dstkey: K,
src_dir: Direction,
dst_dir: Direction
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn lmove<'a, K, RV>(
&'a mut self,
srckey: K,
dstkey: K,
src_dir: Direction,
dst_dir: Direction
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Pop an element a list, push it to another list and return it
sourcefn lmpop<'a, K, RV>(
&'a mut self,
numkeys: usize,
key: K,
dir: Direction,
count: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn lmpop<'a, K, RV>(
&'a mut self,
numkeys: usize,
key: K,
dir: Direction,
count: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Pops
count
elements from the first non-empty list key from the list of
provided key names. Read moresourcefn lpop<'a, K, RV>(
&'a mut self,
key: K,
count: Option<NonZeroUsize>
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn lpop<'a, K, RV>(
&'a mut self,
key: K,
count: Option<NonZeroUsize>
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Removes and returns the up to
count
first elements of the list stored at key. Read moresourcefn lpos<'a, K, V, RV>(
&'a mut self,
key: K,
value: V,
options: LposOptions
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn lpos<'a, K, V, RV>(
&'a mut self,
key: K,
value: V,
options: LposOptions
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Returns the index of the first matching value of the list stored at key.
sourcefn lpush<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn lpush<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Insert all the specified values at the head of the list stored at key.
sourcefn lpush_exists<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn lpush_exists<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Inserts a value at the head of the list stored at key, only if key
already exists and holds a list. Read more
sourcefn lrange<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn lrange<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Returns the specified elements of the list stored at key.
sourcefn lrem<'a, K, V, RV>(
&'a mut self,
key: K,
count: isize,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn lrem<'a, K, V, RV>(
&'a mut self,
key: K,
count: isize,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Removes the first count occurrences of elements equal to value
from the list stored at key. Read more
sourcefn ltrim<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn ltrim<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Trim an existing list so that it will contain only the specified
range of elements specified. Read more
sourcefn lset<'a, K, V, RV>(
&'a mut self,
key: K,
index: isize,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn lset<'a, K, V, RV>(
&'a mut self,
key: K,
index: isize,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Sets the list element at index to value
sourcefn rpop<'a, K, RV>(
&'a mut self,
key: K,
count: Option<NonZeroUsize>
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn rpop<'a, K, RV>(
&'a mut self,
key: K,
count: Option<NonZeroUsize>
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Removes and returns the up to
count
last elements of the list stored at key Read moresourcefn rpoplpush<'a, K, RV>(
&'a mut self,
key: K,
dstkey: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn rpoplpush<'a, K, RV>(
&'a mut self,
key: K,
dstkey: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Pop a value from a list, push it to another list and return it.
sourcefn rpush<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn rpush<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Insert all the specified values at the tail of the list stored at key.
sourcefn rpush_exists<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn rpush_exists<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Inserts value at the tail of the list stored at key, only if key
already exists and holds a list. Read more
sourcefn sadd<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn sadd<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Add one or more members to a set.
sourcefn scard<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn scard<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Get the number of members in a set.
sourcefn sdiff<'a, K, RV>(
&'a mut self,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn sdiff<'a, K, RV>(
&'a mut self,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Subtract multiple sets.
sourcefn sdiffstore<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn sdiffstore<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Subtract multiple sets and store the resulting set in a key.
sourcefn sinter<'a, K, RV>(
&'a mut self,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn sinter<'a, K, RV>(
&'a mut self,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Intersect multiple sets.
sourcefn sinterstore<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn sinterstore<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Intersect multiple sets and store the resulting set in a key.
sourcefn sismember<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn sismember<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Determine if a given value is a member of a set.
sourcefn smembers<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn smembers<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Get all the members in a set.
sourcefn smove<'a, K, M, RV>(
&'a mut self,
srckey: K,
dstkey: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn smove<'a, K, M, RV>(
&'a mut self,
srckey: K,
dstkey: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Move a member from one set to another.
sourcefn spop<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn spop<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Remove and return a random member from a set.
sourcefn srandmember<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn srandmember<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Get one random member from a set.
sourcefn srandmember_multiple<'a, K, RV>(
&'a mut self,
key: K,
count: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn srandmember_multiple<'a, K, RV>(
&'a mut self,
key: K,
count: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Get multiple random members from a set.
sourcefn srem<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn srem<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Remove one or more members from a set.
sourcefn sunion<'a, K, RV>(
&'a mut self,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn sunion<'a, K, RV>(
&'a mut self,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Add multiple sets.
sourcefn sunionstore<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn sunionstore<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Add multiple sets and store the resulting set in a key.
sourcefn zadd<'a, K, S, M, RV>(
&'a mut self,
key: K,
member: M,
score: S
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zadd<'a, K, S, M, RV>(
&'a mut self,
key: K,
member: M,
score: S
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Add one member to a sorted set, or update its score if it already exists.
sourcefn zadd_multiple<'a, K, S, M, RV>(
&'a mut self,
key: K,
items: &'a [(S, M)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zadd_multiple<'a, K, S, M, RV>(
&'a mut self,
key: K,
items: &'a [(S, M)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Add multiple members to a sorted set, or update its score if it already exists.
sourcefn zcard<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zcard<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Get the number of members in a sorted set.
sourcefn zcount<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zcount<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Count the members in a sorted set with scores within the given values.
sourcefn zincr<'a, K, M, D, RV>(
&'a mut self,
key: K,
member: M,
delta: D
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
D: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zincr<'a, K, M, D, RV>(
&'a mut self,
key: K,
member: M,
delta: D
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
D: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Increments the member in a sorted set at key by delta.
If the member does not exist, it is added with delta as its score. Read more
sourcefn zinterstore<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zinterstore<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Intersect multiple sorted sets and store the resulting sorted set in
a new key using SUM as aggregation function. Read more
sourcefn zinterstore_min<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zinterstore_min<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Intersect multiple sorted sets and store the resulting sorted set in
a new key using MIN as aggregation function. Read more
sourcefn zinterstore_max<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zinterstore_max<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Intersect multiple sorted sets and store the resulting sorted set in
a new key using MAX as aggregation function. Read more
sourcefn zinterstore_weights<'a, K, W, RV>(
&'a mut self,
dstkey: K,
keys: &'a [(K, W)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
W: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zinterstore_weights<'a, K, W, RV>(
&'a mut self,
dstkey: K,
keys: &'a [(K, W)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
W: 'a + ToRedisArgs + Send + Sync,
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. Read moresourcefn zinterstore_min_weights<'a, K, W, RV>(
&'a mut self,
dstkey: K,
keys: &'a [(K, W)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
W: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zinterstore_min_weights<'a, K, W, RV>(
&'a mut self,
dstkey: K,
keys: &'a [(K, W)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
W: 'a + ToRedisArgs + Send + Sync,
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. Read moresourcefn zinterstore_max_weights<'a, K, W, RV>(
&'a mut self,
dstkey: K,
keys: &'a [(K, W)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
W: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zinterstore_max_weights<'a, K, W, RV>(
&'a mut self,
dstkey: K,
keys: &'a [(K, W)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
W: 'a + ToRedisArgs + Send + Sync,
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. Read moresourcefn zlexcount<'a, K, L, RV>(
&'a mut self,
key: K,
min: L,
max: L
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
L: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zlexcount<'a, K, L, RV>(
&'a mut self,
key: K,
min: L,
max: L
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
L: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Count the number of members in a sorted set between a given lexicographical range.
sourcefn zpopmax<'a, K, RV>(
&'a mut self,
key: K,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zpopmax<'a, K, RV>(
&'a mut self,
key: K,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Removes and returns up to count members with the highest scores in a sorted set
sourcefn zpopmin<'a, K, RV>(
&'a mut self,
key: K,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zpopmin<'a, K, RV>(
&'a mut self,
key: K,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Removes and returns up to count members with the lowest scores in a sorted set
sourcefn zmpop_max<'a, K, RV>(
&'a mut self,
keys: &'a [K],
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zmpop_max<'a, K, RV>(
&'a mut self,
keys: &'a [K],
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Removes and returns up to count members with the highest scores,
from the first non-empty sorted set in the provided list of key names. Read more
sourcefn zmpop_min<'a, K, RV>(
&'a mut self,
keys: &'a [K],
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zmpop_min<'a, K, RV>(
&'a mut self,
keys: &'a [K],
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Removes and returns up to count members with the lowest scores,
from the first non-empty sorted set in the provided list of key names. Read more
sourcefn zrandmember<'a, K, RV>(
&'a mut self,
key: K,
count: Option<isize>
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zrandmember<'a, K, RV>(
&'a mut self,
key: K,
count: Option<isize>
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Return up to count random members in a sorted set (or 1 if
count == None
)sourcefn zrandmember_withscores<'a, K, RV>(
&'a mut self,
key: K,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zrandmember_withscores<'a, K, RV>(
&'a mut self,
key: K,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Return up to count random members in a sorted set with scores
sourcefn zrange<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zrange<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Return a range of members in a sorted set, by index
sourcefn zrange_withscores<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zrange_withscores<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Return a range of members in a sorted set, by index with scores.
sourcefn zrangebylex<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zrangebylex<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Return a range of members in a sorted set, by lexicographical range.
sourcefn zrangebylex_limit<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zrangebylex_limit<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Return a range of members in a sorted set, by lexicographical
range with offset and limit. Read more
sourcefn zrevrangebylex<'a, K, MM, M, RV>(
&'a mut self,
key: K,
max: MM,
min: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zrevrangebylex<'a, K, MM, M, RV>(
&'a mut self,
key: K,
max: MM,
min: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Return a range of members in a sorted set, by lexicographical range.
sourcefn zrevrangebylex_limit<'a, K, MM, M, RV>(
&'a mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zrevrangebylex_limit<'a, K, MM, M, RV>(
&'a mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Return a range of members in a sorted set, by lexicographical
range with offset and limit. Read more
sourcefn zrangebyscore<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zrangebyscore<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Return a range of members in a sorted set, by score.
sourcefn zrangebyscore_withscores<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zrangebyscore_withscores<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Return a range of members in a sorted set, by score with scores.
sourcefn zrangebyscore_limit<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zrangebyscore_limit<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Return a range of members in a sorted set, by score with limit.
sourcefn zrangebyscore_limit_withscores<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zrangebyscore_limit_withscores<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Return a range of members in a sorted set, by score with limit with scores.
sourcefn zrank<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zrank<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Determine the index of a member in a sorted set.
sourcefn zrem<'a, K, M, RV>(
&'a mut self,
key: K,
members: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zrem<'a, K, M, RV>(
&'a mut self,
key: K,
members: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Remove one or more members from a sorted set.
sourcefn zrembylex<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zrembylex<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Remove all members in a sorted set between the given lexicographical range.
sourcefn zremrangebyrank<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zremrangebyrank<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Remove all members in a sorted set within the given indexes.
sourcefn zrembyscore<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zrembyscore<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Remove all members in a sorted set within the given scores.
sourcefn zrevrange<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zrevrange<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Return a range of members in a sorted set, by index, with scores
ordered from high to low. Read more
sourcefn zrevrange_withscores<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zrevrange_withscores<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Return a range of members in a sorted set, by index, with scores
ordered from high to low. Read more
sourcefn zrevrangebyscore<'a, K, MM, M, RV>(
&'a mut self,
key: K,
max: MM,
min: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zrevrangebyscore<'a, K, MM, M, RV>(
&'a mut self,
key: K,
max: MM,
min: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Return a range of members in a sorted set, by score.
sourcefn zrevrangebyscore_withscores<'a, K, MM, M, RV>(
&'a mut self,
key: K,
max: MM,
min: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zrevrangebyscore_withscores<'a, K, MM, M, RV>(
&'a mut self,
key: K,
max: MM,
min: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Return a range of members in a sorted set, by score with scores.
sourcefn zrevrangebyscore_limit<'a, K, MM, M, RV>(
&'a mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zrevrangebyscore_limit<'a, K, MM, M, RV>(
&'a mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Return a range of members in a sorted set, by score with limit.
sourcefn zrevrangebyscore_limit_withscores<'a, K, MM, M, RV>(
&'a mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zrevrangebyscore_limit_withscores<'a, K, MM, M, RV>(
&'a mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Return a range of members in a sorted set, by score with limit with scores.
sourcefn zrevrank<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zrevrank<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Determine the index of a member in a sorted set, with scores ordered from high to low.
sourcefn zscore<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zscore<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Get the score associated with the given member in a sorted set.
sourcefn zscore_multiple<'a, K, M, RV>(
&'a mut self,
key: K,
members: &'a [M]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zscore_multiple<'a, K, M, RV>(
&'a mut self,
key: K,
members: &'a [M]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Get the scores associated with multiple members in a sorted set.
sourcefn zunionstore<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zunionstore<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Unions multiple sorted sets and store the resulting sorted set in
a new key using SUM as aggregation function. Read more
sourcefn zunionstore_min<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zunionstore_min<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Unions multiple sorted sets and store the resulting sorted set in
a new key using MIN as aggregation function. Read more
sourcefn zunionstore_max<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zunionstore_max<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Unions multiple sorted sets and store the resulting sorted set in
a new key using MAX as aggregation function. Read more
sourcefn zunionstore_weights<'a, K, W, RV>(
&'a mut self,
dstkey: K,
keys: &'a [(K, W)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
W: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zunionstore_weights<'a, K, W, RV>(
&'a mut self,
dstkey: K,
keys: &'a [(K, W)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
W: 'a + ToRedisArgs + Send + Sync,
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. Read moresourcefn zunionstore_min_weights<'a, K, W, RV>(
&'a mut self,
dstkey: K,
keys: &'a [(K, W)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
W: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zunionstore_min_weights<'a, K, W, RV>(
&'a mut self,
dstkey: K,
keys: &'a [(K, W)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
W: 'a + ToRedisArgs + Send + Sync,
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. Read moresourcefn zunionstore_max_weights<'a, K, W, RV>(
&'a mut self,
dstkey: K,
keys: &'a [(K, W)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
W: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zunionstore_max_weights<'a, K, W, RV>(
&'a mut self,
dstkey: K,
keys: &'a [(K, W)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
W: 'a + ToRedisArgs + Send + Sync,
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. Read moresourcefn pfadd<'a, K, E, RV>(
&'a mut self,
key: K,
element: E
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
E: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn pfadd<'a, K, E, RV>(
&'a mut self,
key: K,
element: E
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
E: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Adds the specified elements to the specified HyperLogLog.
sourcefn pfcount<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn pfcount<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Return the approximated cardinality of the set(s) observed by the
HyperLogLog at key(s). Read more
sourcefn pfmerge<'a, K, RV>(
&'a mut self,
dstkey: K,
srckeys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn pfmerge<'a, K, RV>(
&'a mut self,
dstkey: K,
srckeys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Merge N different HyperLogLogs into a single one.
sourcefn publish<'a, K, E, RV>(
&'a mut self,
channel: K,
message: E
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
E: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn publish<'a, K, E, RV>(
&'a mut self,
channel: K,
message: E
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
E: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Posts a message to the given channel.
sourcefn object_encoding<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn object_encoding<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Returns the encoding of a key.
sourcefn object_idletime<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn object_idletime<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Returns the time in seconds since the last access of a key.
sourcefn object_freq<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn object_freq<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Returns the logarithmic access frequency counter of a key.
sourcefn object_refcount<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn object_refcount<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
Returns the reference count of a key.
sourcefn xrevrange_all<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn xrevrange_all<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a, Global>>where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
sourcefn scan<RV>(
&mut self
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>>where
RV: FromRedisValue,
fn scan<RV>(
&mut self
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>>where
RV: FromRedisValue,
Incrementally iterate the keys space.
sourcefn scan_match<P, RV>(
&mut self,
pattern: P
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>>where
P: ToRedisArgs,
RV: FromRedisValue,
fn scan_match<P, RV>(
&mut self,
pattern: P
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>>where
P: ToRedisArgs,
RV: FromRedisValue,
Incrementally iterate set elements for elements matching a pattern.
sourcefn hscan<K, RV>(
&mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>>where
K: ToRedisArgs,
RV: FromRedisValue,
fn hscan<K, RV>(
&mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>>where
K: ToRedisArgs,
RV: FromRedisValue,
Incrementally iterate hash fields and associated values.
sourcefn hscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>>where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
fn hscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>>where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
Incrementally iterate hash fields and associated values for
field names matching a pattern. Read more
sourcefn sscan<K, RV>(
&mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>>where
K: ToRedisArgs,
RV: FromRedisValue,
fn sscan<K, RV>(
&mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>>where
K: ToRedisArgs,
RV: FromRedisValue,
Incrementally iterate set elements.
sourcefn sscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>>where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
fn sscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>>where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
Incrementally iterate set elements for elements matching a pattern.
sourcefn zscan<K, RV>(
&mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zscan<K, RV>(
&mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>>where
K: ToRedisArgs,
RV: FromRedisValue,
Incrementally iterate sorted set elements.
sourcefn zscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>>where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
fn zscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>>where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
Incrementally iterate sorted set elements for elements matching a pattern.
sourceimpl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more