pub struct SentinelConnection { /* private fields */ }redis only.Expand description
A connection to the primary that Redis Sentinel names, which follows a failover:
- A command the server refused with
READONLYorLOADING, or that the connection refused to send, didn’t run: the connection asks Sentinel for the primary, moves there, and sends it once more. A demoted Dragonfly primary answersLOADINGwhile it syncs from the new one. - A command cut off on the way may have run, so it returns its error at once, and the connection asks Sentinel in the background and moves for the next one.
- While Sentinel names the same primary, the connection stays and reconnects by itself.
- Clones share the connection, so one move moves all of them.
It moves on an error, not on Sentinel’s announcement. After a manual failover the old primary
keeps accepting writes until Sentinel demotes it, about ten seconds later, and those writes are
lost. Reads keep answering from it, as a replica, until the next write or a
primary_client call moves the connection.
Its connections use connection_config, so while the primary is down a command fails at
once instead of waiting for the old primary to come back. A command that can’t reach the
primary also waits for one Sentinel lookup, which every caller failing at the same time shares,
before it is sent once more.
use sisa_caching_redis::{
RedisCacheStore, SentinelConnection,
redis::sentinel::{SentinelClient, SentinelServerType},
};
let sentinel = SentinelClient::build(
vec!["redis://10.0.0.1:26379", "redis://10.0.0.2:26379"],
String::from("mymaster"),
None,
SentinelServerType::Master,
)?;
let conn = SentinelConnection::connect(sentinel).await?;
let cache = RedisCacheStore::new("app", conn)?;Implementations§
Source§impl SentinelConnection
impl SentinelConnection
Sourcepub async fn connect(
sentinel: SentinelClient,
) -> Result<SentinelConnection, RedisError>
pub async fn connect( sentinel: SentinelClient, ) -> Result<SentinelConnection, RedisError>
Asks Sentinel for the primary and connects to it. Build sentinel with
SentinelServerType::Master.
Sourcepub async fn primary_client(&self) -> Result<Client, RedisError>
pub async fn primary_client(&self) -> Result<Client, RedisError>
Asks Sentinel for the primary, moves this connection there if it isn’t there yet, and
returns a client for it, for connections this one can’t carry, such as pub/sub. A
subscription opened with it and this connection’s reads then use the same primary. A
hybrid store’s backplane calls it every heartbeat_timeout_ms while subscribed, so reads
leave a demoted primary even when nothing fails there.
Trait Implementations§
Source§impl Clone for SentinelConnection
impl Clone for SentinelConnection
Source§fn clone(&self) -> SentinelConnection
fn clone(&self) -> SentinelConnection
1.0.0 (const: unstable) · Source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source. Read moreSource§impl ConnectionLike for SentinelConnection
impl ConnectionLike for SentinelConnection
Source§impl Debug for SentinelConnection
impl Debug for SentinelConnection
Source§impl RedisConnection for SentinelConnection
impl RedisConnection for SentinelConnection
Auto Trait Implementations§
impl !RefUnwindSafe for SentinelConnection
impl !UnwindSafe for SentinelConnection
impl Freeze for SentinelConnection
impl Send for SentinelConnection
impl Sync for SentinelConnection
impl Unpin for SentinelConnection
impl UnsafeUnpin for SentinelConnection
Blanket Implementations§
Source§impl<T> AsyncCommands for T
impl<T> AsyncCommands for T
Source§fn get<'a, K, RV>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn get<'a, K, RV>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
MGET (if using TypedCommands, you should specifically use mget to get the correct return type.
Redis DocsSource§fn mget<'a, K, RV>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn mget<'a, K, RV>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn keys<'a, K, RV>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn keys<'a, K, RV>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn set<'a, K, V, RV>(
&'a mut self,
key: K,
value: V,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn set_options<'a, K, V, RV>(
&'a mut self,
key: K,
value: V,
options: SetOptions,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
fn set_options<'a, K, V, RV>(
&'a mut self,
key: K,
value: V,
options: SetOptions,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn mset<'a, K, V, RV>(
&'a mut self,
items: &'a [(K, V)],
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn mset<'a, K, V, RV>( &'a mut self, items: &'a [(K, V)], ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn set_ex<'a, K, V, RV>(
&'a mut self,
key: K,
value: V,
seconds: u64,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
fn set_ex<'a, K, V, RV>(
&'a mut self,
key: K,
value: V,
seconds: u64,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn pset_ex<'a, K, V, RV>(
&'a mut self,
key: K,
value: V,
milliseconds: u64,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
fn pset_ex<'a, K, V, RV>(
&'a mut self,
key: K,
value: V,
milliseconds: u64,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn set_nx<'a, K, V, RV>(
&'a mut self,
key: K,
value: V,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn mset_nx<'a, K, V, RV>(
&'a mut self,
items: &'a [(K, V)],
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn mset_nx<'a, K, V, RV>( &'a mut self, items: &'a [(K, V)], ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn mset_ex<'a, K, V, RV>(
&'a mut self,
items: &'a [(K, V)],
options: MSetOptions,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn mset_ex<'a, K, V, RV>( &'a mut self, items: &'a [(K, V)], options: MSetOptions, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn getset<'a, K, V, RV>(
&'a mut self,
key: K,
value: V,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn getrange<'a, K, RV>(
&'a mut self,
key: K,
from: isize,
to: isize,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn getrange<'a, K, RV>( &'a mut self, key: K, from: isize, to: isize, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn del<'a, K, RV>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn del<'a, K, RV>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn del_ex<'a, K, RV>(
&'a mut self,
key: K,
value_comparison: ValueComparison,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn del_ex<'a, K, RV>( &'a mut self, key: K, value_comparison: ValueComparison, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
match-value - Delete the key only if its value is equal to match-value
IFNE match-value - Delete the key only if its value is not equal to match-value
IFDEQ match-digest - Delete the key only if the digest of its value is equal to match-digest
IFDNE match-digest - Delete the key only if the digest of its value is not equal to match-digest
Redis DocsSource§fn digest<'a, K, RV>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn digest<'a, K, RV>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn exists<'a, K, RV>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn exists<'a, K, RV>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn key_type<'a, K, RV>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn key_type<'a, K, RV>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn expire<'a, K, RV>(
&'a mut self,
key: K,
seconds: i64,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn expire<'a, K, RV>( &'a mut self, key: K, seconds: i64, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn expire_at<'a, K, RV>(
&'a mut self,
key: K,
ts: i64,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn expire_at<'a, K, RV>( &'a mut self, key: K, ts: i64, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn pexpire<'a, K, RV>(
&'a mut self,
key: K,
ms: i64,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn pexpire<'a, K, RV>( &'a mut self, key: K, ms: i64, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn pexpire_at<'a, K, RV>(
&'a mut self,
key: K,
ts: i64,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn pexpire_at<'a, K, RV>( &'a mut self, key: K, ts: i64, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn expire_time<'a, K, RV>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn expire_time<'a, K, RV>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
ExistsButNotRelevant if key exists but has no expiration time.
Redis DocsSource§fn pexpire_time<'a, K, RV>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn pexpire_time<'a, K, RV>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
ExistsButNotRelevant if key exists but has no expiration time.
Redis DocsSource§fn persist<'a, K, RV>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn persist<'a, K, RV>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn ttl<'a, K, RV>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn ttl<'a, K, RV>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
ExistsButNotRelevant if key exists but has no expiration time.
Redis DocsSource§fn pttl<'a, K, RV>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn pttl<'a, K, RV>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
ExistsButNotRelevant if key exists but has no expiration time.
Redis DocsSource§fn get_ex<'a, K, RV>(
&'a mut self,
key: K,
expire_at: Expiry,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn get_ex<'a, K, RV>( &'a mut self, key: K, expire_at: Expiry, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn get_del<'a, K, RV>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn get_del<'a, K, RV>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn copy<'a, KSrc, KDst, Db, RV>(
&'a mut self,
source: KSrc,
destination: KDst,
options: CopyOptions<Db>,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
KSrc: ToSingleRedisArg + Send + Sync + 'a,
KDst: ToSingleRedisArg + Send + Sync + 'a,
Db: ToString + Send + Sync + 'a,
RV: FromRedisValue,
fn copy<'a, KSrc, KDst, Db, RV>(
&'a mut self,
source: KSrc,
destination: KDst,
options: CopyOptions<Db>,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
KSrc: ToSingleRedisArg + Send + Sync + 'a,
KDst: ToSingleRedisArg + Send + Sync + 'a,
Db: ToString + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn rename<'a, K, N, RV>(
&'a mut self,
key: K,
new_key: N,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
N: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
fn rename<'a, K, N, RV>(
&'a mut self,
key: K,
new_key: N,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
N: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn rename_nx<'a, K, N, RV>(
&'a mut self,
key: K,
new_key: N,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
N: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
fn rename_nx<'a, K, N, RV>(
&'a mut self,
key: K,
new_key: N,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
N: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn unlink<'a, K, RV>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn unlink<'a, K, RV>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
DEL.
Returns number of keys unlinked.
Redis DocsSource§fn append<'a, K, V, RV>(
&'a mut self,
key: K,
value: V,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn incr<'a, K, V, RV>(
&'a mut self,
key: K,
delta: V,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
INCRBY or INCRBYFLOAT depending on the type.
If the key does not exist, it is set to 0 before performing the operation.Source§fn decr<'a, K, V, RV>(
&'a mut self,
key: K,
delta: V,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn increx<'a, K, V, RV>(
&'a mut self,
key: K,
increment: V,
options: IncrexOptions<V>,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
fn increx<'a, K, V, RV>(
&'a mut self,
key: K,
increment: V,
options: IncrexOptions<V>,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn setbit<'a, K, RV>(
&'a mut self,
key: K,
offset: usize,
value: bool,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn setbit<'a, K, RV>( &'a mut self, key: K, offset: usize, value: bool, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn getbit<'a, K, RV>(
&'a mut self,
key: K,
offset: usize,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn getbit<'a, K, RV>( &'a mut self, key: K, offset: usize, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn bitcount<'a, K, RV>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn bitcount<'a, K, RV>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§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>>
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>>
Source§fn bit_and<'a, D, S, RV>(
&'a mut self,
dstkey: D,
srckeys: S,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
S: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn bit_and<'a, D, S, RV>(
&'a mut self,
dstkey: D,
srckeys: S,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
S: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn bit_or<'a, D, S, RV>(
&'a mut self,
dstkey: D,
srckeys: S,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
S: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn bit_or<'a, D, S, RV>(
&'a mut self,
dstkey: D,
srckeys: S,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
S: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn bit_xor<'a, D, S, RV>(
&'a mut self,
dstkey: D,
srckeys: S,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
S: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn bit_xor<'a, D, S, RV>(
&'a mut self,
dstkey: D,
srckeys: S,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
S: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn bit_not<'a, D, S, RV>(
&'a mut self,
dstkey: D,
srckey: S,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
S: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
fn bit_not<'a, D, S, RV>(
&'a mut self,
dstkey: D,
srckey: S,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
S: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn bit_diff<'a, D, S, RV>(
&'a mut self,
dstkey: D,
srckeys: S,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
S: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn bit_diff<'a, D, S, RV>(
&'a mut self,
dstkey: D,
srckeys: S,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
S: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Perform a set difference to extract the members of X that are not members of any of Y1, Y2,….
Logical representation: X ∧ ¬(Y1 ∨ Y2 ∨ …)
Redis Docs
Source§fn bit_diff1<'a, D, S, RV>(
&'a mut self,
dstkey: D,
srckeys: S,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
S: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn bit_diff1<'a, D, S, RV>(
&'a mut self,
dstkey: D,
srckeys: S,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
S: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Perform a relative complement set difference to extract the members of one or more of Y1, Y2,… that are not members of X.
Logical representation: ¬X ∧ (Y1 ∨ Y2 ∨ …)
Redis Docs
Source§fn bit_and_or<'a, D, S, RV>(
&'a mut self,
dstkey: D,
srckeys: S,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
S: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn bit_and_or<'a, D, S, RV>(
&'a mut self,
dstkey: D,
srckeys: S,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
S: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Perform an “intersection of union(s)” operation to extract the members of X that are also members of one or more of Y1, Y2,….
Logical representation: X ∧ (Y1 ∨ Y2 ∨ …)
Redis Docs
Source§fn bit_one<'a, D, S, RV>(
&'a mut self,
dstkey: D,
srckeys: S,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
S: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn bit_one<'a, D, S, RV>(
&'a mut self,
dstkey: D,
srckeys: S,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
S: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Perform an “exclusive membership” operation to extract the members of exactly one of X, Y1, Y2, ….
Logical representation: (X ∨ Y1 ∨ Y2 ∨ …) ∧ ¬((X ∧ Y1) ∨ (X ∧ Y2) ∨ (Y1 ∧ Y2) ∨ (Y1 ∧ Y3) ∨ …)
Redis Docs
Source§fn strlen<'a, K, RV>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn strlen<'a, K, RV>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn hget<'a, K, F, RV>(
&'a mut self,
key: K,
field: F,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn hmget<'a, K, F, RV>(
&'a mut self,
key: K,
fields: F,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn hmget<'a, K, F, RV>(
&'a mut self,
key: K,
fields: F,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn hget_ex<'a, K, F, RV>(
&'a mut self,
key: K,
fields: F,
expire_at: Expiry,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn hget_ex<'a, K, F, RV>(
&'a mut self,
key: K,
fields: F,
expire_at: Expiry,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn hdel<'a, K, F, RV>(
&'a mut self,
key: K,
field: F,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn hget_del<'a, K, F, RV>(
&'a mut self,
key: K,
fields: F,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn hget_del<'a, K, F, RV>(
&'a mut self,
key: K,
fields: F,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn hset_ex<'a, K, F, V, RV>(
&'a mut self,
key: K,
hash_field_expiration_options: &'a HashFieldExpirationOptions,
fields_values: &'a [(F, V)],
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
V: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn hset_ex<'a, K, F, V, RV>(
&'a mut self,
key: K,
hash_field_expiration_options: &'a HashFieldExpirationOptions,
fields_values: &'a [(F, V)],
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
V: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
V: ToRedisArgs + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
V: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToSingleRedisArg + Send + Sync + 'a,
D: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToSingleRedisArg + Send + Sync + 'a,
D: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn hexists<'a, K, F, RV>(
&'a mut self,
key: K,
field: F,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn httl<'a, K, F, RV>(
&'a mut self,
key: K,
fields: F,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn httl<'a, K, F, RV>(
&'a mut self,
key: K,
fields: F,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn hpttl<'a, K, F, RV>(
&'a mut self,
key: K,
fields: F,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn hpttl<'a, K, F, RV>(
&'a mut self,
key: K,
fields: F,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn hexpire<'a, K, F, RV>(
&'a mut self,
key: K,
seconds: i64,
opt: ExpireOption,
fields: F,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn hexpire<'a, K, F, RV>(
&'a mut self,
key: K,
seconds: i64,
opt: ExpireOption,
fields: F,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn hexpire_at<'a, K, F, RV>(
&'a mut self,
key: K,
ts: i64,
opt: ExpireOption,
fields: F,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn hexpire_at<'a, K, F, RV>(
&'a mut self,
key: K,
ts: i64,
opt: ExpireOption,
fields: F,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn hexpire_time<'a, K, F, RV>(
&'a mut self,
key: K,
fields: F,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn hexpire_time<'a, K, F, RV>(
&'a mut self,
key: K,
fields: F,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn hpersist<'a, K, F, RV>(
&'a mut self,
key: K,
fields: F,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn hpersist<'a, K, F, RV>(
&'a mut self,
key: K,
fields: F,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn hpexpire<'a, K, F, RV>(
&'a mut self,
key: K,
milliseconds: i64,
opt: ExpireOption,
fields: F,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn hpexpire<'a, K, F, RV>(
&'a mut self,
key: K,
milliseconds: i64,
opt: ExpireOption,
fields: F,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn hpexpire_at<'a, K, F, RV>(
&'a mut self,
key: K,
ts: i64,
opt: ExpireOption,
fields: F,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn hpexpire_at<'a, K, F, RV>(
&'a mut self,
key: K,
ts: i64,
opt: ExpireOption,
fields: F,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn hpexpire_time<'a, K, F, RV>(
&'a mut self,
key: K,
fields: F,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn hpexpire_time<'a, K, F, RV>(
&'a mut self,
key: K,
fields: F,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn hkeys<'a, K, RV>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn hkeys<'a, K, RV>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn hvals<'a, K, RV>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn hvals<'a, K, RV>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn hgetall<'a, K, RV>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn hgetall<'a, K, RV>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn hlen<'a, K, RV>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn hlen<'a, K, RV>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn blmove<'a, S, D, RV>(
&'a mut self,
srckey: S,
dstkey: D,
src_dir: Direction,
dst_dir: Direction,
timeout: f64,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
S: ToSingleRedisArg + Send + Sync + 'a,
D: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
fn blmove<'a, S, D, RV>(
&'a mut self,
srckey: S,
dstkey: D,
src_dir: Direction,
dst_dir: Direction,
timeout: f64,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
S: ToSingleRedisArg + Send + Sync + 'a,
D: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn blmpop<'a, K, RV>(
&'a mut self,
timeout: f64,
numkeys: usize,
key: K,
dir: Direction,
count: usize,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn blmpop<'a, K, RV>( &'a mut self, timeout: f64, numkeys: usize, key: K, dir: Direction, count: usize, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
count elements from the first non-empty list key from the list of
provided key names; or blocks until one is available.
Redis DocsSource§fn blpop<'a, K, RV>(
&'a mut self,
key: K,
timeout: f64,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn blpop<'a, K, RV>( &'a mut self, key: K, timeout: f64, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn brpop<'a, K, RV>(
&'a mut self,
key: K,
timeout: f64,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn brpop<'a, K, RV>( &'a mut self, key: K, timeout: f64, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn brpoplpush<'a, S, D, RV>(
&'a mut self,
srckey: S,
dstkey: D,
timeout: f64,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
S: ToSingleRedisArg + Send + Sync + 'a,
D: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
fn brpoplpush<'a, S, D, RV>(
&'a mut self,
srckey: S,
dstkey: D,
timeout: f64,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
S: ToSingleRedisArg + Send + Sync + 'a,
D: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn lindex<'a, K, RV>(
&'a mut self,
key: K,
index: isize,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn lindex<'a, K, RV>( &'a mut self, key: K, index: isize, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
P: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
P: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
P: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
P: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn llen<'a, K, RV>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn llen<'a, K, RV>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn lmove<'a, S, D, RV>(
&'a mut self,
srckey: S,
dstkey: D,
src_dir: Direction,
dst_dir: Direction,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
S: ToSingleRedisArg + Send + Sync + 'a,
D: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
fn lmove<'a, S, D, RV>(
&'a mut self,
srckey: S,
dstkey: D,
src_dir: Direction,
dst_dir: Direction,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
S: ToSingleRedisArg + Send + Sync + 'a,
D: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§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>>
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>>
count elements from the first non-empty list key from the list of
provided key names.
Redis DocsSource§fn lpop<'a, K, RV>(
&'a mut self,
key: K,
count: Option<NonZero<usize>>,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn lpop<'a, K, RV>( &'a mut self, key: K, count: Option<NonZero<usize>>, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
count first elements of the list stored at key. Read moreSource§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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn lpush<'a, K, V, RV>(
&'a mut self,
key: K,
value: V,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToRedisArgs + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn lpush_exists<'a, K, V, RV>(
&'a mut self,
key: K,
value: V,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToRedisArgs + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn lrange<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn lrange<'a, K, RV>( &'a mut self, key: K, start: isize, stop: isize, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn ltrim<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn ltrim<'a, K, RV>( &'a mut self, key: K, start: isize, stop: isize, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn ping<'a, RV>(
&'a mut self,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
RV: FromRedisValue,
fn ping<'a, RV>(
&'a mut self,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
RV: FromRedisValue,
Source§fn ping_message<'a, K, RV>(
&'a mut self,
message: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn ping_message<'a, K, RV>( &'a mut self, message: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn rpop<'a, K, RV>(
&'a mut self,
key: K,
count: Option<NonZero<usize>>,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn rpop<'a, K, RV>( &'a mut self, key: K, count: Option<NonZero<usize>>, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
count last elements of the list stored at key Read moreSource§fn rpoplpush<'a, K, D, RV>(
&'a mut self,
key: K,
dstkey: D,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
D: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
fn rpoplpush<'a, K, D, RV>(
&'a mut self,
key: K,
dstkey: D,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
D: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn rpush<'a, K, V, RV>(
&'a mut self,
key: K,
value: V,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToRedisArgs + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn rpush_exists<'a, K, V, RV>(
&'a mut self,
key: K,
value: V,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToRedisArgs + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn sadd<'a, K, M, RV>(
&'a mut self,
key: K,
member: M,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToRedisArgs + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn scard<'a, K, RV>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn scard<'a, K, RV>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn sdiff<'a, K, RV>(
&'a mut self,
keys: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn sdiff<'a, K, RV>( &'a mut self, keys: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn sdiffstore<'a, D, K, RV>(
&'a mut self,
dstkey: D,
keys: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn sdiffstore<'a, D, K, RV>(
&'a mut self,
dstkey: D,
keys: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn sinter<'a, K, RV>(
&'a mut self,
keys: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn sinter<'a, K, RV>( &'a mut self, keys: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn sinterstore<'a, D, K, RV>(
&'a mut self,
dstkey: D,
keys: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn sinterstore<'a, D, K, RV>(
&'a mut self,
dstkey: D,
keys: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn sismember<'a, K, M, RV>(
&'a mut self,
key: K,
member: M,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn smismember<'a, K, M, RV>(
&'a mut self,
key: K,
members: M,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn smismember<'a, K, M, RV>(
&'a mut self,
key: K,
members: M,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn smembers<'a, K, RV>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn smembers<'a, K, RV>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn smove<'a, S, D, M, RV>(
&'a mut self,
srckey: S,
dstkey: D,
member: M,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
S: ToSingleRedisArg + Send + Sync + 'a,
D: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
fn smove<'a, S, D, M, RV>(
&'a mut self,
srckey: S,
dstkey: D,
member: M,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
S: ToSingleRedisArg + Send + Sync + 'a,
D: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn spop<'a, K, RV>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn spop<'a, K, RV>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn srandmember<'a, K, RV>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn srandmember<'a, K, RV>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn srandmember_multiple<'a, K, RV>(
&'a mut self,
key: K,
count: isize,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn srandmember_multiple<'a, K, RV>( &'a mut self, key: K, count: isize, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn srem<'a, K, M, RV>(
&'a mut self,
key: K,
member: M,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToRedisArgs + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn sunion<'a, K, RV>(
&'a mut self,
keys: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn sunion<'a, K, RV>( &'a mut self, keys: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn sunionstore<'a, D, K, RV>(
&'a mut self,
dstkey: D,
keys: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn sunionstore<'a, D, K, RV>(
&'a mut self,
dstkey: D,
keys: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
S: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
S: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
S: ToRedisArgs + Send + Sync + 'a,
M: ToRedisArgs + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
S: ToRedisArgs + Send + Sync + 'a,
M: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn zadd_options<'a, K, S, M, RV>(
&'a mut self,
key: K,
member: M,
score: S,
options: &'a SortedSetAddOptions,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
S: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
fn zadd_options<'a, K, S, M, RV>(
&'a mut self,
key: K,
member: M,
score: S,
options: &'a SortedSetAddOptions,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
S: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn zadd_multiple_options<'a, K, S, M, RV>(
&'a mut self,
key: K,
items: &'a [(S, M)],
options: &'a SortedSetAddOptions,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
S: ToRedisArgs + Send + Sync + 'a,
M: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn zadd_multiple_options<'a, K, S, M, RV>(
&'a mut self,
key: K,
items: &'a [(S, M)],
options: &'a SortedSetAddOptions,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
S: ToRedisArgs + Send + Sync + 'a,
M: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn zcard<'a, K, RV>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn zcard<'a, K, RV>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
D: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
D: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn zinterstore<'a, D, K, RV>(
&'a mut self,
dstkey: D,
keys: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn zinterstore<'a, D, K, RV>(
&'a mut self,
dstkey: D,
keys: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn zinterstore_min<'a, D, K, RV>(
&'a mut self,
dstkey: D,
keys: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn zinterstore_min<'a, D, K, RV>(
&'a mut self,
dstkey: D,
keys: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn zinterstore_max<'a, D, K, RV>(
&'a mut self,
dstkey: D,
keys: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn zinterstore_max<'a, D, K, RV>(
&'a mut self,
dstkey: D,
keys: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn zinterstore_weights<'a, D, K, W, RV>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn zinterstore_weights<'a, D, K, W, RV>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
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.
Redis DocsSource§fn zinterstore_min_weights<'a, D, K, W, RV>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn zinterstore_min_weights<'a, D, K, W, RV>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
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.
Redis DocsSource§fn zinterstore_max_weights<'a, D, K, W, RV>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn zinterstore_max_weights<'a, D, K, W, RV>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
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.
Redis DocsSource§fn zlexcount<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
fn zlexcount<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn bzpopmax<'a, K, RV>(
&'a mut self,
key: K,
timeout: f64,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn bzpopmax<'a, K, RV>( &'a mut self, key: K, timeout: f64, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn zpopmax<'a, K, RV>(
&'a mut self,
key: K,
count: isize,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn zpopmax<'a, K, RV>( &'a mut self, key: K, count: isize, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn bzpopmin<'a, K, RV>(
&'a mut self,
key: K,
timeout: f64,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn bzpopmin<'a, K, RV>( &'a mut self, key: K, timeout: f64, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn zpopmin<'a, K, RV>(
&'a mut self,
key: K,
count: isize,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn zpopmin<'a, K, RV>( &'a mut self, key: K, count: isize, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn bzmpop_max<'a, K, RV>(
&'a mut self,
timeout: f64,
keys: K,
count: isize,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn bzmpop_max<'a, K, RV>( &'a mut self, timeout: f64, keys: K, count: isize, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn zmpop_max<'a, K, RV>(
&'a mut self,
keys: K,
count: isize,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn zmpop_max<'a, K, RV>( &'a mut self, keys: K, count: isize, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn bzmpop_min<'a, K, RV>(
&'a mut self,
timeout: f64,
keys: K,
count: isize,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn bzmpop_min<'a, K, RV>( &'a mut self, timeout: f64, keys: K, count: isize, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn zmpop_min<'a, K, RV>(
&'a mut self,
keys: K,
count: isize,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn zmpop_min<'a, K, RV>( &'a mut self, keys: K, count: isize, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn zrandmember<'a, K, RV>(
&'a mut self,
key: K,
count: Option<isize>,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn zrandmember<'a, K, RV>( &'a mut self, key: K, count: Option<isize>, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
count == None)
Redis DocsSource§fn zrandmember_withscores<'a, K, RV>(
&'a mut self,
key: K,
count: isize,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn zrandmember_withscores<'a, K, RV>( &'a mut self, key: K, count: isize, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn zrange<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn zrange<'a, K, RV>( &'a mut self, key: K, start: isize, stop: isize, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§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>>
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>>
Source§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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn zrank<'a, K, M, RV>(
&'a mut self,
key: K,
member: M,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn zrem<'a, K, M, RV>(
&'a mut self,
key: K,
members: M,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToRedisArgs + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn zremrangebyrank<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn zremrangebyrank<'a, K, RV>( &'a mut self, key: K, start: isize, stop: isize, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn zrevrange<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn zrevrange<'a, K, RV>( &'a mut self, key: K, start: isize, stop: isize, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§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>>
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>>
Source§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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn zrevrank<'a, K, M, RV>(
&'a mut self,
key: K,
member: M,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn zscore<'a, K, M, RV>(
&'a mut self,
key: K,
member: M,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToRedisArgs + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn zunionstore<'a, D, K, RV>(
&'a mut self,
dstkey: D,
keys: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn zunionstore<'a, D, K, RV>(
&'a mut self,
dstkey: D,
keys: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn zunionstore_min<'a, D, K, RV>(
&'a mut self,
dstkey: D,
keys: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn zunionstore_min<'a, D, K, RV>(
&'a mut self,
dstkey: D,
keys: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn zunionstore_max<'a, D, K, RV>(
&'a mut self,
dstkey: D,
keys: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn zunionstore_max<'a, D, K, RV>(
&'a mut self,
dstkey: D,
keys: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn zunionstore_weights<'a, D, K, W, RV>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn zunionstore_weights<'a, D, K, W, RV>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
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.
Redis DocsSource§fn zunionstore_min_weights<'a, D, K, W, RV>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn zunionstore_min_weights<'a, D, K, W, RV>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
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.
Redis DocsSource§fn zunionstore_max_weights<'a, D, K, W, RV>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn zunionstore_max_weights<'a, D, K, W, RV>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
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.
Redis DocsSource§fn pfadd<'a, K, E, RV>(
&'a mut self,
key: K,
element: E,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
E: ToRedisArgs + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
E: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn pfcount<'a, K, RV>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn pfcount<'a, K, RV>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn pfmerge<'a, D, S, RV>(
&'a mut self,
dstkey: D,
srckeys: S,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
S: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
fn pfmerge<'a, D, S, RV>(
&'a mut self,
dstkey: D,
srckeys: S,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
S: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn publish<'a, K, E, RV>(
&'a mut self,
channel: K,
message: E,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
E: ToSingleRedisArg + Send + Sync + 'a,
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>>where
K: ToSingleRedisArg + Send + Sync + 'a,
E: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn spublish<'a, K, E, RV>(
&'a mut self,
channel: K,
message: E,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
E: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
fn spublish<'a, K, E, RV>(
&'a mut self,
channel: K,
message: E,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
E: ToSingleRedisArg + Send + Sync + 'a,
RV: FromRedisValue,
Source§fn object_encoding<'a, K, RV>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn object_encoding<'a, K, RV>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn object_idletime<'a, K, RV>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn object_idletime<'a, K, RV>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn object_freq<'a, K, RV>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn object_freq<'a, K, RV>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn object_refcount<'a, K, RV>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn object_refcount<'a, K, RV>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn client_getname<'a, RV>(
&'a mut self,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
RV: FromRedisValue,
fn client_getname<'a, RV>(
&'a mut self,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
RV: FromRedisValue,
Source§fn client_id<'a, RV>(
&'a mut self,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
RV: FromRedisValue,
fn client_id<'a, RV>(
&'a mut self,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
RV: FromRedisValue,
Source§fn client_setname<'a, K, RV>(
&'a mut self,
connection_name: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn client_setname<'a, K, RV>( &'a mut self, connection_name: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn flushall<'a, RV>(
&'a mut self,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
RV: FromRedisValue,
fn flushall<'a, RV>(
&'a mut self,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
RV: FromRedisValue,
Source§fn flushall_options<'a, RV>(
&'a mut self,
options: &'a FlushAllOptions,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
RV: FromRedisValue,
fn flushall_options<'a, RV>(
&'a mut self,
options: &'a FlushAllOptions,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
RV: FromRedisValue,
Source§fn flushdb<'a, RV>(
&'a mut self,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
RV: FromRedisValue,
fn flushdb<'a, RV>(
&'a mut self,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
RV: FromRedisValue,
Source§fn flushdb_options<'a, RV>(
&'a mut self,
options: &'a FlushAllOptions,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
RV: FromRedisValue,
fn flushdb_options<'a, RV>(
&'a mut self,
options: &'a FlushAllOptions,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
RV: FromRedisValue,
Source§fn scan<RV>(
&mut self,
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send + '_>>where
RV: FromRedisValue,
fn scan<RV>(
&mut self,
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send + '_>>where
RV: FromRedisValue,
Source§fn scan_options<RV>(
&mut self,
opts: ScanOptions,
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send + '_>>where
RV: FromRedisValue,
fn scan_options<RV>(
&mut self,
opts: ScanOptions,
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send + '_>>where
RV: FromRedisValue,
Source§fn scan_match<P, RV>(
&mut self,
pattern: P,
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send + '_>>where
P: ToSingleRedisArg,
RV: FromRedisValue,
fn scan_match<P, RV>(
&mut self,
pattern: P,
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send + '_>>where
P: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn hscan<K, RV>(
&mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send + '_>>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn hscan<K, RV>(
&mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send + '_>>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn hscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P,
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send + '_>>
fn hscan_match<K, P, RV>( &mut self, key: K, pattern: P, ) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send + '_>>
Source§fn sscan<K, RV>(
&mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send + '_>>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn sscan<K, RV>(
&mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send + '_>>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn sscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P,
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send + '_>>
fn sscan_match<K, P, RV>( &mut self, key: K, pattern: P, ) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send + '_>>
Source§fn zscan<K, RV>(
&mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send + '_>>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn zscan<K, RV>(
&mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send + '_>>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn zscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P,
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send + '_>>
fn zscan_match<K, P, RV>( &mut self, key: K, pattern: P, ) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send + '_>>
Source§impl<T> AsyncTypedCommands for T
impl<T> AsyncTypedCommands for T
Source§fn get<'a, K>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<Option<String>, RedisError>> + Send + 'a>>
fn get<'a, K>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<Option<String>, RedisError>> + Send + 'a>>
MGET (if using TypedCommands, you should specifically use mget to get the correct return type.
Redis DocsSource§fn mget<'a, K>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<Vec<Option<String>>, RedisError>> + Send + 'a>>
fn mget<'a, K>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<Vec<Option<String>>, RedisError>> + Send + 'a>>
Source§fn keys<'a, K>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>
fn keys<'a, K>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>
Source§fn set<'a, K, V>(
&'a mut self,
key: K,
value: V,
) -> Pin<Box<dyn Future<Output = Result<(), RedisError>> + Send + 'a>>
fn set<'a, K, V>( &'a mut self, key: K, value: V, ) -> Pin<Box<dyn Future<Output = Result<(), RedisError>> + Send + 'a>>
Source§fn set_options<'a, K, V>(
&'a mut self,
key: K,
value: V,
options: SetOptions,
) -> Pin<Box<dyn Future<Output = Result<Option<String>, RedisError>> + Send + 'a>>
fn set_options<'a, K, V>( &'a mut self, key: K, value: V, options: SetOptions, ) -> Pin<Box<dyn Future<Output = Result<Option<String>, RedisError>> + Send + 'a>>
Source§fn mset<'a, K, V>(
&'a mut self,
items: &'a [(K, V)],
) -> Pin<Box<dyn Future<Output = Result<(), RedisError>> + Send + 'a>>
fn mset<'a, K, V>( &'a mut self, items: &'a [(K, V)], ) -> Pin<Box<dyn Future<Output = Result<(), RedisError>> + Send + 'a>>
Source§fn set_ex<'a, K, V>(
&'a mut self,
key: K,
value: V,
seconds: u64,
) -> Pin<Box<dyn Future<Output = Result<(), RedisError>> + Send + 'a>>
fn set_ex<'a, K, V>( &'a mut self, key: K, value: V, seconds: u64, ) -> Pin<Box<dyn Future<Output = Result<(), RedisError>> + Send + 'a>>
Source§fn pset_ex<'a, K, V>(
&'a mut self,
key: K,
value: V,
milliseconds: u64,
) -> Pin<Box<dyn Future<Output = Result<(), RedisError>> + Send + 'a>>
fn pset_ex<'a, K, V>( &'a mut self, key: K, value: V, milliseconds: u64, ) -> Pin<Box<dyn Future<Output = Result<(), RedisError>> + Send + 'a>>
Source§fn set_nx<'a, K, V>(
&'a mut self,
key: K,
value: V,
) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>
fn set_nx<'a, K, V>( &'a mut self, key: K, value: V, ) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>
Source§fn mset_nx<'a, K, V>(
&'a mut self,
items: &'a [(K, V)],
) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>
fn mset_nx<'a, K, V>( &'a mut self, items: &'a [(K, V)], ) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>
Source§fn mset_ex<'a, K, V>(
&'a mut self,
items: &'a [(K, V)],
options: MSetOptions,
) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>
fn mset_ex<'a, K, V>( &'a mut self, items: &'a [(K, V)], options: MSetOptions, ) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>
Source§fn getset<'a, K, V>(
&'a mut self,
key: K,
value: V,
) -> Pin<Box<dyn Future<Output = Result<Option<String>, RedisError>> + Send + 'a>>
fn getset<'a, K, V>( &'a mut self, key: K, value: V, ) -> Pin<Box<dyn Future<Output = Result<Option<String>, RedisError>> + Send + 'a>>
Source§fn getrange<'a, K>(
&'a mut self,
key: K,
from: isize,
to: isize,
) -> Pin<Box<dyn Future<Output = Result<String, RedisError>> + Send + 'a>>
fn getrange<'a, K>( &'a mut self, key: K, from: isize, to: isize, ) -> Pin<Box<dyn Future<Output = Result<String, RedisError>> + Send + 'a>>
Source§fn setrange<'a, K, V>(
&'a mut self,
key: K,
offset: isize,
value: V,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn setrange<'a, K, V>( &'a mut self, key: K, offset: isize, value: V, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Source§fn del<'a, K>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn del<'a, K>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Source§fn del_ex<'a, K>(
&'a mut self,
key: K,
value_comparison: ValueComparison,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn del_ex<'a, K>( &'a mut self, key: K, value_comparison: ValueComparison, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
match-value - Delete the key only if its value is equal to match-value
IFNE match-value - Delete the key only if its value is not equal to match-value
IFDEQ match-digest - Delete the key only if the digest of its value is equal to match-digest
IFDNE match-digest - Delete the key only if the digest of its value is not equal to match-digest
Redis DocsSource§fn digest<'a, K>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<Option<String>, RedisError>> + Send + 'a>>
fn digest<'a, K>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<Option<String>, RedisError>> + Send + 'a>>
Source§fn exists<'a, K>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>
fn exists<'a, K>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>
Source§fn key_type<'a, K>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<ValueType, RedisError>> + Send + 'a>>
fn key_type<'a, K>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<ValueType, RedisError>> + Send + 'a>>
Source§fn expire<'a, K>(
&'a mut self,
key: K,
seconds: i64,
) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>
fn expire<'a, K>( &'a mut self, key: K, seconds: i64, ) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>
Source§fn expire_at<'a, K>(
&'a mut self,
key: K,
ts: i64,
) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>
fn expire_at<'a, K>( &'a mut self, key: K, ts: i64, ) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>
Source§fn pexpire<'a, K>(
&'a mut self,
key: K,
ms: i64,
) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>
fn pexpire<'a, K>( &'a mut self, key: K, ms: i64, ) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>
Source§fn pexpire_at<'a, K>(
&'a mut self,
key: K,
ts: i64,
) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>
fn pexpire_at<'a, K>( &'a mut self, key: K, ts: i64, ) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>
Source§fn expire_time<'a, K>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<IntegerReplyOrNoOp, RedisError>> + Send + 'a>>
fn expire_time<'a, K>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<IntegerReplyOrNoOp, RedisError>> + Send + 'a>>
ExistsButNotRelevant if key exists but has no expiration time.
Redis DocsSource§fn pexpire_time<'a, K>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<IntegerReplyOrNoOp, RedisError>> + Send + 'a>>
fn pexpire_time<'a, K>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<IntegerReplyOrNoOp, RedisError>> + Send + 'a>>
ExistsButNotRelevant if key exists but has no expiration time.
Redis DocsSource§fn persist<'a, K>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>
fn persist<'a, K>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>
Source§fn ttl<'a, K>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<IntegerReplyOrNoOp, RedisError>> + Send + 'a>>
fn ttl<'a, K>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<IntegerReplyOrNoOp, RedisError>> + Send + 'a>>
ExistsButNotRelevant if key exists but has no expiration time.
Redis DocsSource§fn pttl<'a, K>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<IntegerReplyOrNoOp, RedisError>> + Send + 'a>>
fn pttl<'a, K>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<IntegerReplyOrNoOp, RedisError>> + Send + 'a>>
ExistsButNotRelevant if key exists but has no expiration time.
Redis DocsSource§fn get_ex<'a, K>(
&'a mut self,
key: K,
expire_at: Expiry,
) -> Pin<Box<dyn Future<Output = Result<Option<String>, RedisError>> + Send + 'a>>
fn get_ex<'a, K>( &'a mut self, key: K, expire_at: Expiry, ) -> Pin<Box<dyn Future<Output = Result<Option<String>, RedisError>> + Send + 'a>>
Source§fn get_del<'a, K>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<Option<String>, RedisError>> + Send + 'a>>
fn get_del<'a, K>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<Option<String>, RedisError>> + Send + 'a>>
Source§fn copy<'a, KSrc, KDst, Db>(
&'a mut self,
source: KSrc,
destination: KDst,
options: CopyOptions<Db>,
) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>where
KSrc: ToSingleRedisArg + Send + Sync + 'a,
KDst: ToSingleRedisArg + Send + Sync + 'a,
Db: ToString + Send + Sync + 'a,
fn copy<'a, KSrc, KDst, Db>(
&'a mut self,
source: KSrc,
destination: KDst,
options: CopyOptions<Db>,
) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>where
KSrc: ToSingleRedisArg + Send + Sync + 'a,
KDst: ToSingleRedisArg + Send + Sync + 'a,
Db: ToString + Send + Sync + 'a,
Source§fn rename<'a, K, N>(
&'a mut self,
key: K,
new_key: N,
) -> Pin<Box<dyn Future<Output = Result<(), RedisError>> + Send + 'a>>
fn rename<'a, K, N>( &'a mut self, key: K, new_key: N, ) -> Pin<Box<dyn Future<Output = Result<(), RedisError>> + Send + 'a>>
Source§fn rename_nx<'a, K, N>(
&'a mut self,
key: K,
new_key: N,
) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>
fn rename_nx<'a, K, N>( &'a mut self, key: K, new_key: N, ) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>
Source§fn unlink<'a, K>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn unlink<'a, K>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
DEL.
Returns number of keys unlinked.
Redis DocsSource§fn append<'a, K, V>(
&'a mut self,
key: K,
value: V,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn append<'a, K, V>( &'a mut self, key: K, value: V, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Source§fn incr<'a, K, V>(
&'a mut self,
key: K,
delta: V,
) -> Pin<Box<dyn Future<Output = Result<isize, RedisError>> + Send + 'a>>
fn incr<'a, K, V>( &'a mut self, key: K, delta: V, ) -> Pin<Box<dyn Future<Output = Result<isize, RedisError>> + Send + 'a>>
INCRBY or INCRBYFLOAT depending on the type.
If the key does not exist, it is set to 0 before performing the operation.Source§fn decr<'a, K, V>(
&'a mut self,
key: K,
delta: V,
) -> Pin<Box<dyn Future<Output = Result<isize, RedisError>> + Send + 'a>>
fn decr<'a, K, V>( &'a mut self, key: K, delta: V, ) -> Pin<Box<dyn Future<Output = Result<isize, RedisError>> + Send + 'a>>
Source§fn increx<'a, K, V>(
&'a mut self,
key: K,
increment: V,
options: IncrexOptions<V>,
) -> Pin<Box<dyn Future<Output = Result<IncrexResult, RedisError>> + Send + 'a>>
fn increx<'a, K, V>( &'a mut self, key: K, increment: V, options: IncrexOptions<V>, ) -> Pin<Box<dyn Future<Output = Result<IncrexResult, RedisError>> + Send + 'a>>
Source§fn setbit<'a, K>(
&'a mut self,
key: K,
offset: usize,
value: bool,
) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>
fn setbit<'a, K>( &'a mut self, key: K, offset: usize, value: bool, ) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>
Source§fn getbit<'a, K>(
&'a mut self,
key: K,
offset: usize,
) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>
fn getbit<'a, K>( &'a mut self, key: K, offset: usize, ) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>
Source§fn bitcount<'a, K>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn bitcount<'a, K>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Source§fn bitcount_range<'a, K>(
&'a mut self,
key: K,
start: usize,
end: usize,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn bitcount_range<'a, K>( &'a mut self, key: K, start: usize, end: usize, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Source§fn bit_and<'a, D, S>(
&'a mut self,
dstkey: D,
srckeys: S,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn bit_and<'a, D, S>( &'a mut self, dstkey: D, srckeys: S, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Source§fn bit_or<'a, D, S>(
&'a mut self,
dstkey: D,
srckeys: S,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn bit_or<'a, D, S>( &'a mut self, dstkey: D, srckeys: S, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Source§fn bit_xor<'a, D, S>(
&'a mut self,
dstkey: D,
srckeys: S,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn bit_xor<'a, D, S>( &'a mut self, dstkey: D, srckeys: S, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Source§fn bit_not<'a, D, S>(
&'a mut self,
dstkey: D,
srckey: S,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn bit_not<'a, D, S>( &'a mut self, dstkey: D, srckey: S, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Source§fn bit_diff<'a, D, S>(
&'a mut self,
dstkey: D,
srckeys: S,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn bit_diff<'a, D, S>( &'a mut self, dstkey: D, srckeys: S, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Perform a set difference to extract the members of X that are not members of any of Y1, Y2,….
Logical representation: X ∧ ¬(Y1 ∨ Y2 ∨ …)
Redis Docs
Source§fn bit_diff1<'a, D, S>(
&'a mut self,
dstkey: D,
srckeys: S,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn bit_diff1<'a, D, S>( &'a mut self, dstkey: D, srckeys: S, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Perform a relative complement set difference to extract the members of one or more of Y1, Y2,… that are not members of X.
Logical representation: ¬X ∧ (Y1 ∨ Y2 ∨ …)
Redis Docs
Source§fn bit_and_or<'a, D, S>(
&'a mut self,
dstkey: D,
srckeys: S,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn bit_and_or<'a, D, S>( &'a mut self, dstkey: D, srckeys: S, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Perform an “intersection of union(s)” operation to extract the members of X that are also members of one or more of Y1, Y2,….
Logical representation: X ∧ (Y1 ∨ Y2 ∨ …)
Redis Docs
Source§fn bit_one<'a, D, S>(
&'a mut self,
dstkey: D,
srckeys: S,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn bit_one<'a, D, S>( &'a mut self, dstkey: D, srckeys: S, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Perform an “exclusive membership” operation to extract the members of exactly one of X, Y1, Y2, ….
Logical representation: (X ∨ Y1 ∨ Y2 ∨ …) ∧ ¬((X ∧ Y1) ∨ (X ∧ Y2) ∨ (Y1 ∧ Y2) ∨ (Y1 ∧ Y3) ∨ …)
Redis Docs
Source§fn strlen<'a, K>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn strlen<'a, K>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Source§fn hget<'a, K, F>(
&'a mut self,
key: K,
field: F,
) -> Pin<Box<dyn Future<Output = Result<Option<String>, RedisError>> + Send + 'a>>
fn hget<'a, K, F>( &'a mut self, key: K, field: F, ) -> Pin<Box<dyn Future<Output = Result<Option<String>, RedisError>> + Send + 'a>>
Source§fn hmget<'a, K, F>(
&'a mut self,
key: K,
fields: F,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>
fn hmget<'a, K, F>( &'a mut self, key: K, fields: F, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>
Source§fn hget_ex<'a, K, F>(
&'a mut self,
key: K,
fields: F,
expire_at: Expiry,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>
fn hget_ex<'a, K, F>( &'a mut self, key: K, fields: F, expire_at: Expiry, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>
Source§fn hdel<'a, K, F>(
&'a mut self,
key: K,
field: F,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn hdel<'a, K, F>( &'a mut self, key: K, field: F, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Source§fn hget_del<'a, K, F>(
&'a mut self,
key: K,
fields: F,
) -> Pin<Box<dyn Future<Output = Result<Vec<Option<String>>, RedisError>> + Send + 'a>>
fn hget_del<'a, K, F>( &'a mut self, key: K, fields: F, ) -> Pin<Box<dyn Future<Output = Result<Vec<Option<String>>, RedisError>> + Send + 'a>>
Source§fn hset<'a, K, F, V>(
&'a mut self,
key: K,
field: F,
value: V,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
fn hset<'a, K, F, V>(
&'a mut self,
key: K,
field: F,
value: V,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
Source§fn hset_ex<'a, K, F, V>(
&'a mut self,
key: K,
hash_field_expiration_options: &'a HashFieldExpirationOptions,
fields_values: &'a [(F, V)],
) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
V: ToRedisArgs + Send + Sync + 'a,
fn hset_ex<'a, K, F, V>(
&'a mut self,
key: K,
hash_field_expiration_options: &'a HashFieldExpirationOptions,
fields_values: &'a [(F, V)],
) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
V: ToRedisArgs + Send + Sync + 'a,
Source§fn hset_nx<'a, K, F, V>(
&'a mut self,
key: K,
field: F,
value: V,
) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
fn hset_nx<'a, K, F, V>(
&'a mut self,
key: K,
field: F,
value: V,
) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
Source§fn hset_multiple<'a, K, F, V>(
&'a mut self,
key: K,
items: &'a [(F, V)],
) -> Pin<Box<dyn Future<Output = Result<(), RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
V: ToRedisArgs + Send + Sync + 'a,
fn hset_multiple<'a, K, F, V>(
&'a mut self,
key: K,
items: &'a [(F, V)],
) -> Pin<Box<dyn Future<Output = Result<(), RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
V: ToRedisArgs + Send + Sync + 'a,
Source§fn hincr<'a, K, F, D>(
&'a mut self,
key: K,
field: F,
delta: D,
) -> Pin<Box<dyn Future<Output = Result<f64, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToSingleRedisArg + Send + Sync + 'a,
D: ToSingleRedisArg + Send + Sync + 'a,
fn hincr<'a, K, F, D>(
&'a mut self,
key: K,
field: F,
delta: D,
) -> Pin<Box<dyn Future<Output = Result<f64, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToSingleRedisArg + Send + Sync + 'a,
D: ToSingleRedisArg + Send + Sync + 'a,
Source§fn hexists<'a, K, F>(
&'a mut self,
key: K,
field: F,
) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>
fn hexists<'a, K, F>( &'a mut self, key: K, field: F, ) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>
Source§fn httl<'a, K, F>(
&'a mut self,
key: K,
fields: F,
) -> Pin<Box<dyn Future<Output = Result<Vec<IntegerReplyOrNoOp>, RedisError>> + Send + 'a>>
fn httl<'a, K, F>( &'a mut self, key: K, fields: F, ) -> Pin<Box<dyn Future<Output = Result<Vec<IntegerReplyOrNoOp>, RedisError>> + Send + 'a>>
Source§fn hpttl<'a, K, F>(
&'a mut self,
key: K,
fields: F,
) -> Pin<Box<dyn Future<Output = Result<Vec<IntegerReplyOrNoOp>, RedisError>> + Send + 'a>>
fn hpttl<'a, K, F>( &'a mut self, key: K, fields: F, ) -> Pin<Box<dyn Future<Output = Result<Vec<IntegerReplyOrNoOp>, RedisError>> + Send + 'a>>
Source§fn hexpire<'a, K, F>(
&'a mut self,
key: K,
seconds: i64,
opt: ExpireOption,
fields: F,
) -> Pin<Box<dyn Future<Output = Result<Vec<IntegerReplyOrNoOp>, RedisError>> + Send + 'a>>
fn hexpire<'a, K, F>( &'a mut self, key: K, seconds: i64, opt: ExpireOption, fields: F, ) -> Pin<Box<dyn Future<Output = Result<Vec<IntegerReplyOrNoOp>, RedisError>> + Send + 'a>>
Source§fn hexpire_at<'a, K, F>(
&'a mut self,
key: K,
ts: i64,
opt: ExpireOption,
fields: F,
) -> Pin<Box<dyn Future<Output = Result<Vec<IntegerReplyOrNoOp>, RedisError>> + Send + 'a>>
fn hexpire_at<'a, K, F>( &'a mut self, key: K, ts: i64, opt: ExpireOption, fields: F, ) -> Pin<Box<dyn Future<Output = Result<Vec<IntegerReplyOrNoOp>, RedisError>> + Send + 'a>>
Source§fn hexpire_time<'a, K, F>(
&'a mut self,
key: K,
fields: F,
) -> Pin<Box<dyn Future<Output = Result<Vec<IntegerReplyOrNoOp>, RedisError>> + Send + 'a>>
fn hexpire_time<'a, K, F>( &'a mut self, key: K, fields: F, ) -> Pin<Box<dyn Future<Output = Result<Vec<IntegerReplyOrNoOp>, RedisError>> + Send + 'a>>
Source§fn hpersist<'a, K, F>(
&'a mut self,
key: K,
fields: F,
) -> Pin<Box<dyn Future<Output = Result<Vec<IntegerReplyOrNoOp>, RedisError>> + Send + 'a>>
fn hpersist<'a, K, F>( &'a mut self, key: K, fields: F, ) -> Pin<Box<dyn Future<Output = Result<Vec<IntegerReplyOrNoOp>, RedisError>> + Send + 'a>>
Source§fn hpexpire<'a, K, F>(
&'a mut self,
key: K,
milliseconds: i64,
opt: ExpireOption,
fields: F,
) -> Pin<Box<dyn Future<Output = Result<Vec<IntegerReplyOrNoOp>, RedisError>> + Send + 'a>>
fn hpexpire<'a, K, F>( &'a mut self, key: K, milliseconds: i64, opt: ExpireOption, fields: F, ) -> Pin<Box<dyn Future<Output = Result<Vec<IntegerReplyOrNoOp>, RedisError>> + Send + 'a>>
Source§fn hpexpire_at<'a, K, F>(
&'a mut self,
key: K,
ts: i64,
opt: ExpireOption,
fields: F,
) -> Pin<Box<dyn Future<Output = Result<Vec<IntegerReplyOrNoOp>, RedisError>> + Send + 'a>>
fn hpexpire_at<'a, K, F>( &'a mut self, key: K, ts: i64, opt: ExpireOption, fields: F, ) -> Pin<Box<dyn Future<Output = Result<Vec<IntegerReplyOrNoOp>, RedisError>> + Send + 'a>>
Source§fn hpexpire_time<'a, K, F>(
&'a mut self,
key: K,
fields: F,
) -> Pin<Box<dyn Future<Output = Result<Vec<IntegerReplyOrNoOp>, RedisError>> + Send + 'a>>
fn hpexpire_time<'a, K, F>( &'a mut self, key: K, fields: F, ) -> Pin<Box<dyn Future<Output = Result<Vec<IntegerReplyOrNoOp>, RedisError>> + Send + 'a>>
Source§fn hkeys<'a, K>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>
fn hkeys<'a, K>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>
Source§fn hvals<'a, K>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>
fn hvals<'a, K>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>
Source§fn hgetall<'a, K>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<HashMap<String, String>, RedisError>> + Send + 'a>>
fn hgetall<'a, K>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<HashMap<String, String>, RedisError>> + Send + 'a>>
Source§fn hlen<'a, K>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn hlen<'a, K>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Source§fn blmove<'a, S, D>(
&'a mut self,
srckey: S,
dstkey: D,
src_dir: Direction,
dst_dir: Direction,
timeout: f64,
) -> Pin<Box<dyn Future<Output = Result<Option<String>, RedisError>> + Send + 'a>>
fn blmove<'a, S, D>( &'a mut self, srckey: S, dstkey: D, src_dir: Direction, dst_dir: Direction, timeout: f64, ) -> Pin<Box<dyn Future<Output = Result<Option<String>, RedisError>> + Send + 'a>>
Source§fn blmpop<'a, K>(
&'a mut self,
timeout: f64,
numkeys: usize,
key: K,
dir: Direction,
count: usize,
) -> Pin<Box<dyn Future<Output = Result<Option<[String; 2]>, RedisError>> + Send + 'a>>
fn blmpop<'a, K>( &'a mut self, timeout: f64, numkeys: usize, key: K, dir: Direction, count: usize, ) -> Pin<Box<dyn Future<Output = Result<Option<[String; 2]>, RedisError>> + Send + 'a>>
count elements from the first non-empty list key from the list of
provided key names; or blocks until one is available.
Redis DocsSource§fn blpop<'a, K>(
&'a mut self,
key: K,
timeout: f64,
) -> Pin<Box<dyn Future<Output = Result<Option<[String; 2]>, RedisError>> + Send + 'a>>
fn blpop<'a, K>( &'a mut self, key: K, timeout: f64, ) -> Pin<Box<dyn Future<Output = Result<Option<[String; 2]>, RedisError>> + Send + 'a>>
Source§fn brpop<'a, K>(
&'a mut self,
key: K,
timeout: f64,
) -> Pin<Box<dyn Future<Output = Result<Option<[String; 2]>, RedisError>> + Send + 'a>>
fn brpop<'a, K>( &'a mut self, key: K, timeout: f64, ) -> Pin<Box<dyn Future<Output = Result<Option<[String; 2]>, RedisError>> + Send + 'a>>
Source§fn brpoplpush<'a, S, D>(
&'a mut self,
srckey: S,
dstkey: D,
timeout: f64,
) -> Pin<Box<dyn Future<Output = Result<Option<String>, RedisError>> + Send + 'a>>
fn brpoplpush<'a, S, D>( &'a mut self, srckey: S, dstkey: D, timeout: f64, ) -> Pin<Box<dyn Future<Output = Result<Option<String>, RedisError>> + Send + 'a>>
Source§fn lindex<'a, K>(
&'a mut self,
key: K,
index: isize,
) -> Pin<Box<dyn Future<Output = Result<Option<String>, RedisError>> + Send + 'a>>
fn lindex<'a, K>( &'a mut self, key: K, index: isize, ) -> Pin<Box<dyn Future<Output = Result<Option<String>, RedisError>> + Send + 'a>>
Source§fn linsert_before<'a, K, P, V>(
&'a mut self,
key: K,
pivot: P,
value: V,
) -> Pin<Box<dyn Future<Output = Result<isize, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
P: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
fn linsert_before<'a, K, P, V>(
&'a mut self,
key: K,
pivot: P,
value: V,
) -> Pin<Box<dyn Future<Output = Result<isize, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
P: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
Source§fn linsert_after<'a, K, P, V>(
&'a mut self,
key: K,
pivot: P,
value: V,
) -> Pin<Box<dyn Future<Output = Result<isize, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
P: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
fn linsert_after<'a, K, P, V>(
&'a mut self,
key: K,
pivot: P,
value: V,
) -> Pin<Box<dyn Future<Output = Result<isize, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
P: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
Source§fn llen<'a, K>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn llen<'a, K>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Source§fn lmove<'a, S, D>(
&'a mut self,
srckey: S,
dstkey: D,
src_dir: Direction,
dst_dir: Direction,
) -> Pin<Box<dyn Future<Output = Result<String, RedisError>> + Send + 'a>>
fn lmove<'a, S, D>( &'a mut self, srckey: S, dstkey: D, src_dir: Direction, dst_dir: Direction, ) -> Pin<Box<dyn Future<Output = Result<String, RedisError>> + Send + 'a>>
Source§fn lmpop<'a, K>(
&'a mut self,
numkeys: usize,
key: K,
dir: Direction,
count: usize,
) -> Pin<Box<dyn Future<Output = Result<Option<(String, Vec<String>)>, RedisError>> + Send + 'a>>
fn lmpop<'a, K>( &'a mut self, numkeys: usize, key: K, dir: Direction, count: usize, ) -> Pin<Box<dyn Future<Output = Result<Option<(String, Vec<String>)>, RedisError>> + Send + 'a>>
count elements from the first non-empty list key from the list of
provided key names.
Redis DocsSource§fn lpop<'a, RV, K>(
&'a mut self,
key: K,
count: Option<NonZero<usize>>,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn lpop<'a, RV, K>( &'a mut self, key: K, count: Option<NonZero<usize>>, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
count first elements of the list stored at key. Read moreSource§fn lpos<'a, RV, K, V>(
&'a mut self,
key: K,
value: V,
options: LposOptions,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
RV: FromRedisValue,
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
fn lpos<'a, RV, K, V>(
&'a mut self,
key: K,
value: V,
options: LposOptions,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>where
RV: FromRedisValue,
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
Source§fn lpush<'a, K, V>(
&'a mut self,
key: K,
value: V,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn lpush<'a, K, V>( &'a mut self, key: K, value: V, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Source§fn lpush_exists<'a, K, V>(
&'a mut self,
key: K,
value: V,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn lpush_exists<'a, K, V>( &'a mut self, key: K, value: V, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Source§fn lrange<'a, K>(
&'a mut self,
key: K,
start: isize,
stop: isize,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>
fn lrange<'a, K>( &'a mut self, key: K, start: isize, stop: isize, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>
Source§fn lrem<'a, K, V>(
&'a mut self,
key: K,
count: isize,
value: V,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn lrem<'a, K, V>( &'a mut self, key: K, count: isize, value: V, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Source§fn ltrim<'a, K>(
&'a mut self,
key: K,
start: isize,
stop: isize,
) -> Pin<Box<dyn Future<Output = Result<(), RedisError>> + Send + 'a>>
fn ltrim<'a, K>( &'a mut self, key: K, start: isize, stop: isize, ) -> Pin<Box<dyn Future<Output = Result<(), RedisError>> + Send + 'a>>
Source§fn lset<'a, K, V>(
&'a mut self,
key: K,
index: isize,
value: V,
) -> Pin<Box<dyn Future<Output = Result<(), RedisError>> + Send + 'a>>
fn lset<'a, K, V>( &'a mut self, key: K, index: isize, value: V, ) -> Pin<Box<dyn Future<Output = Result<(), RedisError>> + Send + 'a>>
Source§fn ping<'a>(
&'a mut self,
) -> Pin<Box<dyn Future<Output = Result<String, RedisError>> + Send + 'a>>
fn ping<'a>( &'a mut self, ) -> Pin<Box<dyn Future<Output = Result<String, RedisError>> + Send + 'a>>
Source§fn ping_message<'a, K>(
&'a mut self,
message: K,
) -> Pin<Box<dyn Future<Output = Result<String, RedisError>> + Send + 'a>>
fn ping_message<'a, K>( &'a mut self, message: K, ) -> Pin<Box<dyn Future<Output = Result<String, RedisError>> + Send + 'a>>
Source§fn rpop<'a, RV, K>(
&'a mut self,
key: K,
count: Option<NonZero<usize>>,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn rpop<'a, RV, K>( &'a mut self, key: K, count: Option<NonZero<usize>>, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
count last elements of the list stored at key Read moreSource§fn rpoplpush<'a, K, D>(
&'a mut self,
key: K,
dstkey: D,
) -> Pin<Box<dyn Future<Output = Result<Option<String>, RedisError>> + Send + 'a>>
fn rpoplpush<'a, K, D>( &'a mut self, key: K, dstkey: D, ) -> Pin<Box<dyn Future<Output = Result<Option<String>, RedisError>> + Send + 'a>>
Source§fn rpush<'a, K, V>(
&'a mut self,
key: K,
value: V,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn rpush<'a, K, V>( &'a mut self, key: K, value: V, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Source§fn rpush_exists<'a, K, V>(
&'a mut self,
key: K,
value: V,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn rpush_exists<'a, K, V>( &'a mut self, key: K, value: V, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Source§fn sadd<'a, K, M>(
&'a mut self,
key: K,
member: M,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn sadd<'a, K, M>( &'a mut self, key: K, member: M, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Source§fn scard<'a, K>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn scard<'a, K>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Source§fn sdiff<'a, K>(
&'a mut self,
keys: K,
) -> Pin<Box<dyn Future<Output = Result<HashSet<String>, RedisError>> + Send + 'a>>
fn sdiff<'a, K>( &'a mut self, keys: K, ) -> Pin<Box<dyn Future<Output = Result<HashSet<String>, RedisError>> + Send + 'a>>
Source§fn sdiffstore<'a, D, K>(
&'a mut self,
dstkey: D,
keys: K,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn sdiffstore<'a, D, K>( &'a mut self, dstkey: D, keys: K, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Source§fn sinter<'a, K>(
&'a mut self,
keys: K,
) -> Pin<Box<dyn Future<Output = Result<HashSet<String>, RedisError>> + Send + 'a>>
fn sinter<'a, K>( &'a mut self, keys: K, ) -> Pin<Box<dyn Future<Output = Result<HashSet<String>, RedisError>> + Send + 'a>>
Source§fn sinterstore<'a, D, K>(
&'a mut self,
dstkey: D,
keys: K,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn sinterstore<'a, D, K>( &'a mut self, dstkey: D, keys: K, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Source§fn sismember<'a, K, M>(
&'a mut self,
key: K,
member: M,
) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>
fn sismember<'a, K, M>( &'a mut self, key: K, member: M, ) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>
Source§fn smismember<'a, K, M>(
&'a mut self,
key: K,
members: M,
) -> Pin<Box<dyn Future<Output = Result<Vec<bool>, RedisError>> + Send + 'a>>
fn smismember<'a, K, M>( &'a mut self, key: K, members: M, ) -> Pin<Box<dyn Future<Output = Result<Vec<bool>, RedisError>> + Send + 'a>>
Source§fn smembers<'a, K>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<HashSet<String>, RedisError>> + Send + 'a>>
fn smembers<'a, K>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<HashSet<String>, RedisError>> + Send + 'a>>
Source§fn smove<'a, S, D, M>(
&'a mut self,
srckey: S,
dstkey: D,
member: M,
) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>where
S: ToSingleRedisArg + Send + Sync + 'a,
D: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
fn smove<'a, S, D, M>(
&'a mut self,
srckey: S,
dstkey: D,
member: M,
) -> Pin<Box<dyn Future<Output = Result<bool, RedisError>> + Send + 'a>>where
S: ToSingleRedisArg + Send + Sync + 'a,
D: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
Source§fn spop<'a, RV, K>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn spop<'a, RV, K>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn srandmember<'a, K>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<Option<String>, RedisError>> + Send + 'a>>
fn srandmember<'a, K>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<Option<String>, RedisError>> + Send + 'a>>
Source§fn srandmember_multiple<'a, K>(
&'a mut self,
key: K,
count: isize,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>
fn srandmember_multiple<'a, K>( &'a mut self, key: K, count: isize, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>
Source§fn srem<'a, K, M>(
&'a mut self,
key: K,
member: M,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn srem<'a, K, M>( &'a mut self, key: K, member: M, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Source§fn sunion<'a, K>(
&'a mut self,
keys: K,
) -> Pin<Box<dyn Future<Output = Result<HashSet<String>, RedisError>> + Send + 'a>>
fn sunion<'a, K>( &'a mut self, keys: K, ) -> Pin<Box<dyn Future<Output = Result<HashSet<String>, RedisError>> + Send + 'a>>
Source§fn sunionstore<'a, D, K>(
&'a mut self,
dstkey: D,
keys: K,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn sunionstore<'a, D, K>( &'a mut self, dstkey: D, keys: K, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Source§fn zadd<'a, K, S, M>(
&'a mut self,
key: K,
member: M,
score: S,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
S: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
fn zadd<'a, K, S, M>(
&'a mut self,
key: K,
member: M,
score: S,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
S: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zadd_multiple<'a, K, S, M>(
&'a mut self,
key: K,
items: &'a [(S, M)],
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
S: ToRedisArgs + Send + Sync + 'a,
M: ToRedisArgs + Send + Sync + 'a,
fn zadd_multiple<'a, K, S, M>(
&'a mut self,
key: K,
items: &'a [(S, M)],
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
S: ToRedisArgs + Send + Sync + 'a,
M: ToRedisArgs + Send + Sync + 'a,
Source§fn zadd_options<'a, K, S, M>(
&'a mut self,
key: K,
member: M,
score: S,
options: &'a SortedSetAddOptions,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
S: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
fn zadd_options<'a, K, S, M>(
&'a mut self,
key: K,
member: M,
score: S,
options: &'a SortedSetAddOptions,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
S: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zadd_multiple_options<'a, K, S, M>(
&'a mut self,
key: K,
items: &'a [(S, M)],
options: &'a SortedSetAddOptions,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
S: ToRedisArgs + Send + Sync + 'a,
M: ToRedisArgs + Send + Sync + 'a,
fn zadd_multiple_options<'a, K, S, M>(
&'a mut self,
key: K,
items: &'a [(S, M)],
options: &'a SortedSetAddOptions,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
S: ToRedisArgs + Send + Sync + 'a,
M: ToRedisArgs + Send + Sync + 'a,
Source§fn zcard<'a, K>(
&'a mut self,
key: K,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn zcard<'a, K>( &'a mut self, key: K, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Source§fn zcount<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
fn zcount<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zincr<'a, K, M, D>(
&'a mut self,
key: K,
member: M,
delta: D,
) -> Pin<Box<dyn Future<Output = Result<f64, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
D: ToSingleRedisArg + Send + Sync + 'a,
fn zincr<'a, K, M, D>(
&'a mut self,
key: K,
member: M,
delta: D,
) -> Pin<Box<dyn Future<Output = Result<f64, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
D: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zinterstore<'a, D, K>(
&'a mut self,
dstkey: D,
keys: K,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn zinterstore<'a, D, K>( &'a mut self, dstkey: D, keys: K, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Source§fn zinterstore_min<'a, D, K>(
&'a mut self,
dstkey: D,
keys: K,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn zinterstore_min<'a, D, K>( &'a mut self, dstkey: D, keys: K, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Source§fn zinterstore_max<'a, D, K>(
&'a mut self,
dstkey: D,
keys: K,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn zinterstore_max<'a, D, K>( &'a mut self, dstkey: D, keys: K, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Source§fn zinterstore_weights<'a, D, K, W>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
fn zinterstore_weights<'a, D, K, W>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
Commands::zinterstore, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.
Redis DocsSource§fn zinterstore_min_weights<'a, D, K, W>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
fn zinterstore_min_weights<'a, D, K, W>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
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.
Redis DocsSource§fn zinterstore_max_weights<'a, D, K, W>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
fn zinterstore_max_weights<'a, D, K, W>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
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.
Redis DocsSource§fn zlexcount<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
fn zlexcount<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
Source§fn bzpopmax<'a, K>(
&'a mut self,
key: K,
timeout: f64,
) -> Pin<Box<dyn Future<Output = Result<Option<(String, String, f64)>, RedisError>> + Send + 'a>>
fn bzpopmax<'a, K>( &'a mut self, key: K, timeout: f64, ) -> Pin<Box<dyn Future<Output = Result<Option<(String, String, f64)>, RedisError>> + Send + 'a>>
Source§fn zpopmax<'a, K>(
&'a mut self,
key: K,
count: isize,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>
fn zpopmax<'a, K>( &'a mut self, key: K, count: isize, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>
Source§fn bzpopmin<'a, K>(
&'a mut self,
key: K,
timeout: f64,
) -> Pin<Box<dyn Future<Output = Result<Option<(String, String, f64)>, RedisError>> + Send + 'a>>
fn bzpopmin<'a, K>( &'a mut self, key: K, timeout: f64, ) -> Pin<Box<dyn Future<Output = Result<Option<(String, String, f64)>, RedisError>> + Send + 'a>>
Source§fn zpopmin<'a, K>(
&'a mut self,
key: K,
count: isize,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>
fn zpopmin<'a, K>( &'a mut self, key: K, count: isize, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>
Source§fn bzmpop_max<'a, K>(
&'a mut self,
timeout: f64,
keys: K,
count: isize,
) -> Pin<Box<dyn Future<Output = Result<Option<(String, Vec<(String, f64)>)>, RedisError>> + Send + 'a>>
fn bzmpop_max<'a, K>( &'a mut self, timeout: f64, keys: K, count: isize, ) -> Pin<Box<dyn Future<Output = Result<Option<(String, Vec<(String, f64)>)>, RedisError>> + Send + 'a>>
Source§fn zmpop_max<'a, K>(
&'a mut self,
keys: K,
count: isize,
) -> Pin<Box<dyn Future<Output = Result<Option<(String, Vec<(String, f64)>)>, RedisError>> + Send + 'a>>
fn zmpop_max<'a, K>( &'a mut self, keys: K, count: isize, ) -> Pin<Box<dyn Future<Output = Result<Option<(String, Vec<(String, f64)>)>, RedisError>> + Send + 'a>>
Source§fn bzmpop_min<'a, K>(
&'a mut self,
timeout: f64,
keys: K,
count: isize,
) -> Pin<Box<dyn Future<Output = Result<Option<(String, Vec<(String, f64)>)>, RedisError>> + Send + 'a>>
fn bzmpop_min<'a, K>( &'a mut self, timeout: f64, keys: K, count: isize, ) -> Pin<Box<dyn Future<Output = Result<Option<(String, Vec<(String, f64)>)>, RedisError>> + Send + 'a>>
Source§fn zmpop_min<'a, K>(
&'a mut self,
keys: K,
count: isize,
) -> Pin<Box<dyn Future<Output = Result<Option<(String, Vec<(String, f64)>)>, RedisError>> + Send + 'a>>
fn zmpop_min<'a, K>( &'a mut self, keys: K, count: isize, ) -> Pin<Box<dyn Future<Output = Result<Option<(String, Vec<(String, f64)>)>, RedisError>> + Send + 'a>>
Source§fn zrandmember<'a, RV, K>(
&'a mut self,
key: K,
count: Option<isize>,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn zrandmember<'a, RV, K>( &'a mut self, key: K, count: Option<isize>, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
count == None)
Redis DocsSource§fn zrandmember_withscores<'a, RV, K>(
&'a mut self,
key: K,
count: isize,
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
fn zrandmember_withscores<'a, RV, K>( &'a mut self, key: K, count: isize, ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + Send + 'a>>
Source§fn zrange<'a, K>(
&'a mut self,
key: K,
start: isize,
stop: isize,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>
fn zrange<'a, K>( &'a mut self, key: K, start: isize, stop: isize, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>
Source§fn zrange_withscores<'a, K>(
&'a mut self,
key: K,
start: isize,
stop: isize,
) -> Pin<Box<dyn Future<Output = Result<Vec<(String, f64)>, RedisError>> + Send + 'a>>
fn zrange_withscores<'a, K>( &'a mut self, key: K, start: isize, stop: isize, ) -> Pin<Box<dyn Future<Output = Result<Vec<(String, f64)>, RedisError>> + Send + 'a>>
Source§fn zrangebylex<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
fn zrangebylex<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zrangebylex_limit<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
fn zrangebylex_limit<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zrevrangebylex<'a, K, MM, M>(
&'a mut self,
key: K,
max: MM,
min: M,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
fn zrevrangebylex<'a, K, MM, M>(
&'a mut self,
key: K,
max: MM,
min: M,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zrevrangebylex_limit<'a, K, MM, M>(
&'a mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
fn zrevrangebylex_limit<'a, K, MM, M>(
&'a mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zrangebyscore<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
fn zrangebyscore<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zrangebyscore_withscores<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
) -> Pin<Box<dyn Future<Output = Result<Vec<(String, usize)>, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
fn zrangebyscore_withscores<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
) -> Pin<Box<dyn Future<Output = Result<Vec<(String, usize)>, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zrangebyscore_limit<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
fn zrangebyscore_limit<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zrangebyscore_limit_withscores<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize,
) -> Pin<Box<dyn Future<Output = Result<Vec<(String, usize)>, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
fn zrangebyscore_limit_withscores<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize,
) -> Pin<Box<dyn Future<Output = Result<Vec<(String, usize)>, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zrank<'a, K, M>(
&'a mut self,
key: K,
member: M,
) -> Pin<Box<dyn Future<Output = Result<Option<usize>, RedisError>> + Send + 'a>>
fn zrank<'a, K, M>( &'a mut self, key: K, member: M, ) -> Pin<Box<dyn Future<Output = Result<Option<usize>, RedisError>> + Send + 'a>>
Source§fn zrem<'a, K, M>(
&'a mut self,
key: K,
members: M,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn zrem<'a, K, M>( &'a mut self, key: K, members: M, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Source§fn zrembylex<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
fn zrembylex<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zremrangebyrank<'a, K>(
&'a mut self,
key: K,
start: isize,
stop: isize,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn zremrangebyrank<'a, K>( &'a mut self, key: K, start: isize, stop: isize, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Source§fn zrembyscore<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
fn zrembyscore<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zrevrange<'a, K>(
&'a mut self,
key: K,
start: isize,
stop: isize,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>
fn zrevrange<'a, K>( &'a mut self, key: K, start: isize, stop: isize, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>
Source§fn zrevrange_withscores<'a, K>(
&'a mut self,
key: K,
start: isize,
stop: isize,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>
fn zrevrange_withscores<'a, K>( &'a mut self, key: K, start: isize, stop: isize, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>
Source§fn zrevrangebyscore<'a, K, MM, M>(
&'a mut self,
key: K,
max: MM,
min: M,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
fn zrevrangebyscore<'a, K, MM, M>(
&'a mut self,
key: K,
max: MM,
min: M,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zrevrangebyscore_withscores<'a, K, MM, M>(
&'a mut self,
key: K,
max: MM,
min: M,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
fn zrevrangebyscore_withscores<'a, K, MM, M>(
&'a mut self,
key: K,
max: MM,
min: M,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zrevrangebyscore_limit<'a, K, MM, M>(
&'a mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
fn zrevrangebyscore_limit<'a, K, MM, M>(
&'a mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zrevrangebyscore_limit_withscores<'a, K, MM, M>(
&'a mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
fn zrevrangebyscore_limit_withscores<'a, K, MM, M>(
&'a mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, RedisError>> + Send + 'a>>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zrevrank<'a, K, M>(
&'a mut self,
key: K,
member: M,
) -> Pin<Box<dyn Future<Output = Result<Option<usize>, RedisError>> + Send + 'a>>
fn zrevrank<'a, K, M>( &'a mut self, key: K, member: M, ) -> Pin<Box<dyn Future<Output = Result<Option<usize>, RedisError>> + Send + 'a>>
Source§fn zscore<'a, K, M>(
&'a mut self,
key: K,
member: M,
) -> Pin<Box<dyn Future<Output = Result<Option<f64>, RedisError>> + Send + 'a>>
fn zscore<'a, K, M>( &'a mut self, key: K, member: M, ) -> Pin<Box<dyn Future<Output = Result<Option<f64>, RedisError>> + Send + 'a>>
Source§fn zscore_multiple<'a, K, M>(
&'a mut self,
key: K,
members: &'a [M],
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<f64>>, RedisError>> + Send + 'a>>
fn zscore_multiple<'a, K, M>( &'a mut self, key: K, members: &'a [M], ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<f64>>, RedisError>> + Send + 'a>>
Source§fn zunionstore<'a, D, K>(
&'a mut self,
dstkey: D,
keys: K,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn zunionstore<'a, D, K>( &'a mut self, dstkey: D, keys: K, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Source§fn zunionstore_min<'a, D, K>(
&'a mut self,
dstkey: D,
keys: K,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn zunionstore_min<'a, D, K>( &'a mut self, dstkey: D, keys: K, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Source§fn zunionstore_max<'a, D, K>(
&'a mut self,
dstkey: D,
keys: K,
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
fn zunionstore_max<'a, D, K>( &'a mut self, dstkey: D, keys: K, ) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>
Source§fn zunionstore_weights<'a, D, K, W>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
fn zunionstore_weights<'a, D, K, W>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
Commands::zunionstore, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.
Redis DocsSource§fn zunionstore_min_weights<'a, D, K, W>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
fn zunionstore_min_weights<'a, D, K, W>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
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.
Redis DocsSource§fn zunionstore_max_weights<'a, D, K, W>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
fn zunionstore_max_weights<'a, D, K, W>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Pin<Box<dyn Future<Output = Result<usize, RedisError>> + Send + 'a>>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
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.
Redis Docs