Trait redis::PipelineCommands

pub trait PipelineCommands {
    fn get<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self { ... }
    fn keys<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self { ... }
    fn set<'a, K: ToRedisArgs, V: ToRedisArgs>(
        &mut self, 
        key: K, 
        value: V
    ) -> &mut Self { ... }
    fn set_multiple<'a, K: ToRedisArgs, V: ToRedisArgs>(
        &mut self, 
        items: &[(K, V)]
    ) -> &mut Self { ... }
    fn set_ex<'a, K: ToRedisArgs, V: ToRedisArgs>(
        &mut self, 
        key: K, 
        value: V, 
        seconds: usize
    ) -> &mut Self { ... }
    fn set_nx<'a, K: ToRedisArgs, V: ToRedisArgs>(
        &mut self, 
        key: K, 
        value: V
    ) -> &mut Self { ... }
    fn mset_nx<'a, K: ToRedisArgs, V: ToRedisArgs>(
        &mut self, 
        items: &[(K, V)]
    ) -> &mut Self { ... }
    fn getset<'a, K: ToRedisArgs, V: ToRedisArgs>(
        &mut self, 
        key: K, 
        value: V
    ) -> &mut Self { ... }
    fn del<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self { ... }
    fn exists<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self { ... }
    fn expire<'a, K: ToRedisArgs>(
        &mut self, 
        key: K, 
        seconds: usize
    ) -> &mut Self { ... }
    fn expire_at<'a, K: ToRedisArgs>(&mut self, key: K, ts: usize) -> &mut Self { ... }
    fn pexpire<'a, K: ToRedisArgs>(&mut self, key: K, ms: usize) -> &mut Self { ... }
    fn pexpire_at<'a, K: ToRedisArgs>(&mut self, key: K, ts: usize) -> &mut Self { ... }
    fn persist<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self { ... }
    fn ttl<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self { ... }
    fn rename<'a, K: ToRedisArgs>(&mut self, key: K, new_key: K) -> &mut Self { ... }
    fn rename_nx<'a, K: ToRedisArgs>(&mut self, key: K, new_key: K) -> &mut Self { ... }
    fn append<'a, K: ToRedisArgs, V: ToRedisArgs>(
        &mut self, 
        key: K, 
        value: V
    ) -> &mut Self { ... }
    fn incr<'a, K: ToRedisArgs, V: ToRedisArgs>(
        &mut self, 
        key: K, 
        delta: V
    ) -> &mut Self { ... }
    fn setbit<'a, K: ToRedisArgs>(
        &mut self, 
        key: K, 
        offset: usize, 
        value: bool
    ) -> &mut Self { ... }
    fn getbit<'a, K: ToRedisArgs>(&mut self, key: K, offset: usize) -> &mut Self { ... }
    fn bitcount<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self { ... }
    fn bitcount_range<'a, K: ToRedisArgs>(
        &mut self, 
        key: K, 
        start: usize, 
        end: usize
    ) -> &mut Self { ... }
    fn bit_and<'a, K: ToRedisArgs>(
        &mut self, 
        dstkey: K, 
        srckeys: K
    ) -> &mut Self { ... }
    fn bit_or<'a, K: ToRedisArgs>(&mut self, dstkey: K, srckeys: K) -> &mut Self { ... }
    fn bit_xor<'a, K: ToRedisArgs>(
        &mut self, 
        dstkey: K, 
        srckeys: K
    ) -> &mut Self { ... }
    fn bit_not<'a, K: ToRedisArgs>(&mut self, dstkey: K, srckey: K) -> &mut Self { ... }
    fn strlen<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self { ... }
    fn hget<'a, K: ToRedisArgs, F: ToRedisArgs>(
        &mut self, 
        key: K, 
        field: F
    ) -> &mut Self { ... }
    fn hdel<'a, K: ToRedisArgs, F: ToRedisArgs>(
        &mut self, 
        key: K, 
        field: F
    ) -> &mut Self { ... }
    fn hset<'a, K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs>(
        &mut self, 
        key: K, 
        field: F, 
        value: V
    ) -> &mut Self { ... }
    fn hset_nx<'a, K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs>(
        &mut self, 
        key: K, 
        field: F, 
        value: V
    ) -> &mut Self { ... }
    fn hset_multiple<'a, K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs>(
        &mut self, 
        key: K, 
        items: &[(F, V)]
    ) -> &mut Self { ... }
    fn hincr<'a, K: ToRedisArgs, F: ToRedisArgs, D: ToRedisArgs>(
        &mut self, 
        key: K, 
        field: F, 
        delta: D
    ) -> &mut Self { ... }
    fn hexists<'a, K: ToRedisArgs, F: ToRedisArgs>(
        &mut self, 
        key: K, 
        field: F
    ) -> &mut Self { ... }
    fn hkeys<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self { ... }
    fn hvals<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self { ... }
    fn hgetall<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self { ... }
    fn hlen<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self { ... }
    fn blpop<'a, K: ToRedisArgs>(&mut self, key: K, timeout: usize) -> &mut Self { ... }
    fn brpop<'a, K: ToRedisArgs>(&mut self, key: K, timeout: usize) -> &mut Self { ... }
    fn brpoplpush<'a, K: ToRedisArgs>(
        &mut self, 
        srckey: K, 
        dstkey: K, 
        timeout: usize
    ) -> &mut Self { ... }
    fn lindex<'a, K: ToRedisArgs>(&mut self, key: K, index: isize) -> &mut Self { ... }
    fn linsert_before<'a, K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs>(
        &mut self, 
        key: K, 
        pivot: P, 
        value: V
    ) -> &mut Self { ... }
    fn linsert_after<'a, K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs>(
        &mut self, 
        key: K, 
        pivot: P, 
        value: V
    ) -> &mut Self { ... }
    fn llen<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self { ... }
    fn lpop<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self { ... }
    fn lpush<'a, K: ToRedisArgs, V: ToRedisArgs>(
        &mut self, 
        key: K, 
        value: V
    ) -> &mut Self { ... }
    fn lpush_exists<'a, K: ToRedisArgs, V: ToRedisArgs>(
        &mut self, 
        key: K, 
        value: V
    ) -> &mut Self { ... }
    fn lrange<'a, K: ToRedisArgs>(
        &mut self, 
        key: K, 
        start: isize, 
        stop: isize
    ) -> &mut Self { ... }
    fn lrem<'a, K: ToRedisArgs, V: ToRedisArgs>(
        &mut self, 
        key: K, 
        count: isize, 
        value: V
    ) -> &mut Self { ... }
    fn ltrim<'a, K: ToRedisArgs>(
        &mut self, 
        key: K, 
        start: isize, 
        stop: isize
    ) -> &mut Self { ... }
    fn lset<'a, K: ToRedisArgs, V: ToRedisArgs>(
        &mut self, 
        key: K, 
        index: isize, 
        value: V
    ) -> &mut Self { ... }
    fn rpop<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self { ... }
    fn rpoplpush<'a, K: ToRedisArgs>(&mut self, key: K, dstkey: K) -> &mut Self { ... }
    fn rpush<'a, K: ToRedisArgs, V: ToRedisArgs>(
        &mut self, 
        key: K, 
        value: V
    ) -> &mut Self { ... }
    fn rpush_exists<'a, K: ToRedisArgs, V: ToRedisArgs>(
        &mut self, 
        key: K, 
        value: V
    ) -> &mut Self { ... }
    fn sadd<'a, K: ToRedisArgs, M: ToRedisArgs>(
        &mut self, 
        key: K, 
        member: M
    ) -> &mut Self { ... }
    fn scard<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self { ... }
    fn sdiff<'a, K: ToRedisArgs>(&mut self, keys: K) -> &mut Self { ... }
    fn sdiffstore<'a, K: ToRedisArgs>(
        &mut self, 
        dstkey: K, 
        keys: K
    ) -> &mut Self { ... }
    fn sinter<'a, K: ToRedisArgs>(&mut self, keys: K) -> &mut Self { ... }
    fn sdinterstore<'a, K: ToRedisArgs>(
        &mut self, 
        dstkey: K, 
        keys: K
    ) -> &mut Self { ... }
    fn sismember<'a, K: ToRedisArgs, M: ToRedisArgs>(
        &mut self, 
        key: K, 
        member: M
    ) -> &mut Self { ... }
    fn smembers<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self { ... }
    fn smove<'a, K: ToRedisArgs, M: ToRedisArgs>(
        &mut self, 
        srckey: K, 
        dstkey: K, 
        member: M
    ) -> &mut Self { ... }
    fn spop<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self { ... }
    fn srandmember<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self { ... }
    fn srandmember_multiple<'a, K: ToRedisArgs>(
        &mut self, 
        key: K, 
        count: usize
    ) -> &mut Self { ... }
    fn srem<'a, K: ToRedisArgs, M: ToRedisArgs>(
        &mut self, 
        key: K, 
        member: M
    ) -> &mut Self { ... }
    fn sunion<'a, K: ToRedisArgs>(&mut self, keys: K) -> &mut Self { ... }
    fn sunionstore<'a, K: ToRedisArgs>(
        &mut self, 
        dstkey: K, 
        keys: K
    ) -> &mut Self { ... }
    fn zadd<'a, K: ToRedisArgs, S: ToRedisArgs, M: ToRedisArgs>(
        &mut self, 
        key: K, 
        member: M, 
        score: S
    ) -> &mut Self { ... }
    fn zadd_multiple<'a, K: ToRedisArgs, S: ToRedisArgs, M: ToRedisArgs>(
        &mut self, 
        key: K, 
        items: &[(S, M)]
    ) -> &mut Self { ... }
    fn zcard<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self { ... }
    fn zcount<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs>(
        &mut self, 
        key: K, 
        min: M, 
        max: MM
    ) -> &mut Self { ... }
    fn zincr<'a, K: ToRedisArgs, M: ToRedisArgs, D: ToRedisArgs>(
        &mut self, 
        key: K, 
        member: M, 
        delta: D
    ) -> &mut Self { ... }
    fn zinterstore<'a, K: ToRedisArgs>(
        &mut self, 
        dstkey: K, 
        keys: &[K]
    ) -> &mut Self { ... }
    fn zinterstore_min<'a, K: ToRedisArgs>(
        &mut self, 
        dstkey: K, 
        keys: &[K]
    ) -> &mut Self { ... }
    fn zinterstore_max<'a, K: ToRedisArgs>(
        &mut self, 
        dstkey: K, 
        keys: &[K]
    ) -> &mut Self { ... }
    fn zlexcount<'a, K: ToRedisArgs, L: ToRedisArgs>(
        &mut self, 
        key: K, 
        min: L, 
        max: L
    ) -> &mut Self { ... }
    fn zrange<'a, K: ToRedisArgs>(
        &mut self, 
        key: K, 
        start: isize, 
        stop: isize
    ) -> &mut Self { ... }
    fn zrange_withscores<'a, K: ToRedisArgs>(
        &mut self, 
        key: K, 
        start: isize, 
        stop: isize
    ) -> &mut Self { ... }
    fn zrangebylex<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs>(
        &mut self, 
        key: K, 
        min: M, 
        max: MM
    ) -> &mut Self { ... }
    fn zrangebylex_limit<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs>(
        &mut self, 
        key: K, 
        min: M, 
        max: MM, 
        offset: isize, 
        count: isize
    ) -> &mut Self { ... }
    fn zrevrangebylex<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs>(
        &mut self, 
        key: K, 
        max: MM, 
        min: M
    ) -> &mut Self { ... }
    fn zrevrangebylex_limit<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs>(
        &mut self, 
        key: K, 
        max: MM, 
        min: M, 
        offset: isize, 
        count: isize
    ) -> &mut Self { ... }
    fn zrangebyscore<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs>(
        &mut self, 
        key: K, 
        min: M, 
        max: MM
    ) -> &mut Self { ... }
    fn zrangebyscore_withscores<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs>(
        &mut self, 
        key: K, 
        min: M, 
        max: MM
    ) -> &mut Self { ... }
    fn zrangebyscore_limit<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs>(
        &mut self, 
        key: K, 
        min: M, 
        max: MM, 
        offset: isize, 
        count: isize
    ) -> &mut Self { ... }
    fn zrangebyscore_limit_withscores<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs>(
        &mut self, 
        key: K, 
        min: M, 
        max: MM, 
        offset: isize, 
        count: isize
    ) -> &mut Self { ... }
    fn zrank<'a, K: ToRedisArgs, M: ToRedisArgs>(
        &mut self, 
        key: K, 
        member: M
    ) -> &mut Self { ... }
    fn zrem<'a, K: ToRedisArgs, M: ToRedisArgs>(
        &mut self, 
        key: K, 
        members: M
    ) -> &mut Self { ... }
    fn zrembylex<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs>(
        &mut self, 
        key: K, 
        min: M, 
        max: MM
    ) -> &mut Self { ... }
    fn zrembyrank<'a, K: ToRedisArgs>(
        &mut self, 
        key: K, 
        start: isize, 
        stop: isize
    ) -> &mut Self { ... }
    fn zrembyscore<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs>(
        &mut self, 
        key: K, 
        min: M, 
        max: MM
    ) -> &mut Self { ... }
    fn zrevrange<'a, K: ToRedisArgs>(
        &mut self, 
        key: K, 
        start: isize, 
        stop: isize
    ) -> &mut Self { ... }
    fn zrevrange_withscores<'a, K: ToRedisArgs>(
        &mut self, 
        key: K, 
        start: isize, 
        stop: isize
    ) -> &mut Self { ... }
    fn zrevrangebyscore<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs>(
        &mut self, 
        key: K, 
        max: MM, 
        min: M
    ) -> &mut Self { ... }
    fn zrevrangebyscore_withscores<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs>(
        &mut self, 
        key: K, 
        max: MM, 
        min: M
    ) -> &mut Self { ... }
    fn zrevrangebyscore_limit<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs>(
        &mut self, 
        key: K, 
        max: MM, 
        min: M, 
        offset: isize, 
        count: isize
    ) -> &mut Self { ... }
    fn zrevrangebyscore_limit_withscores<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs>(
        &mut self, 
        key: K, 
        max: MM, 
        min: M, 
        offset: isize, 
        count: isize
    ) -> &mut Self { ... }
    fn zrevrank<'a, K: ToRedisArgs, M: ToRedisArgs>(
        &mut self, 
        key: K, 
        member: M
    ) -> &mut Self { ... }
    fn zscore<'a, K: ToRedisArgs, M: ToRedisArgs>(
        &mut self, 
        key: K, 
        member: M
    ) -> &mut Self { ... }
    fn zunionstore<'a, K: ToRedisArgs>(
        &mut self, 
        dstkey: K, 
        keys: &[K]
    ) -> &mut Self { ... }
    fn zunionstore_min<'a, K: ToRedisArgs>(
        &mut self, 
        dstkey: K, 
        keys: &[K]
    ) -> &mut Self { ... }
    fn zunionstore_max<'a, K: ToRedisArgs>(
        &mut self, 
        dstkey: K, 
        keys: &[K]
    ) -> &mut Self { ... }
    fn pfadd<'a, K: ToRedisArgs, E: ToRedisArgs>(
        &mut self, 
        key: K, 
        element: E
    ) -> &mut Self { ... }
    fn pfcount<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self { ... }
    fn pfmerge<'a, K: ToRedisArgs>(
        &mut self, 
        dstkey: K, 
        srckeys: K
    ) -> &mut Self { ... }
    fn publish<'a, K: ToRedisArgs, E: ToRedisArgs>(
        &mut self, 
        channel: K, 
        message: E
    ) -> &mut Self { ... }
}

Implements common redis commands for pipelines. Unlike the regular commands trait, this returns the pipeline rather than a result directly. Other than that it works the same however.

Provided methods

fn get<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

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

fn keys<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

Gets all keys matching pattern

fn set<'a, K: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    key: K,
    value: V
) -> &mut Self

Set the string value of a key.

fn set_multiple<'a, K: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    items: &[(K, V)]
) -> &mut Self

Sets multiple keys to their values.

fn set_ex<'a, K: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    key: K,
    value: V,
    seconds: usize
) -> &mut Self

Set the value and expiration of a key.

fn set_nx<'a, K: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    key: K,
    value: V
) -> &mut Self

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

fn mset_nx<'a, K: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    items: &[(K, V)]
) -> &mut Self

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

fn getset<'a, K: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    key: K,
    value: V
) -> &mut Self

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

fn del<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

Delete one or more keys.

fn exists<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

Determine if a key exists.

fn expire<'a, K: ToRedisArgs>(&mut self, key: K, seconds: usize) -> &mut Self

Set a key's time to live in seconds.

fn expire_at<'a, K: ToRedisArgs>(&mut self, key: K, ts: usize) -> &mut Self

Set the expiration for a key as a UNIX timestamp.

fn pexpire<'a, K: ToRedisArgs>(&mut self, key: K, ms: usize) -> &mut Self

Set a key's time to live in milliseconds.

fn pexpire_at<'a, K: ToRedisArgs>(&mut self, key: K, ts: usize) -> &mut Self

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

fn persist<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

Remove the expiration from a key.

fn ttl<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

Check the expiration time of a key.

fn rename<'a, K: ToRedisArgs>(&mut self, key: K, new_key: K) -> &mut Self

Rename a key.

fn rename_nx<'a, K: ToRedisArgs>(&mut self, key: K, new_key: K) -> &mut Self

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

fn append<'a, K: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    key: K,
    value: V
) -> &mut Self

Append a value to a key.

fn incr<'a, K: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    key: K,
    delta: V
) -> &mut Self

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

fn setbit<'a, K: ToRedisArgs>(
    &mut self,
    key: K,
    offset: usize,
    value: bool
) -> &mut Self

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

fn getbit<'a, K: ToRedisArgs>(&mut self, key: K, offset: usize) -> &mut Self

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

fn bitcount<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

Count set bits in a string.

fn bitcount_range<'a, K: ToRedisArgs>(
    &mut self,
    key: K,
    start: usize,
    end: usize
) -> &mut Self

Count set bits in a string in a range.

fn bit_and<'a, K: ToRedisArgs>(&mut self, dstkey: K, srckeys: K) -> &mut Self

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

fn bit_or<'a, K: ToRedisArgs>(&mut self, dstkey: K, srckeys: K) -> &mut Self

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

fn bit_xor<'a, K: ToRedisArgs>(&mut self, dstkey: K, srckeys: K) -> &mut Self

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

fn bit_not<'a, K: ToRedisArgs>(&mut self, dstkey: K, srckey: K) -> &mut Self

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

fn strlen<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

Get the length of the value stored in a key.

fn hget<'a, K: ToRedisArgs, F: ToRedisArgs>(
    &mut self,
    key: K,
    field: F
) -> &mut Self

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

fn hdel<'a, K: ToRedisArgs, F: ToRedisArgs>(
    &mut self,
    key: K,
    field: F
) -> &mut Self

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

fn hset<'a, K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    key: K,
    field: F,
    value: V
) -> &mut Self

Sets a single field in a hash.

fn hset_nx<'a, K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    key: K,
    field: F,
    value: V
) -> &mut Self

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

fn hset_multiple<'a, K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    key: K,
    items: &[(F, V)]
) -> &mut Self

Sets a multiple fields in a hash.

fn hincr<'a, K: ToRedisArgs, F: ToRedisArgs, D: ToRedisArgs>(
    &mut self,
    key: K,
    field: F,
    delta: D
) -> &mut Self

Increments a value.

fn hexists<'a, K: ToRedisArgs, F: ToRedisArgs>(
    &mut self,
    key: K,
    field: F
) -> &mut Self

Checks if a field in a hash exists.

fn hkeys<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

Gets all the keys in a hash.

fn hvals<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

Gets all the values in a hash.

fn hgetall<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

Gets all the fields and values in a hash.

fn hlen<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

Gets the length of a hash.

fn blpop<'a, K: ToRedisArgs>(&mut self, key: K, timeout: usize) -> &mut Self

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

fn brpop<'a, K: ToRedisArgs>(&mut self, key: K, timeout: usize) -> &mut Self

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

fn brpoplpush<'a, K: ToRedisArgs>(
    &mut self,
    srckey: K,
    dstkey: K,
    timeout: usize
) -> &mut Self

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>(&mut self, key: K, index: isize) -> &mut Self

Get an element from a list by its index.

fn linsert_before<'a, K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    key: K,
    pivot: P,
    value: V
) -> &mut Self

Insert an element before another element in a list.

fn linsert_after<'a, K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    key: K,
    pivot: P,
    value: V
) -> &mut Self

Insert an element after another element in a list.

fn llen<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

Returns the length of the list stored at key.

fn lpop<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

Removes and returns the first element of the list stored at key.

fn lpush<'a, K: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    key: K,
    value: V
) -> &mut Self

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

fn lpush_exists<'a, K: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    key: K,
    value: V
) -> &mut Self

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>(
    &mut self,
    key: K,
    start: isize,
    stop: isize
) -> &mut Self

Returns the specified elements of the list stored at key.

fn lrem<'a, K: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    key: K,
    count: isize,
    value: V
) -> &mut Self

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

fn ltrim<'a, K: ToRedisArgs>(
    &mut self,
    key: K,
    start: isize,
    stop: isize
) -> &mut Self

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

fn lset<'a, K: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    key: K,
    index: isize,
    value: V
) -> &mut Self

Sets the list element at index to value

fn rpop<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

Removes and returns the last element of the list stored at key.

fn rpoplpush<'a, K: ToRedisArgs>(&mut self, key: K, dstkey: K) -> &mut Self

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

fn rpush<'a, K: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    key: K,
    value: V
) -> &mut Self

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

fn rpush_exists<'a, K: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    key: K,
    value: V
) -> &mut Self

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, M: ToRedisArgs>(
    &mut self,
    key: K,
    member: M
) -> &mut Self

Add one or more members to a set.

fn scard<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

Get the number of members in a set.

fn sdiff<'a, K: ToRedisArgs>(&mut self, keys: K) -> &mut Self

Subtract multiple sets.

fn sdiffstore<'a, K: ToRedisArgs>(&mut self, dstkey: K, keys: K) -> &mut Self

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

fn sinter<'a, K: ToRedisArgs>(&mut self, keys: K) -> &mut Self

Intersect multiple sets.

fn sdinterstore<'a, K: ToRedisArgs>(&mut self, dstkey: K, keys: K) -> &mut Self

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

fn sismember<'a, K: ToRedisArgs, M: ToRedisArgs>(
    &mut self,
    key: K,
    member: M
) -> &mut Self

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

fn smembers<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

Get all the members in a set.

fn smove<'a, K: ToRedisArgs, M: ToRedisArgs>(
    &mut self,
    srckey: K,
    dstkey: K,
    member: M
) -> &mut Self

Move a member from one set to another.

fn spop<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

Remove and return a random member from a set.

fn srandmember<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

Get one random member from a set.

fn srandmember_multiple<'a, K: ToRedisArgs>(
    &mut self,
    key: K,
    count: usize
) -> &mut Self

Get multiple random members from a set.

fn srem<'a, K: ToRedisArgs, M: ToRedisArgs>(
    &mut self,
    key: K,
    member: M
) -> &mut Self

Remove one or more members from a set.

fn sunion<'a, K: ToRedisArgs>(&mut self, keys: K) -> &mut Self

Add multiple sets.

fn sunionstore<'a, K: ToRedisArgs>(&mut self, dstkey: K, keys: K) -> &mut Self

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

fn zadd<'a, K: ToRedisArgs, S: ToRedisArgs, M: ToRedisArgs>(
    &mut self,
    key: K,
    member: M,
    score: S
) -> &mut Self

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

fn zadd_multiple<'a, K: ToRedisArgs, S: ToRedisArgs, M: ToRedisArgs>(
    &mut self,
    key: K,
    items: &[(S, M)]
) -> &mut Self

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

fn zcard<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

Get the number of members in a sorted set.

fn zcount<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs>(
    &mut self,
    key: K,
    min: M,
    max: MM
) -> &mut Self

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

fn zincr<'a, K: ToRedisArgs, M: ToRedisArgs, D: ToRedisArgs>(
    &mut self,
    key: K,
    member: M,
    delta: D
) -> &mut Self

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, K: ToRedisArgs>(
    &mut self,
    dstkey: K,
    keys: &[K]
) -> &mut Self

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

fn zinterstore_min<'a, K: ToRedisArgs>(
    &mut self,
    dstkey: K,
    keys: &[K]
) -> &mut Self

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

fn zinterstore_max<'a, K: ToRedisArgs>(
    &mut self,
    dstkey: K,
    keys: &[K]
) -> &mut Self

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

fn zlexcount<'a, K: ToRedisArgs, L: ToRedisArgs>(
    &mut self,
    key: K,
    min: L,
    max: L
) -> &mut Self

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

fn zrange<'a, K: ToRedisArgs>(
    &mut self,
    key: K,
    start: isize,
    stop: isize
) -> &mut Self

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

fn zrange_withscores<'a, K: ToRedisArgs>(
    &mut self,
    key: K,
    start: isize,
    stop: isize
) -> &mut Self

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

fn zrangebylex<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs>(
    &mut self,
    key: K,
    min: M,
    max: MM
) -> &mut Self

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

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

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

fn zrevrangebylex<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs>(
    &mut self,
    key: K,
    max: MM,
    min: M
) -> &mut Self

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

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

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

fn zrangebyscore<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs>(
    &mut self,
    key: K,
    min: M,
    max: MM
) -> &mut Self

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

fn zrangebyscore_withscores<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs>(
    &mut self,
    key: K,
    min: M,
    max: MM
) -> &mut Self

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

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

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

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

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

fn zrank<'a, K: ToRedisArgs, M: ToRedisArgs>(
    &mut self,
    key: K,
    member: M
) -> &mut Self

Determine the index of a member in a sorted set.

fn zrem<'a, K: ToRedisArgs, M: ToRedisArgs>(
    &mut self,
    key: K,
    members: M
) -> &mut Self

Remove one or more members from a sorted set.

fn zrembylex<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs>(
    &mut self,
    key: K,
    min: M,
    max: MM
) -> &mut Self

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

fn zrembyrank<'a, K: ToRedisArgs>(
    &mut self,
    key: K,
    start: isize,
    stop: isize
) -> &mut Self

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

fn zrembyscore<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs>(
    &mut self,
    key: K,
    min: M,
    max: MM
) -> &mut Self

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

fn zrevrange<'a, K: ToRedisArgs>(
    &mut self,
    key: K,
    start: isize,
    stop: isize
) -> &mut Self

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

fn zrevrange_withscores<'a, K: ToRedisArgs>(
    &mut self,
    key: K,
    start: isize,
    stop: isize
) -> &mut Self

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

fn zrevrangebyscore<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs>(
    &mut self,
    key: K,
    max: MM,
    min: M
) -> &mut Self

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

fn zrevrangebyscore_withscores<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs>(
    &mut self,
    key: K,
    max: MM,
    min: M
) -> &mut Self

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

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

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

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

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

fn zrevrank<'a, K: ToRedisArgs, M: ToRedisArgs>(
    &mut self,
    key: K,
    member: M
) -> &mut Self

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

fn zscore<'a, K: ToRedisArgs, M: ToRedisArgs>(
    &mut self,
    key: K,
    member: M
) -> &mut Self

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

fn zunionstore<'a, K: ToRedisArgs>(
    &mut self,
    dstkey: K,
    keys: &[K]
) -> &mut Self

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

fn zunionstore_min<'a, K: ToRedisArgs>(
    &mut self,
    dstkey: K,
    keys: &[K]
) -> &mut Self

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

fn zunionstore_max<'a, K: ToRedisArgs>(
    &mut self,
    dstkey: K,
    keys: &[K]
) -> &mut Self

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

fn pfadd<'a, K: ToRedisArgs, E: ToRedisArgs>(
    &mut self,
    key: K,
    element: E
) -> &mut Self

Adds the specified elements to the specified HyperLogLog.

fn pfcount<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

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

fn pfmerge<'a, K: ToRedisArgs>(&mut self, dstkey: K, srckeys: K) -> &mut Self

Merge N different HyperLogLogs into a single one.

fn publish<'a, K: ToRedisArgs, E: ToRedisArgs>(
    &mut self,
    channel: K,
    message: E
) -> &mut Self

Posts a message to the given channel.

Loading content...

Implementors

impl PipelineCommands for Pipeline

fn perform(&mut self, cmd: &Cmd) -> &mut Pipeline

fn get<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

fn keys<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

fn set<'a, K: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    key: K,
    value: V
) -> &mut Self

fn set_multiple<'a, K: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    items: &[(K, V)]
) -> &mut Self

fn set_ex<'a, K: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    key: K,
    value: V,
    seconds: usize
) -> &mut Self

fn set_nx<'a, K: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    key: K,
    value: V
) -> &mut Self

fn mset_nx<'a, K: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    items: &[(K, V)]
) -> &mut Self

fn getset<'a, K: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    key: K,
    value: V
) -> &mut Self

fn del<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

fn exists<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

fn expire<'a, K: ToRedisArgs>(&mut self, key: K, seconds: usize) -> &mut Self

fn expire_at<'a, K: ToRedisArgs>(&mut self, key: K, ts: usize) -> &mut Self

fn pexpire<'a, K: ToRedisArgs>(&mut self, key: K, ms: usize) -> &mut Self

fn pexpire_at<'a, K: ToRedisArgs>(&mut self, key: K, ts: usize) -> &mut Self

fn persist<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

fn ttl<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

fn rename<'a, K: ToRedisArgs>(&mut self, key: K, new_key: K) -> &mut Self

fn rename_nx<'a, K: ToRedisArgs>(&mut self, key: K, new_key: K) -> &mut Self

fn append<'a, K: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    key: K,
    value: V
) -> &mut Self

fn incr<'a, K: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    key: K,
    delta: V
) -> &mut Self

fn setbit<'a, K: ToRedisArgs>(
    &mut self,
    key: K,
    offset: usize,
    value: bool
) -> &mut Self

fn getbit<'a, K: ToRedisArgs>(&mut self, key: K, offset: usize) -> &mut Self

fn bitcount<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

fn bitcount_range<'a, K: ToRedisArgs>(
    &mut self,
    key: K,
    start: usize,
    end: usize
) -> &mut Self

fn bit_and<'a, K: ToRedisArgs>(&mut self, dstkey: K, srckeys: K) -> &mut Self

fn bit_or<'a, K: ToRedisArgs>(&mut self, dstkey: K, srckeys: K) -> &mut Self

fn bit_xor<'a, K: ToRedisArgs>(&mut self, dstkey: K, srckeys: K) -> &mut Self

fn bit_not<'a, K: ToRedisArgs>(&mut self, dstkey: K, srckey: K) -> &mut Self

fn strlen<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

fn hget<'a, K: ToRedisArgs, F: ToRedisArgs>(
    &mut self,
    key: K,
    field: F
) -> &mut Self

fn hdel<'a, K: ToRedisArgs, F: ToRedisArgs>(
    &mut self,
    key: K,
    field: F
) -> &mut Self

fn hset<'a, K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    key: K,
    field: F,
    value: V
) -> &mut Self

fn hset_nx<'a, K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    key: K,
    field: F,
    value: V
) -> &mut Self

fn hset_multiple<'a, K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    key: K,
    items: &[(F, V)]
) -> &mut Self

fn hincr<'a, K: ToRedisArgs, F: ToRedisArgs, D: ToRedisArgs>(
    &mut self,
    key: K,
    field: F,
    delta: D
) -> &mut Self

fn hexists<'a, K: ToRedisArgs, F: ToRedisArgs>(
    &mut self,
    key: K,
    field: F
) -> &mut Self

fn hkeys<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

fn hvals<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

fn hgetall<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

fn hlen<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

fn blpop<'a, K: ToRedisArgs>(&mut self, key: K, timeout: usize) -> &mut Self

fn brpop<'a, K: ToRedisArgs>(&mut self, key: K, timeout: usize) -> &mut Self

fn brpoplpush<'a, K: ToRedisArgs>(
    &mut self,
    srckey: K,
    dstkey: K,
    timeout: usize
) -> &mut Self

fn lindex<'a, K: ToRedisArgs>(&mut self, key: K, index: isize) -> &mut Self

fn linsert_before<'a, K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    key: K,
    pivot: P,
    value: V
) -> &mut Self

fn linsert_after<'a, K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    key: K,
    pivot: P,
    value: V
) -> &mut Self

fn llen<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

fn lpop<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

fn lpush<'a, K: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    key: K,
    value: V
) -> &mut Self

fn lpush_exists<'a, K: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    key: K,
    value: V
) -> &mut Self

fn lrange<'a, K: ToRedisArgs>(
    &mut self,
    key: K,
    start: isize,
    stop: isize
) -> &mut Self

fn lrem<'a, K: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    key: K,
    count: isize,
    value: V
) -> &mut Self

fn ltrim<'a, K: ToRedisArgs>(
    &mut self,
    key: K,
    start: isize,
    stop: isize
) -> &mut Self

fn lset<'a, K: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    key: K,
    index: isize,
    value: V
) -> &mut Self

fn rpop<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

fn rpoplpush<'a, K: ToRedisArgs>(&mut self, key: K, dstkey: K) -> &mut Self

fn rpush<'a, K: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    key: K,
    value: V
) -> &mut Self

fn rpush_exists<'a, K: ToRedisArgs, V: ToRedisArgs>(
    &mut self,
    key: K,
    value: V
) -> &mut Self

fn sadd<'a, K: ToRedisArgs, M: ToRedisArgs>(
    &mut self,
    key: K,
    member: M
) -> &mut Self

fn scard<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

fn sdiff<'a, K: ToRedisArgs>(&mut self, keys: K) -> &mut Self

fn sdiffstore<'a, K: ToRedisArgs>(&mut self, dstkey: K, keys: K) -> &mut Self

fn sinter<'a, K: ToRedisArgs>(&mut self, keys: K) -> &mut Self

fn sdinterstore<'a, K: ToRedisArgs>(&mut self, dstkey: K, keys: K) -> &mut Self

fn sismember<'a, K: ToRedisArgs, M: ToRedisArgs>(
    &mut self,
    key: K,
    member: M
) -> &mut Self

fn smembers<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

fn smove<'a, K: ToRedisArgs, M: ToRedisArgs>(
    &mut self,
    srckey: K,
    dstkey: K,
    member: M
) -> &mut Self

fn spop<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

fn srandmember<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

fn srandmember_multiple<'a, K: ToRedisArgs>(
    &mut self,
    key: K,
    count: usize
) -> &mut Self

fn srem<'a, K: ToRedisArgs, M: ToRedisArgs>(
    &mut self,
    key: K,
    member: M
) -> &mut Self

fn sunion<'a, K: ToRedisArgs>(&mut self, keys: K) -> &mut Self

fn sunionstore<'a, K: ToRedisArgs>(&mut self, dstkey: K, keys: K) -> &mut Self

fn zadd<'a, K: ToRedisArgs, S: ToRedisArgs, M: ToRedisArgs>(
    &mut self,
    key: K,
    member: M,
    score: S
) -> &mut Self

fn zadd_multiple<'a, K: ToRedisArgs, S: ToRedisArgs, M: ToRedisArgs>(
    &mut self,
    key: K,
    items: &[(S, M)]
) -> &mut Self

fn zcard<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

fn zcount<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs>(
    &mut self,
    key: K,
    min: M,
    max: MM
) -> &mut Self

fn zincr<'a, K: ToRedisArgs, M: ToRedisArgs, D: ToRedisArgs>(
    &mut self,
    key: K,
    member: M,
    delta: D
) -> &mut Self

fn zinterstore<'a, K: ToRedisArgs>(
    &mut self,
    dstkey: K,
    keys: &[K]
) -> &mut Self

fn zinterstore_min<'a, K: ToRedisArgs>(
    &mut self,
    dstkey: K,
    keys: &[K]
) -> &mut Self

fn zinterstore_max<'a, K: ToRedisArgs>(
    &mut self,
    dstkey: K,
    keys: &[K]
) -> &mut Self

fn zlexcount<'a, K: ToRedisArgs, L: ToRedisArgs>(
    &mut self,
    key: K,
    min: L,
    max: L
) -> &mut Self

fn zrange<'a, K: ToRedisArgs>(
    &mut self,
    key: K,
    start: isize,
    stop: isize
) -> &mut Self

fn zrange_withscores<'a, K: ToRedisArgs>(
    &mut self,
    key: K,
    start: isize,
    stop: isize
) -> &mut Self

fn zrangebylex<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs>(
    &mut self,
    key: K,
    min: M,
    max: MM
) -> &mut Self

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

fn zrevrangebylex<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs>(
    &mut self,
    key: K,
    max: MM,
    min: M
) -> &mut Self

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

fn zrangebyscore<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs>(
    &mut self,
    key: K,
    min: M,
    max: MM
) -> &mut Self

fn zrangebyscore_withscores<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs>(
    &mut self,
    key: K,
    min: M,
    max: MM
) -> &mut Self

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

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

fn zrank<'a, K: ToRedisArgs, M: ToRedisArgs>(
    &mut self,
    key: K,
    member: M
) -> &mut Self

fn zrem<'a, K: ToRedisArgs, M: ToRedisArgs>(
    &mut self,
    key: K,
    members: M
) -> &mut Self

fn zrembylex<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs>(
    &mut self,
    key: K,
    min: M,
    max: MM
) -> &mut Self

fn zrembyrank<'a, K: ToRedisArgs>(
    &mut self,
    key: K,
    start: isize,
    stop: isize
) -> &mut Self

fn zrembyscore<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs>(
    &mut self,
    key: K,
    min: M,
    max: MM
) -> &mut Self

fn zrevrange<'a, K: ToRedisArgs>(
    &mut self,
    key: K,
    start: isize,
    stop: isize
) -> &mut Self

fn zrevrange_withscores<'a, K: ToRedisArgs>(
    &mut self,
    key: K,
    start: isize,
    stop: isize
) -> &mut Self

fn zrevrangebyscore<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs>(
    &mut self,
    key: K,
    max: MM,
    min: M
) -> &mut Self

fn zrevrangebyscore_withscores<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs>(
    &mut self,
    key: K,
    max: MM,
    min: M
) -> &mut Self

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

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

fn zrevrank<'a, K: ToRedisArgs, M: ToRedisArgs>(
    &mut self,
    key: K,
    member: M
) -> &mut Self

fn zscore<'a, K: ToRedisArgs, M: ToRedisArgs>(
    &mut self,
    key: K,
    member: M
) -> &mut Self

fn zunionstore<'a, K: ToRedisArgs>(
    &mut self,
    dstkey: K,
    keys: &[K]
) -> &mut Self

fn zunionstore_min<'a, K: ToRedisArgs>(
    &mut self,
    dstkey: K,
    keys: &[K]
) -> &mut Self

fn zunionstore_max<'a, K: ToRedisArgs>(
    &mut self,
    dstkey: K,
    keys: &[K]
) -> &mut Self

fn pfadd<'a, K: ToRedisArgs, E: ToRedisArgs>(
    &mut self,
    key: K,
    element: E
) -> &mut Self

fn pfcount<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

fn pfmerge<'a, K: ToRedisArgs>(&mut self, dstkey: K, srckeys: K) -> &mut Self

fn publish<'a, K: ToRedisArgs, E: ToRedisArgs>(
    &mut self,
    channel: K,
    message: E
) -> &mut Self

Loading content...