Struct redis_cluster::Cluster

pub struct Cluster { /* fields omitted */ }

Methods

impl Cluster

fn new(startup_nodes: Vec<&str>) -> Cluster

fn send_command<T: FromRedisValue>(&mut self,
                                   cmd: &ClusterCmd)
                                   -> RedisResult<T>

Trait Implementations

impl ConnectionLike for Cluster

fn req_packed_command(&self, cmd: &[u8]) -> RedisResult<Value>

Sends an already encoded (packed) command into the TCP socket and reads the single response from it.

fn req_packed_commands(&self,
                       cmd: &[u8],
                       offset: usize,
                       count: usize)
                       -> RedisResult<Vec<Value>>

Sends multiple already encoded (packed) command into the TCP socket and reads count responses from it. This is used to implement pipelining.

fn get_db(&self) -> i64

Returns the database this connection is bound to. Note that this information might be unreliable because it's initially cached and also might be incorrect if the connection like object is not actually connected.

impl Commands for Cluster

fn get<K, RV>(&self, key: K) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

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

fn keys<K, RV>(&self, key: K) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

Gets all keys matching pattern

fn set<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue, V: ToRedisArgs

Set the string value of a key.

fn set_multiple<K, V, RV>(&self, items: &[(K, V)]) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue, V: ToRedisArgs

Sets multiple keys to their values.

fn set_ex<K, V, RV>(&self,
                    key: K,
                    value: V,
                    seconds: usize)
                    -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue, V: ToRedisArgs

Set the value and expiration of a key.

fn set_nx<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue, V: ToRedisArgs

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

fn mset_nx<K, V, RV>(&self, items: &[(K, V)]) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue, V: ToRedisArgs

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

fn getset<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue, V: ToRedisArgs

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

fn del<K, RV>(&self, key: K) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

Delete one or more keys.

fn exists<K, RV>(&self, key: K) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

Determine if a key exists.

fn expire<K, RV>(&self, key: K, seconds: usize) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

Set a key's time to live in seconds.

fn expire_at<K, RV>(&self, key: K, ts: usize) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

Set the expiration for a key as a UNIX timestamp.

fn pexpire<K, RV>(&self, key: K, ms: usize) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

Set a key's time to live in milliseconds.

fn pexpire_at<K, RV>(&self, key: K, ts: usize) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

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

fn persist<K, RV>(&self, key: K) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

Remove the expiration from a key.

fn rename<K, RV>(&self, key: K, new_key: K) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

Rename a key.

fn rename_nx<K, RV>(&self, key: K, new_key: K) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

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

fn append<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue, V: ToRedisArgs

Append a value to a key.

fn incr<K, V, RV>(&self, key: K, delta: V) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue, V: ToRedisArgs

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

fn setbit<K, RV>(&self,
                 key: K,
                 offset: usize,
                 value: bool)
                 -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

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

fn getbit<K, RV>(&self, key: K, offset: usize) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

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

fn bitcount<K, RV>(&self, key: K) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

Count set bits in a string.

fn bitcount_range<K, RV>(&self,
                         key: K,
                         start: usize,
                         end: usize)
                         -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

Count set bits in a string in a range.

fn bit_and<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

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

fn bit_or<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

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

fn bit_xor<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

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

fn bit_not<K, RV>(&self, dstkey: K, srckey: K) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

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

fn strlen<K, RV>(&self, key: K) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

Get the length of the value stored in a key.

fn hget<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError> where F: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue

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

fn hdel<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError> where F: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue

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

fn hset<K, F, V, RV>(&self,
                     key: K,
                     field: F,
                     value: V)
                     -> Result<RV, RedisError> where F: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue, V: ToRedisArgs

Sets a single field in a hash.

fn hset_nx<K, F, V, RV>(&self,
                        key: K,
                        field: F,
                        value: V)
                        -> Result<RV, RedisError> where F: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue, V: ToRedisArgs

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

fn hset_multiple<K, F, V, RV>(&self,
                              key: K,
                              items: &[(F, V)])
                              -> Result<RV, RedisError> where F: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue, V: ToRedisArgs

Sets a multiple fields in a hash.

fn hincr<K, F, D, RV>(&self,
                      key: K,
                      field: F,
                      delta: D)
                      -> Result<RV, RedisError> where D: ToRedisArgs, F: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue

Increments a value.

fn hexists<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError> where F: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue

Checks if a field in a hash exists.

fn hkeys<K, RV>(&self, key: K) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

Gets all the keys in a hash.

fn hvals<K, RV>(&self, key: K) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

Gets all the values in a hash.

fn hgetall<K, RV>(&self, key: K) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

Gets all the fields and values in a hash.

fn hlen<K, RV>(&self, key: K) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

Gets the length of a hash.

fn blpop<K, RV>(&self, key: K, timeout: usize) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

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

fn brpop<K, RV>(&self, key: K, timeout: usize) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

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

fn brpoplpush<K, RV>(&self,
                     srckey: K,
                     dstkey: K,
                     timeout: usize)
                     -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

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

fn lindex<K, RV>(&self, key: K, index: isize) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

Get an element from a list by its index.

fn linsert_before<K, P, V, RV>(&self,
                               key: K,
                               pivot: P,
                               value: V)
                               -> Result<RV, RedisError> where K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue, V: ToRedisArgs

Insert an element before another element in a list.

fn linsert_after<K, P, V, RV>(&self,
                              key: K,
                              pivot: P,
                              value: V)
                              -> Result<RV, RedisError> where K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue, V: ToRedisArgs

Insert an element after another element in a list.

fn llen<K, RV>(&self, key: K) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

Returns the length of the list stored at key.

fn lpop<K, RV>(&self, key: K) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

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

fn lpush<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue, V: ToRedisArgs

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

fn lpush_exists<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue, V: ToRedisArgs

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

fn lrange<K, RV>(&self,
                 key: K,
                 start: isize,
                 stop: isize)
                 -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

Returns the specified elements of the list stored at key.

fn lrem<K, V, RV>(&self,
                  key: K,
                  count: isize,
                  value: V)
                  -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue, V: ToRedisArgs

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

fn ltrim<K, RV>(&self,
                key: K,
                start: isize,
                stop: isize)
                -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

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

fn rpop<K, RV>(&self, key: K) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

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

fn rpoplpush<K, RV>(&self, key: K, dstkey: K) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

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

fn rpush<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue, V: ToRedisArgs

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

fn rpush_exists<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue, V: ToRedisArgs

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

fn sadd<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue

Add one or more members to a set.

fn scard<K, RV>(&self, key: K) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

Get the number of members in a set.

fn sdiff<K, RV>(&self, keys: K) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

Subtract multiple sets.

fn sdiffstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

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

fn sinter<K, RV>(&self, keys: K) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

Intersect multiple sets.

fn sdinterstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

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

fn sismember<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue

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

fn smembers<K, RV>(&self, key: K) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

Get all the members in a set.

fn smove<K, M, RV>(&self,
                   srckey: K,
                   dstkey: K,
                   member: M)
                   -> Result<RV, RedisError> where K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue

Move a member from one set to another.

fn spop<K, RV>(&self, key: K) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

Remove and return a random member from a set.

fn srandmember<K, RV>(&self, key: K) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

Get one random member from a set.

fn srandmember_multiple<K, RV>(&self,
                               key: K,
                               count: usize)
                               -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

Get multiple random members from a set.

fn srem<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue

Remove one or more members from a set.

fn sunion<K, RV>(&self, keys: K) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

Add multiple sets.

fn sunionstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

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

fn zadd<K, S, M, RV>(&self,
                     key: K,
                     member: M,
                     score: S)
                     -> Result<RV, RedisError> where K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue, S: ToRedisArgs

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

fn zadd_multiple<K, S, M, RV>(&self,
                              key: K,
                              items: &[(S, M)])
                              -> Result<RV, RedisError> where K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue, S: ToRedisArgs

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

fn zcard<K, RV>(&self, key: K) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

Get the number of members in a sorted set.

fn zcount<K, M, MM, RV>(&self,
                        key: K,
                        min: M,
                        max: MM)
                        -> Result<RV, RedisError> where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue

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

fn zincr<K, M, D, RV>(&self,
                      key: K,
                      member: M,
                      delta: D)
                      -> Result<RV, RedisError> where D: ToRedisArgs, K: ToRedisArgs, M: ToRedisArgs, 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<K, RV>(&self, dstkey: K, keys: &[K]) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

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

fn zinterstore_min<K, RV>(&self,
                          dstkey: K,
                          keys: &[K])
                          -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

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

fn zinterstore_max<K, RV>(&self,
                          dstkey: K,
                          keys: &[K])
                          -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

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

fn zlexcount<K, L, RV>(&self, key: K, min: L, max: L) -> Result<RV, RedisError> where K: ToRedisArgs, L: ToRedisArgs, RV: FromRedisValue

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

fn zrange<K, RV>(&self,
                 key: K,
                 start: isize,
                 stop: isize)
                 -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

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

fn zrange_withscores<K, RV>(&self,
                            key: K,
                            start: isize,
                            stop: isize)
                            -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

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

fn zrangebylex<K, M, MM, RV>(&self,
                             key: K,
                             min: M,
                             max: MM)
                             -> Result<RV, RedisError> where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue

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

fn zrangebylex_limit<K, M, MM, RV>(&self,
                                   key: K,
                                   min: M,
                                   max: MM,
                                   offset: isize,
                                   count: isize)
                                   -> Result<RV, RedisError> where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue

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

fn zrevrangebylex<K, MM, M, RV>(&self,
                                key: K,
                                max: MM,
                                min: M)
                                -> Result<RV, RedisError> where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue

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

fn zrevrangebylex_limit<K, MM, M, RV>(&self,
                                      key: K,
                                      max: MM,
                                      min: M,
                                      offset: isize,
                                      count: isize)
                                      -> Result<RV, RedisError> where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue

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

fn zrangebyscore<K, M, MM, RV>(&self,
                               key: K,
                               min: M,
                               max: MM)
                               -> Result<RV, RedisError> where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue

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

fn zrangebyscore_withscores<K, M, MM, RV>(&self,
                                          key: K,
                                          min: M,
                                          max: MM)
                                          -> Result<RV, RedisError> where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue

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

fn zrangebyscore_limit<K, M, MM, RV>(&self,
                                     key: K,
                                     min: M,
                                     max: MM,
                                     offset: isize,
                                     count: isize)
                                     -> Result<RV, RedisError> where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue

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

fn zrangebyscore_limit_withscores<K, M, MM, RV>(&self,
                                                key: K,
                                                min: M,
                                                max: MM,
                                                offset: isize,
                                                count: isize)
                                                -> Result<RV, RedisError> where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue

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

fn zrank<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue

Determine the index of a member in a sorted set.

fn zrem<K, M, RV>(&self, key: K, members: M) -> Result<RV, RedisError> where K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue

Remove one or more members from a sorted set.

fn zrembylex<K, M, MM, RV>(&self,
                           key: K,
                           min: M,
                           max: MM)
                           -> Result<RV, RedisError> where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue

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

fn zrembyrank<K, RV>(&self,
                     key: K,
                     start: isize,
                     stop: isize)
                     -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

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

fn zrembyscore<K, M, MM, RV>(&self,
                             key: K,
                             min: M,
                             max: MM)
                             -> Result<RV, RedisError> where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue

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

fn zrevrange<K, RV>(&self,
                    key: K,
                    start: isize,
                    stop: isize)
                    -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

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

fn zrevrange_withscores<K, RV>(&self,
                               key: K,
                               start: isize,
                               stop: isize)
                               -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

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

fn zrevrangebyscore<K, MM, M, RV>(&self,
                                  key: K,
                                  max: MM,
                                  min: M)
                                  -> Result<RV, RedisError> where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue

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

fn zrevrangebyscore_withscores<K, MM, M, RV>(&self,
                                             key: K,
                                             max: MM,
                                             min: M)
                                             -> Result<RV, RedisError> where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue

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

fn zrevrangebyscore_limit<K, MM, M, RV>(&self,
                                        key: K,
                                        max: MM,
                                        min: M,
                                        offset: isize,
                                        count: isize)
                                        -> Result<RV, RedisError> where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue

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

fn zrevrangebyscore_limit_withscores<K, MM, M, RV>(&self,
                                                   key: K,
                                                   max: MM,
                                                   min: M,
                                                   offset: isize,
                                                   count: isize)
                                                   -> Result<RV, RedisError> where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue

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

fn zrevrank<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue

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

fn zscore<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue

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

fn zunionstore<K, RV>(&self, dstkey: K, keys: &[K]) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

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

fn zunionstore_min<K, RV>(&self,
                          dstkey: K,
                          keys: &[K])
                          -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

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

fn zunionstore_max<K, RV>(&self,
                          dstkey: K,
                          keys: &[K])
                          -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

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

fn pfadd<K, E, RV>(&self, key: K, element: E) -> Result<RV, RedisError> where E: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue

Adds the specified elements to the specified HyperLogLog.

fn pfcount<K, RV>(&self, key: K) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

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

fn pfmerge<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where K: ToRedisArgs, RV: FromRedisValue

Merge N different HyperLogLogs into a single one.

fn scan<RV>(&self) -> Result<Iter<RV>, RedisError> where RV: FromRedisValue

Incrementally iterate the keys space.

fn scan_match<P, RV>(&self, pattern: P) -> Result<Iter<RV>, RedisError> where P: ToRedisArgs, RV: FromRedisValue

Incrementally iterate the keys space for keys matching a pattern.

fn hscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError> where K: ToRedisArgs, RV: FromRedisValue

Incrementally iterate hash fields and associated values.

fn hscan_match<K, P, RV>(&self,
                         key: K,
                         pattern: P)
                         -> Result<Iter<RV>, RedisError> where K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue

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

fn sscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError> where K: ToRedisArgs, RV: FromRedisValue

Incrementally iterate set elements.

fn sscan_match<K, P, RV>(&self,
                         key: K,
                         pattern: P)
                         -> Result<Iter<RV>, RedisError> where K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue

Incrementally iterate set elements for elements matching a pattern.

fn zscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError> where K: ToRedisArgs, RV: FromRedisValue

Incrementally iterate sorted set elements.

fn zscan_match<K, P, RV>(&self,
                         key: K,
                         pattern: P)
                         -> Result<Iter<RV>, RedisError> where K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue

Incrementally iterate sorted set elements for elements matching a pattern.