Trait AsyncCommands

pub trait AsyncCommands:
    ConnectionLike
    + Send
    + Sized {
    // Provided methods
    fn get<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn mget<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn keys<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn set<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        value: V,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn set_options<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        value: V,
        options: SetOptions,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn set_multiple<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        items: &'a [(K, V)],
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn mset<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        items: &'a [(K, V)],
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn set_ex<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        value: V,
        seconds: u64,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn pset_ex<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        value: V,
        milliseconds: u64,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn set_nx<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        value: V,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn mset_nx<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        items: &'a [(K, V)],
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn getset<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        value: V,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn getrange<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        from: isize,
        to: isize,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn setrange<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        offset: isize,
        value: V,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn del<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn exists<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn key_type<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn expire<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        seconds: i64,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn expire_at<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        ts: i64,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn pexpire<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        ms: i64,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn pexpire_at<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        ts: i64,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn expire_time<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn pexpire_time<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn persist<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn ttl<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn pttl<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn get_ex<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        expire_at: Expiry,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn get_del<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn rename<'a, K: ToRedisArgs + Send + Sync + 'a, N: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        new_key: N,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn rename_nx<'a, K: ToRedisArgs + Send + Sync + 'a, N: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        new_key: N,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn unlink<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn append<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        value: V,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn incr<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        delta: V,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn decr<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        delta: V,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn setbit<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        offset: usize,
        value: bool,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn getbit<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        offset: usize,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn bitcount<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn bitcount_range<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        start: usize,
        end: usize,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn bit_and<'a, D: ToRedisArgs + Send + Sync + 'a, S: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        dstkey: D,
        srckeys: S,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn bit_or<'a, D: ToRedisArgs + Send + Sync + 'a, S: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        dstkey: D,
        srckeys: S,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn bit_xor<'a, D: ToRedisArgs + Send + Sync + 'a, S: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        dstkey: D,
        srckeys: S,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn bit_not<'a, D: ToRedisArgs + Send + Sync + 'a, S: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        dstkey: D,
        srckey: S,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn strlen<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn hget<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        field: F,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn hdel<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        field: F,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn hset<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        field: F,
        value: V,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn hset_nx<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        field: F,
        value: V,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn hset_multiple<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        items: &'a [(F, V)],
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn hincr<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, D: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        field: F,
        delta: D,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn hexists<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        field: F,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn httl<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        fields: F,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn hpttl<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        fields: F,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn hexpire<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        seconds: i64,
        opt: ExpireOption,
        fields: F,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn hexpire_at<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        ts: i64,
        opt: ExpireOption,
        fields: F,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn hexpire_time<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        fields: F,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn hpersist<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        fields: F,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn hpexpire<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        milliseconds: i64,
        opt: ExpireOption,
        fields: F,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn hpexpire_at<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        ts: i64,
        opt: ExpireOption,
        fields: F,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn hpexpire_time<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        fields: F,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn hkeys<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn hvals<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn hgetall<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn hlen<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn blmove<'a, S: ToRedisArgs + Send + Sync + 'a, D: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        srckey: S,
        dstkey: D,
        src_dir: Direction,
        dst_dir: Direction,
        timeout: f64,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn blmpop<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        timeout: f64,
        numkeys: usize,
        key: K,
        dir: Direction,
        count: usize,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn blpop<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        timeout: f64,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn brpop<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        timeout: f64,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn brpoplpush<'a, S: ToRedisArgs + Send + Sync + 'a, D: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        srckey: S,
        dstkey: D,
        timeout: f64,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn lindex<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        index: isize,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn linsert_before<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        pivot: P,
        value: V,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn linsert_after<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        pivot: P,
        value: V,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn llen<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn lmove<'a, S: ToRedisArgs + Send + Sync + 'a, D: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        srckey: S,
        dstkey: D,
        src_dir: Direction,
        dst_dir: Direction,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn lmpop<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        numkeys: usize,
        key: K,
        dir: Direction,
        count: usize,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn lpop<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        count: Option<NonZeroUsize>,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn lpos<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        value: V,
        options: LposOptions,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn lpush<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        value: V,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn lpush_exists<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        value: V,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn lrange<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        start: isize,
        stop: isize,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn lrem<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        count: isize,
        value: V,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn ltrim<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        start: isize,
        stop: isize,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn lset<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        index: isize,
        value: V,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn ping<'a, RV>(&'a mut self) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn ping_message<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        message: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn rpop<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        count: Option<NonZeroUsize>,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn rpoplpush<'a, K: ToRedisArgs + Send + Sync + 'a, D: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        dstkey: D,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn rpush<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        value: V,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn rpush_exists<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        value: V,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn sadd<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        member: M,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn scard<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn sdiff<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        keys: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn sdiffstore<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        dstkey: D,
        keys: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn sinter<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        keys: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn sinterstore<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        dstkey: D,
        keys: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn sismember<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        member: M,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn smismember<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        members: M,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn smembers<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn smove<'a, S: ToRedisArgs + Send + Sync + 'a, D: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        srckey: S,
        dstkey: D,
        member: M,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn spop<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn srandmember<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn srandmember_multiple<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        count: usize,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn srem<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        member: M,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn sunion<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        keys: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn sunionstore<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        dstkey: D,
        keys: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zadd<'a, K: ToRedisArgs + Send + Sync + 'a, S: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        member: M,
        score: S,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zadd_multiple<'a, K: ToRedisArgs + Send + Sync + 'a, S: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        items: &'a [(S, M)],
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zcard<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zcount<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        min: M,
        max: MM,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zincr<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, D: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        member: M,
        delta: D,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zinterstore<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        dstkey: D,
        keys: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zinterstore_min<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        dstkey: D,
        keys: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zinterstore_max<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        dstkey: D,
        keys: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zinterstore_weights<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, W: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        dstkey: D,
        keys: &'a [(K, W)],
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zinterstore_min_weights<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, W: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        dstkey: D,
        keys: &'a [(K, W)],
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zinterstore_max_weights<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, W: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        dstkey: D,
        keys: &'a [(K, W)],
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zlexcount<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        min: M,
        max: MM,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn bzpopmax<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        timeout: f64,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zpopmax<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        count: isize,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn bzpopmin<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        timeout: f64,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zpopmin<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        count: isize,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn bzmpop_max<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        timeout: f64,
        keys: K,
        count: isize,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zmpop_max<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        keys: K,
        count: isize,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn bzmpop_min<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        timeout: f64,
        keys: K,
        count: isize,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zmpop_min<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        keys: K,
        count: isize,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zrandmember<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        count: Option<isize>,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zrandmember_withscores<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        count: isize,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zrange<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        start: isize,
        stop: isize,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zrange_withscores<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        start: isize,
        stop: isize,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zrangebylex<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        min: M,
        max: MM,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zrangebylex_limit<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        min: M,
        max: MM,
        offset: isize,
        count: isize,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zrevrangebylex<'a, K: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        max: MM,
        min: M,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zrevrangebylex_limit<'a, K: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        max: MM,
        min: M,
        offset: isize,
        count: isize,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zrangebyscore<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        min: M,
        max: MM,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zrangebyscore_withscores<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        min: M,
        max: MM,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zrangebyscore_limit<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        min: M,
        max: MM,
        offset: isize,
        count: isize,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zrangebyscore_limit_withscores<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        min: M,
        max: MM,
        offset: isize,
        count: isize,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zrank<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        member: M,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zrem<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        members: M,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zrembylex<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        min: M,
        max: MM,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zremrangebyrank<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        start: isize,
        stop: isize,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zrembyscore<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        min: M,
        max: MM,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zrevrange<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        start: isize,
        stop: isize,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zrevrange_withscores<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        start: isize,
        stop: isize,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zrevrangebyscore<'a, K: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        max: MM,
        min: M,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zrevrangebyscore_withscores<'a, K: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        max: MM,
        min: M,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zrevrangebyscore_limit<'a, K: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        max: MM,
        min: M,
        offset: isize,
        count: isize,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zrevrangebyscore_limit_withscores<'a, K: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        max: MM,
        min: M,
        offset: isize,
        count: isize,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zrevrank<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        member: M,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zscore<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        member: M,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zscore_multiple<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        members: &'a [M],
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zunionstore<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        dstkey: D,
        keys: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zunionstore_min<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        dstkey: D,
        keys: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zunionstore_max<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        dstkey: D,
        keys: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zunionstore_weights<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, W: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        dstkey: D,
        keys: &'a [(K, W)],
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zunionstore_min_weights<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, W: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        dstkey: D,
        keys: &'a [(K, W)],
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn zunionstore_max_weights<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, W: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        dstkey: D,
        keys: &'a [(K, W)],
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn pfadd<'a, K: ToRedisArgs + Send + Sync + 'a, E: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
        element: E,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn pfcount<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn pfmerge<'a, D: ToRedisArgs + Send + Sync + 'a, S: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        dstkey: D,
        srckeys: S,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn publish<'a, K: ToRedisArgs + Send + Sync + 'a, E: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        channel: K,
        message: E,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn spublish<'a, K: ToRedisArgs + Send + Sync + 'a, E: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        channel: K,
        message: E,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn object_encoding<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn object_idletime<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn object_freq<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn object_refcount<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn client_getname<'a, RV>(&'a mut self) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn client_id<'a, RV>(&'a mut self) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn client_setname<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        connection_name: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn xrevrange_all<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(
        &'a mut self,
        key: K,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn flushall<'a, RV>(&'a mut self) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn flushall_options<'a, RV>(
        &'a mut self,
        options: &'a FlushAllOptions,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn flushdb<'a, RV>(&'a mut self) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn flushdb_options<'a, RV>(
        &'a mut self,
        options: &'a FlushDbOptions,
    ) -> RedisFuture<'a, RV>
       where RV: FromRedisValue { ... }
    fn scan<RV: FromRedisValue>(&mut self) -> RedisFuture<'_, AsyncIter<'_, RV>> { ... }
    fn scan_options<RV: FromRedisValue>(
        &mut self,
        opts: ScanOptions,
    ) -> RedisFuture<'_, AsyncIter<'_, RV>> { ... }
    fn scan_match<P: ToRedisArgs, RV: FromRedisValue>(
        &mut self,
        pattern: P,
    ) -> RedisFuture<'_, AsyncIter<'_, RV>> { ... }
    fn hscan<K: ToRedisArgs, RV: FromRedisValue>(
        &mut self,
        key: K,
    ) -> RedisFuture<'_, AsyncIter<'_, RV>> { ... }
    fn hscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
        &mut self,
        key: K,
        pattern: P,
    ) -> RedisFuture<'_, AsyncIter<'_, RV>> { ... }
    fn sscan<K: ToRedisArgs, RV: FromRedisValue>(
        &mut self,
        key: K,
    ) -> RedisFuture<'_, AsyncIter<'_, RV>> { ... }
    fn sscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
        &mut self,
        key: K,
        pattern: P,
    ) -> RedisFuture<'_, AsyncIter<'_, RV>> { ... }
    fn zscan<K: ToRedisArgs, RV: FromRedisValue>(
        &mut self,
        key: K,
    ) -> RedisFuture<'_, AsyncIter<'_, RV>> { ... }
    fn zscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
        &mut self,
        key: K,
        pattern: P,
    ) -> RedisFuture<'_, AsyncIter<'_, RV>> { ... }
}

Implements common redis commands over asynchronous connections.

This allows you to send commands straight to a connection or client.

This allows you to use nicer syntax for some common operations. For instance this code:

use redis::AsyncCommands;
let client = redis::Client::open("redis://127.0.0.1/")?;
let mut con = client.get_multiplexed_async_connection().await?;
redis::cmd("SET").arg("my_key").arg(42i32).exec_async(&mut con).await?;
assert_eq!(redis::cmd("GET").arg("my_key").query_async(&mut con).await, Ok(42i32));

Will become this:

use redis::AsyncCommands;
use redis::Commands;
let client = redis::Client::open("redis://127.0.0.1/")?;
let mut con = client.get_multiplexed_async_connection().await?;
let _: () = con.set("my_key", 42i32).await?;
assert_eq!(con.get("my_key").await, Ok(42i32));

Provided Methods

fn get<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Get the value of a key. If key is a vec this becomes an MGET.

fn mget<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Get values of keys

fn keys<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Gets all keys matching pattern

fn set<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, value: V, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Set the string value of a key.

fn set_options<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, value: V, options: SetOptions, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Set the string value of a key with options.

fn set_multiple<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, items: &'a [(K, V)], ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

👎Deprecated since 0.22.4: Renamed to mset() to reflect Redis name

Sets multiple keys to their values.

fn mset<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, items: &'a [(K, V)], ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Sets multiple keys to their values.

fn set_ex<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, value: V, seconds: u64, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Set the value and expiration of a key.

fn pset_ex<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, value: V, milliseconds: u64, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Set the value and expiration in milliseconds of a key.

fn set_nx<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, value: V, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Set the value of a key, only if the key does not exist

fn mset_nx<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, items: &'a [(K, V)], ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Sets multiple keys to their values failing if at least one already exists.

fn getset<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, value: V, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Set the string value of a key and return its old value.

fn getrange<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, from: isize, to: isize, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Get a range of bytes/substring from the value of a key. Negative values provide an offset from the end of the value.

fn setrange<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, offset: isize, value: V, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Overwrite the part of the value stored in key at the specified offset.

fn del<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Delete one or more keys.

fn exists<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Determine if a key exists.

fn key_type<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Determine the type of a key.

fn expire<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, seconds: i64, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Set a key’s time to live in seconds.

fn expire_at<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ts: i64, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Set the expiration for a key as a UNIX timestamp.

fn pexpire<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ms: i64, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Set a key’s time to live in milliseconds.

fn pexpire_at<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ts: i64, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Set the expiration for a key as a UNIX timestamp in milliseconds.

fn expire_time<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Get the absolute Unix expiration timestamp in seconds.

fn pexpire_time<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Get the absolute Unix expiration timestamp in milliseconds.

fn persist<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Remove the expiration from a key.

fn ttl<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Get the time to live for a key in seconds.

fn pttl<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Get the time to live for a key in milliseconds.

fn get_ex<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, expire_at: Expiry, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Get the value of a key and set expiration

fn get_del<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Get the value of a key and delete it

fn rename<'a, K: ToRedisArgs + Send + Sync + 'a, N: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, new_key: N, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Rename a key.

fn rename_nx<'a, K: ToRedisArgs + Send + Sync + 'a, N: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, new_key: N, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Rename a key, only if the new key does not exist.

fn unlink<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Unlink one or more keys.

fn append<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, value: V, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Append a value to a key.

fn incr<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, delta: V, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Increment the numeric value of a key by the given amount. This issues a INCRBY or INCRBYFLOAT depending on the type.

fn decr<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, delta: V, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Decrement the numeric value of a key by the given amount.

fn setbit<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, offset: usize, value: bool, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Sets or clears the bit at offset in the string value stored at key.

fn getbit<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, offset: usize, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Returns the bit value at offset in the string value stored at key.

fn bitcount<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Count set bits in a string.

fn bitcount_range<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, start: usize, end: usize, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Count set bits in a string in a range.

fn bit_and<'a, D: ToRedisArgs + Send + Sync + 'a, S: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, srckeys: S, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Perform a bitwise AND between multiple keys (containing string values) and store the result in the destination key.

fn bit_or<'a, D: ToRedisArgs + Send + Sync + 'a, S: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, srckeys: S, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Perform a bitwise OR between multiple keys (containing string values) and store the result in the destination key.

fn bit_xor<'a, D: ToRedisArgs + Send + Sync + 'a, S: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, srckeys: S, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Perform a bitwise XOR between multiple keys (containing string values) and store the result in the destination key.

fn bit_not<'a, D: ToRedisArgs + Send + Sync + 'a, S: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, srckey: S, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Perform a bitwise NOT of the key (containing string values) and store the result in the destination key.

fn strlen<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Get the length of the value stored in a key.

fn hget<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, field: F, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Gets a single (or multiple) fields from a hash.

fn hdel<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, field: F, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Deletes a single (or multiple) fields from a hash.

fn hset<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, field: F, value: V, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Sets a single field in a hash.

fn hset_nx<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, field: F, value: V, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Sets a single field in a hash if it does not exist.

fn hset_multiple<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, items: &'a [(F, V)], ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Sets multiple fields in a hash.

fn hincr<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, D: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, field: F, delta: D, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Increments a value.

fn hexists<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, field: F, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Checks if a field in a hash exists.

fn httl<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, fields: F, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Get one or more fields’ TTL in seconds.

fn hpttl<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, fields: F, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Get one or more fields’ TTL in milliseconds.

fn hexpire<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, seconds: i64, opt: ExpireOption, fields: F, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Set one or more fields’ time to live in seconds.

fn hexpire_at<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ts: i64, opt: ExpireOption, fields: F, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Set the expiration for one or more fields as a UNIX timestamp in milliseconds.

fn hexpire_time<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, fields: F, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Returns the absolute Unix expiration timestamp in seconds.

fn hpersist<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, fields: F, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Remove the expiration from a key.

fn hpexpire<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, milliseconds: i64, opt: ExpireOption, fields: F, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Set one or more fields’ time to live in milliseconds.

fn hpexpire_at<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ts: i64, opt: ExpireOption, fields: F, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Set the expiration for one or more fields as a UNIX timestamp in milliseconds.

fn hpexpire_time<'a, K: ToRedisArgs + Send + Sync + 'a, F: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, fields: F, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Returns the absolute Unix expiration timestamp in seconds.

fn hkeys<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Gets all the keys in a hash.

fn hvals<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Gets all the values in a hash.

fn hgetall<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Gets all the fields and values in a hash.

fn hlen<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Gets the length of a hash.

fn blmove<'a, S: ToRedisArgs + Send + Sync + 'a, D: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, srckey: S, dstkey: D, src_dir: Direction, dst_dir: Direction, timeout: f64, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Pop an element from a list, push it to another list and return it; or block until one is available

fn blmpop<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, timeout: f64, numkeys: usize, key: K, dir: Direction, count: usize, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Pops count elements from the first non-empty list key from the list of provided key names; or blocks until one is available.

fn blpop<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, timeout: f64, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Remove and get the first element in a list, or block until one is available.

fn brpop<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, timeout: f64, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Remove and get the last element in a list, or block until one is available.

fn brpoplpush<'a, S: ToRedisArgs + Send + Sync + 'a, D: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, srckey: S, dstkey: D, timeout: f64, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Pop a value from a list, push it to another list and return it; or block until one is available.

fn lindex<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, index: isize, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Get an element from a list by its index.

fn linsert_before<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, pivot: P, value: V, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Insert an element before another element in a list.

fn linsert_after<'a, K: ToRedisArgs + Send + Sync + 'a, P: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, pivot: P, value: V, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Insert an element after another element in a list.

fn llen<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Returns the length of the list stored at key.

fn lmove<'a, S: ToRedisArgs + Send + Sync + 'a, D: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, srckey: S, dstkey: D, src_dir: Direction, dst_dir: Direction, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Pop an element a list, push it to another list and return it

fn lmpop<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, numkeys: usize, key: K, dir: Direction, count: usize, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Pops count elements from the first non-empty list key from the list of provided key names.

fn lpop<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, count: Option<NonZeroUsize>, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Removes and returns the up to count first elements of the list stored at key.

If count is not specified, then defaults to first element.

fn lpos<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, value: V, options: LposOptions, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Returns the index of the first matching value of the list stored at key.

fn lpush<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, value: V, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Insert all the specified values at the head of the list stored at key.

fn lpush_exists<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, value: V, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Inserts a value at the head of the list stored at key, only if key already exists and holds a list.

fn lrange<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, start: isize, stop: isize, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Returns the specified elements of the list stored at key.

fn lrem<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, count: isize, value: V, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Removes the first count occurrences of elements equal to value from the list stored at key.

fn ltrim<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, start: isize, stop: isize, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Trim an existing list so that it will contain only the specified range of elements specified.

fn lset<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, index: isize, value: V, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Sets the list element at index to value

fn ping<'a, RV>(&'a mut self) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Sends a ping to the server

fn ping_message<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, message: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Sends a ping with a message to the server

fn rpop<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, count: Option<NonZeroUsize>, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Removes and returns the up to count last elements of the list stored at key

If count is not specified, then defaults to last element.

fn rpoplpush<'a, K: ToRedisArgs + Send + Sync + 'a, D: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, dstkey: D, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Pop a value from a list, push it to another list and return it.

fn rpush<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, value: V, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Insert all the specified values at the tail of the list stored at key.

fn rpush_exists<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, value: V, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Inserts value at the tail of the list stored at key, only if key already exists and holds a list.

fn sadd<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, member: M, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Add one or more members to a set.

fn scard<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Get the number of members in a set.

fn sdiff<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, keys: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Subtract multiple sets.

fn sdiffstore<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, keys: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Subtract multiple sets and store the resulting set in a key.

fn sinter<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, keys: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Intersect multiple sets.

fn sinterstore<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, keys: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Intersect multiple sets and store the resulting set in a key.

fn sismember<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, member: M, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Determine if a given value is a member of a set.

fn smismember<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, members: M, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Determine if given values are members of a set.

fn smembers<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Get all the members in a set.

fn smove<'a, S: ToRedisArgs + Send + Sync + 'a, D: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, srckey: S, dstkey: D, member: M, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Move a member from one set to another.

fn spop<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Remove and return a random member from a set.

fn srandmember<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Get one random member from a set.

fn srandmember_multiple<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, count: usize, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Get multiple random members from a set.

fn srem<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, member: M, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Remove one or more members from a set.

fn sunion<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, keys: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Add multiple sets.

fn sunionstore<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, keys: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Add multiple sets and store the resulting set in a key.

fn zadd<'a, K: ToRedisArgs + Send + Sync + 'a, S: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, member: M, score: S, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Add one member to a sorted set, or update its score if it already exists.

fn zadd_multiple<'a, K: ToRedisArgs + Send + Sync + 'a, S: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, items: &'a [(S, M)], ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Add multiple members to a sorted set, or update its score if it already exists.

fn zcard<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Get the number of members in a sorted set.

fn zcount<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, min: M, max: MM, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Count the members in a sorted set with scores within the given values.

fn zincr<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, D: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, member: M, delta: D, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Increments the member in a sorted set at key by delta. If the member does not exist, it is added with delta as its score.

fn zinterstore<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, keys: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Intersect multiple sorted sets and store the resulting sorted set in a new key using SUM as aggregation function.

fn zinterstore_min<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, keys: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Intersect multiple sorted sets and store the resulting sorted set in a new key using MIN as aggregation function.

fn zinterstore_max<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, keys: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Intersect multiple sorted sets and store the resulting sorted set in a new key using MAX as aggregation function.

fn zinterstore_weights<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, W: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, keys: &'a [(K, W)], ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Commands::zinterstore, but with the ability to specify a multiplication factor for each sorted set by pairing one with each key in a tuple.

fn zinterstore_min_weights<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, W: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, keys: &'a [(K, W)], ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Commands::zinterstore_min, but with the ability to specify a multiplication factor for each sorted set by pairing one with each key in a tuple.

fn zinterstore_max_weights<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, W: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, keys: &'a [(K, W)], ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Commands::zinterstore_max, but with the ability to specify a multiplication factor for each sorted set by pairing one with each key in a tuple.

fn zlexcount<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, min: M, max: MM, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Count the number of members in a sorted set between a given lexicographical range.

fn bzpopmax<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, timeout: f64, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Removes and returns the member with the highest score in a sorted set. Blocks until a member is available otherwise.

fn zpopmax<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, count: isize, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Removes and returns up to count members with the highest scores in a sorted set

fn bzpopmin<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, timeout: f64, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Removes and returns the member with the lowest score in a sorted set. Blocks until a member is available otherwise.

fn zpopmin<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, count: isize, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Removes and returns up to count members with the lowest scores in a sorted set

fn bzmpop_max<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, timeout: f64, keys: K, count: isize, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Removes and returns up to count members with the highest scores, from the first non-empty sorted set in the provided list of key names. Blocks until a member is available otherwise.

fn zmpop_max<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, keys: K, count: isize, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Removes and returns up to count members with the highest scores, from the first non-empty sorted set in the provided list of key names.

fn bzmpop_min<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, timeout: f64, keys: K, count: isize, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Removes and returns up to count members with the lowest scores, from the first non-empty sorted set in the provided list of key names. Blocks until a member is available otherwise.

fn zmpop_min<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, keys: K, count: isize, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Removes and returns up to count members with the lowest scores, from the first non-empty sorted set in the provided list of key names.

fn zrandmember<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, count: Option<isize>, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Return up to count random members in a sorted set (or 1 if count == None)

fn zrandmember_withscores<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, count: isize, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Return up to count random members in a sorted set with scores

fn zrange<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, start: isize, stop: isize, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Return a range of members in a sorted set, by index

fn zrange_withscores<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, start: isize, stop: isize, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Return a range of members in a sorted set, by index with scores.

fn zrangebylex<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, min: M, max: MM, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Return a range of members in a sorted set, by lexicographical range.

fn zrangebylex_limit<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, min: M, max: MM, offset: isize, count: isize, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Return a range of members in a sorted set, by lexicographical range with offset and limit.

fn zrevrangebylex<'a, K: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, max: MM, min: M, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Return a range of members in a sorted set, by lexicographical range.

fn zrevrangebylex_limit<'a, K: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, max: MM, min: M, offset: isize, count: isize, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Return a range of members in a sorted set, by lexicographical range with offset and limit.

fn zrangebyscore<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, min: M, max: MM, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Return a range of members in a sorted set, by score.

fn zrangebyscore_withscores<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, min: M, max: MM, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Return a range of members in a sorted set, by score with scores.

fn zrangebyscore_limit<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, min: M, max: MM, offset: isize, count: isize, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Return a range of members in a sorted set, by score with limit.

fn zrangebyscore_limit_withscores<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, min: M, max: MM, offset: isize, count: isize, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Return a range of members in a sorted set, by score with limit with scores.

fn zrank<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, member: M, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Determine the index of a member in a sorted set.

fn zrem<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, members: M, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Remove one or more members from a sorted set.

fn zrembylex<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, min: M, max: MM, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Remove all members in a sorted set between the given lexicographical range.

fn zremrangebyrank<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, start: isize, stop: isize, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Remove all members in a sorted set within the given indexes.

fn zrembyscore<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, min: M, max: MM, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Remove all members in a sorted set within the given scores.

fn zrevrange<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, start: isize, stop: isize, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Return a range of members in a sorted set, by index, with scores ordered from high to low.

fn zrevrange_withscores<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, start: isize, stop: isize, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Return a range of members in a sorted set, by index, with scores ordered from high to low.

fn zrevrangebyscore<'a, K: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, max: MM, min: M, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Return a range of members in a sorted set, by score.

fn zrevrangebyscore_withscores<'a, K: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, max: MM, min: M, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Return a range of members in a sorted set, by score with scores.

fn zrevrangebyscore_limit<'a, K: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, max: MM, min: M, offset: isize, count: isize, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Return a range of members in a sorted set, by score with limit.

fn zrevrangebyscore_limit_withscores<'a, K: ToRedisArgs + Send + Sync + 'a, MM: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, max: MM, min: M, offset: isize, count: isize, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Return a range of members in a sorted set, by score with limit with scores.

fn zrevrank<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, member: M, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Determine the index of a member in a sorted set, with scores ordered from high to low.

fn zscore<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, member: M, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Get the score associated with the given member in a sorted set.

fn zscore_multiple<'a, K: ToRedisArgs + Send + Sync + 'a, M: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, members: &'a [M], ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Get the scores associated with multiple members in a sorted set.

fn zunionstore<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, keys: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Unions multiple sorted sets and store the resulting sorted set in a new key using SUM as aggregation function.

fn zunionstore_min<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, keys: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Unions multiple sorted sets and store the resulting sorted set in a new key using MIN as aggregation function.

fn zunionstore_max<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, keys: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Unions multiple sorted sets and store the resulting sorted set in a new key using MAX as aggregation function.

fn zunionstore_weights<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, W: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, keys: &'a [(K, W)], ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Commands::zunionstore, but with the ability to specify a multiplication factor for each sorted set by pairing one with each key in a tuple.

fn zunionstore_min_weights<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, W: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, keys: &'a [(K, W)], ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Commands::zunionstore_min, but with the ability to specify a multiplication factor for each sorted set by pairing one with each key in a tuple.

fn zunionstore_max_weights<'a, D: ToRedisArgs + Send + Sync + 'a, K: ToRedisArgs + Send + Sync + 'a, W: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, keys: &'a [(K, W)], ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Commands::zunionstore_max, but with the ability to specify a multiplication factor for each sorted set by pairing one with each key in a tuple.

fn pfadd<'a, K: ToRedisArgs + Send + Sync + 'a, E: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, element: E, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Adds the specified elements to the specified HyperLogLog.

fn pfcount<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).

fn pfmerge<'a, D: ToRedisArgs + Send + Sync + 'a, S: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, dstkey: D, srckeys: S, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Merge N different HyperLogLogs into a single one.

fn publish<'a, K: ToRedisArgs + Send + Sync + 'a, E: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, channel: K, message: E, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Posts a message to the given channel.

fn spublish<'a, K: ToRedisArgs + Send + Sync + 'a, E: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, channel: K, message: E, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Posts a message to the given sharded channel.

fn object_encoding<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Returns the encoding of a key.

fn object_idletime<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Returns the time in seconds since the last access of a key.

fn object_freq<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Returns the logarithmic access frequency counter of a key.

fn object_refcount<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Returns the reference count of a key.

fn client_getname<'a, RV>(&'a mut self) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Returns the name of the current connection as set by CLIENT SETNAME.

fn client_id<'a, RV>(&'a mut self) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Returns the ID of the current connection.

fn client_setname<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, connection_name: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Command assigns a name to the current connection.

fn xrevrange_all<'a, K: ToRedisArgs + Send + Sync + 'a, RV>( &'a mut self, key: K, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

This is the reverse version of xrange_all. The same rules apply for start and end here.

XREVRANGE key + -

fn flushall<'a, RV>(&'a mut self) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Deletes all the keys of all databases

Whether the flushing happens asynchronously or synchronously depends on the configuration of your Redis server.

To enforce a flush mode, use Commands::flushall_options.

FLUSHALL

fn flushall_options<'a, RV>( &'a mut self, options: &'a FlushAllOptions, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Deletes all the keys of all databases with options

FLUSHALL [ASYNC|SYNC]

fn flushdb<'a, RV>(&'a mut self) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Deletes all the keys of the current database

Whether the flushing happens asynchronously or synchronously depends on the configuration of your Redis server.

To enforce a flush mode, use Commands::flushdb_options.

FLUSHDB

fn flushdb_options<'a, RV>( &'a mut self, options: &'a FlushDbOptions, ) -> RedisFuture<'a, RV>

where RV: FromRedisValue,

Deletes all the keys of the current database with options

FLUSHDB [ASYNC|SYNC]

fn scan<RV: FromRedisValue>(&mut self) -> RedisFuture<'_, AsyncIter<'_, RV>>

Incrementally iterate the keys space.

fn scan_options<RV: FromRedisValue>( &mut self, opts: ScanOptions, ) -> RedisFuture<'_, AsyncIter<'_, RV>>

Incrementally iterate the keys space with options.

fn scan_match<P: ToRedisArgs, RV: FromRedisValue>( &mut self, pattern: P, ) -> RedisFuture<'_, AsyncIter<'_, RV>>

Incrementally iterate set elements for elements matching a pattern.

fn hscan<K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ) -> RedisFuture<'_, AsyncIter<'_, RV>>

Incrementally iterate hash fields and associated values.

fn hscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, pattern: P, ) -> RedisFuture<'_, AsyncIter<'_, RV>>

Incrementally iterate hash fields and associated values for field names matching a pattern.

fn sscan<K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ) -> RedisFuture<'_, AsyncIter<'_, RV>>

Incrementally iterate set elements.

fn sscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, pattern: P, ) -> RedisFuture<'_, AsyncIter<'_, RV>>

Incrementally iterate set elements for elements matching a pattern.

fn zscan<K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ) -> RedisFuture<'_, AsyncIter<'_, RV>>

Incrementally iterate sorted set elements.

fn zscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, pattern: P, ) -> RedisFuture<'_, AsyncIter<'_, RV>>

Incrementally iterate sorted set elements for elements matching a pattern.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<T> AsyncCommands for T

where T: ConnectionLike + Send + Sync + Sized,