Struct deadpool_redis::ConnectionWrapper [−][src]
pub struct ConnectionWrapper { /* fields omitted */ }
Expand description
A wrapper for redis::Connection
. The query_async
and execute_async
functions of redis::Cmd
and redis::Pipeline
consume the connection.
This wrapper makes it possible to replace the internal connection after
executing a query.
Implementations
impl ConnectionWrapper
[src]
impl ConnectionWrapper
[src]pub fn take(this: Self) -> RedisConnection
[src]
pub fn take(this: Self) -> RedisConnection
[src]Take this object from the pool permanently. This reduces the size of the pool.
Methods from Deref<Target = RedisConnection>
Trait Implementations
impl AsMut<Connection<Pin<Box<dyn AsyncStream + 'static + Sync + Send, Global>>>> for ConnectionWrapper
[src]
impl AsMut<Connection<Pin<Box<dyn AsyncStream + 'static + Sync + Send, Global>>>> for ConnectionWrapper
[src]fn as_mut(&mut self) -> &mut Connection
[src]
fn as_mut(&mut self) -> &mut Connection
[src]Performs the conversion.
impl AsRef<Connection<Pin<Box<dyn AsyncStream + 'static + Sync + Send, Global>>>> for ConnectionWrapper
[src]
impl AsRef<Connection<Pin<Box<dyn AsyncStream + 'static + Sync + Send, Global>>>> for ConnectionWrapper
[src]fn as_ref(&self) -> &Connection
[src]
fn as_ref(&self) -> &Connection
[src]Performs the conversion.
impl ConnectionLike for ConnectionWrapper
[src]
impl ConnectionLike for ConnectionWrapper
[src]fn req_packed_command<'a>(&'a mut self, cmd: &'a Cmd) -> RedisFuture<'a, Value>
[src]
fn req_packed_command<'a>(&'a mut self, cmd: &'a Cmd) -> RedisFuture<'a, Value>
[src]Sends an already encoded (packed) command into the TCP socket and reads the single response from it. Read more
fn req_packed_commands<'a>(
&'a mut self,
cmd: &'a Pipeline,
offset: usize,
count: usize
) -> RedisFuture<'a, Vec<Value>>
[src]
fn req_packed_commands<'a>(
&'a mut self,
cmd: &'a Pipeline,
offset: usize,
count: usize
) -> RedisFuture<'a, Vec<Value>>
[src]Sends multiple already encoded (packed) command into the TCP socket
and reads count
responses from it. This is used to implement
pipelining. Read more
impl Deref for ConnectionWrapper
[src]
impl Deref for ConnectionWrapper
[src]type Target = RedisConnection
type Target = RedisConnection
The resulting type after dereferencing.
fn deref(&self) -> &RedisConnection
[src]
fn deref(&self) -> &RedisConnection
[src]Dereferences the value.
impl DerefMut for ConnectionWrapper
[src]
impl DerefMut for ConnectionWrapper
[src]fn deref_mut(&mut self) -> &mut RedisConnection
[src]
fn deref_mut(&mut self) -> &mut RedisConnection
[src]Mutably dereferences the value.
impl From<Object<Manager>> for ConnectionWrapper
[src]
impl From<Object<Manager>> for ConnectionWrapper
[src]fn from(conn: Connection) -> Self
[src]
fn from(conn: Connection) -> Self
[src]Performs the conversion.
Auto Trait Implementations
impl !RefUnwindSafe for ConnectionWrapper
impl Send for ConnectionWrapper
impl Sync for ConnectionWrapper
impl Unpin for ConnectionWrapper
impl !UnwindSafe for ConnectionWrapper
Blanket Implementations
impl<T> AsyncCommands for T where
T: ConnectionLike + Send,
[src]
impl<T> AsyncCommands for T where
T: ConnectionLike + Send,
[src]fn get<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn get<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Get the value of a key. If key is a vec this becomes an MGET
.
fn keys<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn keys<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Gets all keys matching pattern
fn set<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn set<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Set the string value of a key.
fn set_multiple<'a, K, V, RV>(
&'a mut self,
items: &'a [(K, V)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn set_multiple<'a, K, V, RV>(
&'a mut self,
items: &'a [(K, V)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Sets multiple keys to their values.
fn set_ex<'a, K, V, RV>(
&'a mut self,
key: K,
value: V,
seconds: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn set_ex<'a, K, V, RV>(
&'a mut self,
key: K,
value: V,
seconds: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Set the value and expiration of a key.
fn pset_ex<'a, K, V, RV>(
&'a mut self,
key: K,
value: V,
milliseconds: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn pset_ex<'a, K, V, RV>(
&'a mut self,
key: K,
value: V,
milliseconds: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Set the value and expiration in milliseconds of a key.
fn set_nx<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn set_nx<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Set the value of a key, only if the key does not exist
fn mset_nx<'a, K, V, RV>(
&'a mut self,
items: &'a [(K, V)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn mset_nx<'a, K, V, RV>(
&'a mut self,
items: &'a [(K, V)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Sets multiple keys to their values failing if at least one already exists.
fn getset<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn getset<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Set the string value of a key and return its old value.
fn getrange<'a, K, RV>(
&'a mut self,
key: K,
from: isize,
to: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn getrange<'a, K, RV>(
&'a mut self,
key: K,
from: isize,
to: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Get a range of bytes/substring from the value of a key. Negative values provide an offset from the end of the value.
fn setrange<'a, K, V, RV>(
&'a mut self,
key: K,
offset: isize,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn setrange<'a, K, V, RV>(
&'a mut self,
key: K,
offset: isize,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Overwrite the part of the value stored in key at the specified offset.
fn del<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn del<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Delete one or more keys.
fn exists<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn exists<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Determine if a key exists.
fn expire<'a, K, RV>(
&'a mut self,
key: K,
seconds: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn expire<'a, K, RV>(
&'a mut self,
key: K,
seconds: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Set a key’s time to live in seconds.
fn expire_at<'a, K, RV>(
&'a mut self,
key: K,
ts: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn expire_at<'a, K, RV>(
&'a mut self,
key: K,
ts: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Set the expiration for a key as a UNIX timestamp.
fn pexpire<'a, K, RV>(
&'a mut self,
key: K,
ms: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn pexpire<'a, K, RV>(
&'a mut self,
key: K,
ms: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Set a key’s time to live in milliseconds.
fn pexpire_at<'a, K, RV>(
&'a mut self,
key: K,
ts: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn pexpire_at<'a, K, RV>(
&'a mut self,
key: K,
ts: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Set the expiration for a key as a UNIX timestamp in milliseconds.
fn persist<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn persist<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Remove the expiration from a key.
fn ttl<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn ttl<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Get the expiration time of a key.
fn pttl<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn pttl<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Get the expiration time of a key in milliseconds.
fn rename<'a, K, RV>(
&'a mut self,
key: K,
new_key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn rename<'a, K, RV>(
&'a mut self,
key: K,
new_key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Rename a key.
fn rename_nx<'a, K, RV>(
&'a mut self,
key: K,
new_key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn rename_nx<'a, K, RV>(
&'a mut self,
key: K,
new_key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Rename a key, only if the new key does not exist.
fn unlink<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn unlink<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Unlink one or more keys.
fn append<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn append<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Append a value to a key.
fn incr<'a, K, V, RV>(
&'a mut self,
key: K,
delta: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn incr<'a, K, V, RV>(
&'a mut self,
key: K,
delta: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Increment the numeric value of a key by the given amount. This
issues a INCRBY
or INCRBYFLOAT
depending on the type. Read more
fn decr<'a, K, V, RV>(
&'a mut self,
key: K,
delta: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn decr<'a, K, V, RV>(
&'a mut self,
key: K,
delta: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Decrement the numeric value of a key by the given amount.
fn setbit<'a, K, RV>(
&'a mut self,
key: K,
offset: usize,
value: bool
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn setbit<'a, K, RV>(
&'a mut self,
key: K,
offset: usize,
value: bool
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Sets or clears the bit at offset in the string value stored at key.
fn getbit<'a, K, RV>(
&'a mut self,
key: K,
offset: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn getbit<'a, K, RV>(
&'a mut self,
key: K,
offset: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Returns the bit value at offset in the string value stored at key.
fn bitcount<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn bitcount<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Count set bits in a string.
fn bitcount_range<'a, K, RV>(
&'a mut self,
key: K,
start: usize,
end: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn bitcount_range<'a, K, RV>(
&'a mut self,
key: K,
start: usize,
end: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Count set bits in a string in a range.
fn bit_and<'a, K, RV>(
&'a mut self,
dstkey: K,
srckeys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn bit_and<'a, K, RV>(
&'a mut self,
dstkey: K,
srckeys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Perform a bitwise AND between multiple keys (containing string values) and store the result in the destination key. Read more
fn bit_or<'a, K, RV>(
&'a mut self,
dstkey: K,
srckeys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn bit_or<'a, K, RV>(
&'a mut self,
dstkey: K,
srckeys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Perform a bitwise OR between multiple keys (containing string values) and store the result in the destination key. Read more
fn bit_xor<'a, K, RV>(
&'a mut self,
dstkey: K,
srckeys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn bit_xor<'a, K, RV>(
&'a mut self,
dstkey: K,
srckeys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Perform a bitwise XOR between multiple keys (containing string values) and store the result in the destination key. Read more
fn bit_not<'a, K, RV>(
&'a mut self,
dstkey: K,
srckey: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn bit_not<'a, K, RV>(
&'a mut self,
dstkey: K,
srckey: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Perform a bitwise NOT of the key (containing string values) and store the result in the destination key. Read more
fn strlen<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn strlen<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Get the length of the value stored in a key.
fn hget<'a, K, F, RV>(
&'a mut self,
key: K,
field: F
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
F: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn hget<'a, K, F, RV>(
&'a mut self,
key: K,
field: F
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
F: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Gets a single (or multiple) fields from a hash.
fn hdel<'a, K, F, RV>(
&'a mut self,
key: K,
field: F
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
F: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn hdel<'a, K, F, RV>(
&'a mut self,
key: K,
field: F
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
F: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Deletes a single (or multiple) fields from a hash.
fn hset<'a, K, F, V, RV>(
&'a mut self,
key: K,
field: F,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
F: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn hset<'a, K, F, V, RV>(
&'a mut self,
key: K,
field: F,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
F: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Sets a single field in a hash.
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>> + 'a + Send, Global>> where
F: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
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>> + 'a + Send, Global>> where
F: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Sets a single field in a hash if it does not exist.
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>> + 'a + Send, Global>> where
F: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
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>> + 'a + Send, Global>> where
F: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Sets a multiple fields in a hash.
fn hincr<'a, K, F, D, RV>(
&'a mut self,
key: K,
field: F,
delta: D
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
F: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
D: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn hincr<'a, K, F, D, RV>(
&'a mut self,
key: K,
field: F,
delta: D
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
F: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
D: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Increments a value.
fn hexists<'a, K, F, RV>(
&'a mut self,
key: K,
field: F
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
F: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn hexists<'a, K, F, RV>(
&'a mut self,
key: K,
field: F
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
F: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Checks if a field in a hash exists.
fn hkeys<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn hkeys<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Gets all the keys in a hash.
fn hvals<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn hvals<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Gets all the values in a hash.
fn hgetall<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn hgetall<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Gets all the fields and values in a hash.
fn hlen<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn hlen<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Gets the length of a hash.
fn blpop<'a, K, RV>(
&'a mut self,
key: K,
timeout: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn blpop<'a, K, RV>(
&'a mut self,
key: K,
timeout: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Remove and get the first element in a list, or block until one is available.
fn brpop<'a, K, RV>(
&'a mut self,
key: K,
timeout: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn brpop<'a, K, RV>(
&'a mut self,
key: K,
timeout: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Remove and get the last element in a list, or block until one is available.
fn brpoplpush<'a, K, RV>(
&'a mut self,
srckey: K,
dstkey: K,
timeout: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn brpoplpush<'a, K, RV>(
&'a mut self,
srckey: K,
dstkey: K,
timeout: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Pop a value from a list, push it to another list and return it; or block until one is available. Read more
fn lindex<'a, K, RV>(
&'a mut self,
key: K,
index: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn lindex<'a, K, RV>(
&'a mut self,
key: K,
index: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Get an element from a list by its index.
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>> + 'a + Send, Global>> where
P: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
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>> + 'a + Send, Global>> where
P: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Insert an element before another element in a list.
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>> + 'a + Send, Global>> where
P: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
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>> + 'a + Send, Global>> where
P: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Insert an element after another element in a list.
fn llen<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn llen<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Returns the length of the list stored at key.
fn lpop<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn lpop<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Removes and returns the first element of the list stored at key.
fn lpos<'a, K, V, RV>(
&'a mut self,
key: K,
value: V,
options: LposOptions
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn lpos<'a, K, V, RV>(
&'a mut self,
key: K,
value: V,
options: LposOptions
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Returns the index of the first matching value of the list stored at key.
fn lpush<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn lpush<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Insert all the specified values at the head of the list stored at key.
fn lpush_exists<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn lpush_exists<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Inserts a value at the head of the list stored at key, only if key already exists and holds a list. Read more
fn lrange<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn lrange<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Returns the specified elements of the list stored at key.
fn lrem<'a, K, V, RV>(
&'a mut self,
key: K,
count: isize,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn lrem<'a, K, V, RV>(
&'a mut self,
key: K,
count: isize,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Removes the first count occurrences of elements equal to value from the list stored at key. Read more
fn ltrim<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn ltrim<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Trim an existing list so that it will contain only the specified range of elements specified. Read more
fn lset<'a, K, V, RV>(
&'a mut self,
key: K,
index: isize,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn lset<'a, K, V, RV>(
&'a mut self,
key: K,
index: isize,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Sets the list element at index to value
fn rpop<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn rpop<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Removes and returns the last element of the list stored at key.
fn rpoplpush<'a, K, RV>(
&'a mut self,
key: K,
dstkey: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn rpoplpush<'a, K, RV>(
&'a mut self,
key: K,
dstkey: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Pop a value from a list, push it to another list and return it.
fn rpush<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn rpush<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Insert all the specified values at the tail of the list stored at key.
fn rpush_exists<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn rpush_exists<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Inserts value at the tail of the list stored at key, only if key already exists and holds a list. Read more
fn sadd<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn sadd<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Add one or more members to a set.
fn scard<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn scard<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Get the number of members in a set.
fn sdiff<'a, K, RV>(
&'a mut self,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn sdiff<'a, K, RV>(
&'a mut self,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Subtract multiple sets.
fn sdiffstore<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn sdiffstore<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Subtract multiple sets and store the resulting set in a key.
fn sinter<'a, K, RV>(
&'a mut self,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn sinter<'a, K, RV>(
&'a mut self,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Intersect multiple sets.
fn sinterstore<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn sinterstore<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Intersect multiple sets and store the resulting set in a key.
fn sismember<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn sismember<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Determine if a given value is a member of a set.
fn smembers<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn smembers<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Get all the members in a set.
fn smove<'a, K, M, RV>(
&'a mut self,
srckey: K,
dstkey: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn smove<'a, K, M, RV>(
&'a mut self,
srckey: K,
dstkey: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Move a member from one set to another.
fn spop<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn spop<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Remove and return a random member from a set.
fn srandmember<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn srandmember<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Get one random member from a set.
fn srandmember_multiple<'a, K, RV>(
&'a mut self,
key: K,
count: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn srandmember_multiple<'a, K, RV>(
&'a mut self,
key: K,
count: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Get multiple random members from a set.
fn srem<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn srem<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Remove one or more members from a set.
fn sunion<'a, K, RV>(
&'a mut self,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn sunion<'a, K, RV>(
&'a mut self,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Add multiple sets.
fn sunionstore<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn sunionstore<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Add multiple sets and store the resulting set in a key.
fn zadd<'a, K, S, M, RV>(
&'a mut self,
key: K,
member: M,
score: S
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn zadd<'a, K, S, M, RV>(
&'a mut self,
key: K,
member: M,
score: S
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Add one member to a sorted set, or update its score if it already exists.
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>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
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>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Add multiple members to a sorted set, or update its score if it already exists.
fn zcard<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn zcard<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Get the number of members in a sorted set.
fn zcount<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]
fn zcount<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]Count the members in a sorted set with scores within the given values.
fn zincr<'a, K, M, D, RV>(
&'a mut self,
key: K,
member: M,
delta: D
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
D: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn zincr<'a, K, M, D, RV>(
&'a mut self,
key: K,
member: M,
delta: D
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
D: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]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
fn zinterstore<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn zinterstore<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Intersect multiple sorted sets and store the resulting sorted set in a new key using SUM as aggregation function. Read more
fn zinterstore_min<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn zinterstore_min<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Intersect multiple sorted sets and store the resulting sorted set in a new key using MIN as aggregation function. Read more
fn zinterstore_max<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn zinterstore_max<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Intersect multiple sorted sets and store the resulting sorted set in a new key using MAX as aggregation function. Read more
fn zlexcount<'a, K, L, RV>(
&'a mut self,
key: K,
min: L,
max: L
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
L: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn zlexcount<'a, K, L, RV>(
&'a mut self,
key: K,
min: L,
max: L
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
L: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Count the number of members in a sorted set between a given lexicographical range.
fn zpopmax<'a, K, RV>(
&'a mut self,
key: K,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn zpopmax<'a, K, RV>(
&'a mut self,
key: K,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Removes and returns up to count members with the highest scores in a sorted set
fn zpopmin<'a, K, RV>(
&'a mut self,
key: K,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn zpopmin<'a, K, RV>(
&'a mut self,
key: K,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Removes and returns up to count members with the lowest scores in a sorted set
fn zrange<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn zrange<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Return a range of members in a sorted set, by index
fn zrange_withscores<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn zrange_withscores<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Return a range of members in a sorted set, by index with scores.
fn zrangebylex<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]
fn zrangebylex<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]Return a range of members in a sorted set, by lexicographical range.
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>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]
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>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]Return a range of members in a sorted set, by lexicographical range with offset and limit. Read more
fn zrevrangebylex<'a, K, MM, M, RV>(
&'a mut self,
key: K,
max: MM,
min: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]
fn zrevrangebylex<'a, K, MM, M, RV>(
&'a mut self,
key: K,
max: MM,
min: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]Return a range of members in a sorted set, by lexicographical range.
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>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]
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>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]Return a range of members in a sorted set, by lexicographical range with offset and limit. Read more
fn zrangebyscore<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]
fn zrangebyscore<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]Return a range of members in a sorted set, by score.
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>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]
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>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]Return a range of members in a sorted set, by score with scores.
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>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]
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>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]Return a range of members in a sorted set, by score with limit.
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>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]
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>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]Return a range of members in a sorted set, by score with limit with scores.
fn zrank<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn zrank<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Determine the index of a member in a sorted set.
fn zrem<'a, K, M, RV>(
&'a mut self,
key: K,
members: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn zrem<'a, K, M, RV>(
&'a mut self,
key: K,
members: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Remove one or more members from a sorted set.
fn zrembylex<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]
fn zrembylex<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]Remove all members in a sorted set between the given lexicographical range.
fn zremrangebyrank<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn zremrangebyrank<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Remove all members in a sorted set within the given indexes.
fn zrembyscore<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]
fn zrembyscore<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]Remove all members in a sorted set within the given scores.
fn zrevrange<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn zrevrange<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Return a range of members in a sorted set, by index, with scores ordered from high to low. Read more
fn zrevrange_withscores<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn zrevrange_withscores<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Return a range of members in a sorted set, by index, with scores ordered from high to low. Read more
fn zrevrangebyscore<'a, K, MM, M, RV>(
&'a mut self,
key: K,
max: MM,
min: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]
fn zrevrangebyscore<'a, K, MM, M, RV>(
&'a mut self,
key: K,
max: MM,
min: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]Return a range of members in a sorted set, by score.
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>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]
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>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]Return a range of members in a sorted set, by score with scores.
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>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]
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>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]Return a range of members in a sorted set, by score with limit.
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>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]
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>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]Return a range of members in a sorted set, by score with limit with scores.
fn zrevrank<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn zrevrank<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Determine the index of a member in a sorted set, with scores ordered from high to low.
fn zscore<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn zscore<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Get the score associated with the given member in a sorted set.
fn zunionstore<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn zunionstore<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Unions multiple sorted sets and store the resulting sorted set in a new key using SUM as aggregation function. Read more
fn zunionstore_min<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn zunionstore_min<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Unions multiple sorted sets and store the resulting sorted set in a new key using MIN as aggregation function. Read more
fn zunionstore_max<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn zunionstore_max<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Unions multiple sorted sets and store the resulting sorted set in a new key using MAX as aggregation function. Read more
fn pfadd<'a, K, E, RV>(
&'a mut self,
key: K,
element: E
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
E: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn pfadd<'a, K, E, RV>(
&'a mut self,
key: K,
element: E
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
E: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Adds the specified elements to the specified HyperLogLog.
fn pfcount<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn pfcount<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s). Read more
fn pfmerge<'a, K, RV>(
&'a mut self,
dstkey: K,
srckeys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn pfmerge<'a, K, RV>(
&'a mut self,
dstkey: K,
srckeys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Merge N different HyperLogLogs into a single one.
fn publish<'a, K, E, RV>(
&'a mut self,
channel: K,
message: E
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
E: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn publish<'a, K, E, RV>(
&'a mut self,
channel: K,
message: E
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
E: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]Posts a message to the given channel.
fn xrevrange_all<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
fn xrevrange_all<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]This is the reverse version of xrange_all
.
The same rules apply for start
and end
here. Read more
fn scan<RV>(
&mut self
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where
RV: FromRedisValue,
[src]
fn scan<RV>(
&mut self
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where
RV: FromRedisValue,
[src]Incrementally iterate the keys space.
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,
[src]
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,
[src]Incrementally iterate set elements for elements matching a pattern.
fn hscan<K, RV>(
&mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn hscan<K, RV>(
&mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]Incrementally iterate hash fields and associated values.
fn hscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where
P: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn hscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where
P: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
[src]Incrementally iterate hash fields and associated values for field names matching a pattern. Read more
fn sscan<K, RV>(
&mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn sscan<K, RV>(
&mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]Incrementally iterate set elements.
fn sscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where
P: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn sscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where
P: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
[src]Incrementally iterate set elements for elements matching a pattern.
fn zscan<K, RV>(
&mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zscan<K, RV>(
&mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]Incrementally iterate sorted set elements.
fn zscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where
P: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where
P: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
[src]Incrementally iterate sorted set elements for elements matching a pattern.
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]pub fn borrow_mut(&mut self) -> &mut T
[src]
pub fn borrow_mut(&mut self) -> &mut T
[src]Mutably borrows from an owned value. Read more