Struct fred::clients::RedisClient

pub struct RedisClient { /* private fields */ }

The primary Redis client struct.

Implementations

impl RedisClient

pub fn new(config: RedisConfig) -> RedisClient

Create a new client instance without connecting to the server.

pub fn clone_new(&self) -> Self

Create a new RedisClient from the config provided to this client.

The returned client will not be connected to the server, and it will use new connections after connecting.

pub fn on_reconnect(&self) -> impl Stream<Item = Self>

Listen for reconnection notifications.

This function can be used to receive notifications whenever the client successfully reconnects in order to select the right database again, re-subscribe to channels, etc.

A reconnection event is also triggered upon first connecting to the server.

pub fn on_cluster_change(&self) -> impl Stream<Item = Vec<ClusterStateChange>>

Listen for notifications whenever the cluster state changes.

This is usually triggered in response to a MOVED or ASK error, but can also happen when connections close unexpectedly.

pub async fn split_cluster(&self) -> Result<Vec<RedisClient>, RedisError>

Split a clustered Redis client into a list of centralized clients - one for each primary node in the cluster.

Some Redis commands are not designed to work with hash slots against a clustered deployment. For example, FLUSHDB, PING, etc all work on one node in the cluster, but no interface exists for the client to select a specific node in the cluster against which to run the command. This function allows the caller to create a list of clients such that each connect to one of the primary nodes in the cluster and functions as if it were operating against a single centralized Redis server.

The clients returned by this function will not be connected to their associated servers. The caller needs to call connect on each client before sending any commands.

Note: For this to work reliably this function needs to be called each time nodes are added or removed from the cluster.

pub fn scan<P>(
    &self,
    pattern: P,
    count: Option<u32>,
    type: Option<ScanType>
) -> impl Stream<Item = Result<ScanResult, RedisError>> where
    P: Into<Str>, 

Incrementally iterate over a set of keys matching the pattern argument, returning count results per page, if specified.

The scan operation can be canceled by dropping the returned stream.

Note: scanning data in a cluster can be tricky. To make this easier this function supports hash tags in the pattern so callers can direct scanning operations to specific nodes in the cluster. Callers can also use split_cluster with this function if hash tags are not used in the keys that should be scanned.

https://redis.io/commands/scan

pub fn scan_cluster<P>(
    &self,
    pattern: P,
    count: Option<u32>,
    type: Option<ScanType>
) -> impl Stream<Item = Result<ScanResult, RedisError>> where
    P: Into<Str>, 

Run the SCAN command on each primary/main node in a cluster concurrently.

In order for this function to work reliably the cluster state must not change while scanning. If nodes are added or removed, or hash slots are rebalanced, it may result in missing keys or duplicate keys in the result stream. If callers need to support cluster scanning while the cluster state may change please see split_cluster.

Unlike SCAN, HSCAN, etc, the returned stream may continue even if has_more returns false on a given page of keys.

pub fn hscan<K, P>(
    &self,
    key: K,
    pattern: P,
    count: Option<u32>
) -> impl Stream<Item = Result<HScanResult, RedisError>> where
    K: Into<RedisKey>,
    P: Into<Str>, 

Incrementally iterate over pages of the hash map stored at key, returning count results per page, if specified.

https://redis.io/commands/hscan

pub fn sscan<K, P>(
    &self,
    key: K,
    pattern: P,
    count: Option<u32>
) -> impl Stream<Item = Result<SScanResult, RedisError>> where
    K: Into<RedisKey>,
    P: Into<Str>, 

Incrementally iterate over pages of the set stored at key, returning count results per page, if specified.

https://redis.io/commands/sscan

pub fn zscan<K, P>(
    &self,
    key: K,
    pattern: P,
    count: Option<u32>
) -> impl Stream<Item = Result<ZScanResult, RedisError>> where
    K: Into<RedisKey>,
    P: Into<Str>, 

Incrementally iterate over pages of the sorted set stored at key, returning count results per page, if specified.

https://redis.io/commands/zscan

Trait Implementations

impl AclInterface for RedisClient

fn acl_setuser<S>(&self, username: S, rules: Vec<AclRule>) -> AsyncResult<()> where
    S: Into<Str>, 

Create an ACL user with the specified rules or modify the rules of an existing user.

fn acl_load(&self) -> AsyncResult<()>

When Redis is configured to use an ACL file (with the aclfile configuration option), this command will reload the ACLs from the file, replacing all the current ACL rules with the ones defined in the file.

fn acl_save(&self) -> AsyncResult<()>

When Redis is configured to use an ACL file (with the aclfile configuration option), this command will save the currently defined ACLs from the server memory to the ACL file.

fn acl_list<R>(&self) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send, 

The command shows the currently active ACL rules in the Redis server.

fn acl_users<R>(&self) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send, 

The command shows a list of all the usernames of the currently configured users in the Redis ACL system.

fn acl_getuser<S>(&self, username: S) -> AsyncResult<Option<AclUser>> where
    S: Into<Str>, 

The command returns all the rules defined for an existing ACL user.

fn acl_deluser<R, S>(&self, usernames: S) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    S: Into<MultipleStrings>, 

Delete all the specified ACL users and terminate all the connections that are authenticated with such users.

fn acl_cat(&self, category: Option<Str>) -> AsyncResult<Vec<String>>

The command shows the available ACL categories if called without arguments. If a category name is given, the command shows all the Redis commands in the specified category.

fn acl_genpass(&self, bits: Option<u16>) -> AsyncResult<String>

Generate a password with length bits, returning the password.

fn acl_whoami(&self) -> AsyncResult<String>

Return the username the current connection is authenticated with. New connections are authenticated with the “default” user.

fn acl_log_count(&self, count: Option<u32>) -> AsyncResult<RedisValue>

Read count recent ACL security events.

fn acl_log_reset(&self) -> AsyncResult<()>

Clear the ACL security events logs.

impl AuthInterface for RedisClient

fn auth<S>(&self, username: Option<String>, password: S) -> AsyncResult<()> where
    S: Into<Str>, 

Request for authentication in a password-protected Redis server. Returns ok if successful.

fn hello(
    &self,
    version: RespVersion,
    auth: Option<(String, String)>
) -> AsyncResult<()>

Switch to a different protocol, optionally authenticating in the process.

impl ClientInterface for RedisClient

fn client_id<R>(&self) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send, 

Return the ID of the current connection.

fn connection_ids(&self) -> AsyncResult<HashMap<Arc<String>, i64>>

Read the connection IDs for the active connections to each server.

fn update_sentinel_nodes(&self) -> AsyncResult<()>

Force update the client’s sentinel nodes list if using the sentinel interface.

fn client_info<R>(&self) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send, 

The command returns information and statistics about the current client connection in a mostly human readable format.

fn client_kill<R>(&self, filters: Vec<ClientKillFilter>) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send, 

Close a given connection or set of connections.

fn client_list<R, I>(
    &self,
    type: Option<ClientKillType>,
    ids: Option<Vec<String>>
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send, 

The CLIENT LIST command returns information and statistics about the client connections server in a mostly human readable format.

fn client_getname<R>(&self) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send, 

The CLIENT GETNAME returns the name of the current connection as set by CLIENT SETNAME.

fn client_setname<S>(&self, name: S) -> AsyncResult<()> where
    S: Into<Str>, 

Assign a name to the current connection.

fn client_pause(
    &self,
    timeout: i64,
    mode: Option<ClientPauseKind>
) -> AsyncResult<()>

CLIENT PAUSE is a connections control command able to suspend all the Redis clients for the specified amount of time (in milliseconds).

fn client_unpause(&self) -> AsyncResult<()>

CLIENT UNPAUSE is used to resume command processing for all clients that were paused by CLIENT PAUSE.

fn client_reply(&self, flag: ClientReplyFlag) -> AsyncResult<()>

The CLIENT REPLY command controls whether the server will reply the client’s commands. The following modes are available:

fn client_unblock<R, S>(
    &self,
    id: S,
    flag: Option<ClientUnblockFlag>
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    S: Into<RedisValue>, 

This command can unblock, from a different connection, a client blocked in a blocking operation, such as for instance BRPOP or XREAD or WAIT.

fn unblock_self(&self, flag: Option<ClientUnblockFlag>) -> AsyncResult<()>

A convenience function to unblock any blocked connection on this client.

impl ClientLike for RedisClient

fn id(&self) -> &Arc<String>

The unique ID identifying this client and underlying connections.

fn client_config(&self) -> RedisConfig

Read the config used to initialize the client.

fn client_reconnect_policy(&self) -> Option<ReconnectPolicy>

Read the reconnect policy used to initialize the client.

fn protocol_version(&self) -> RespVersion

Read the RESP version used by the client when communicating with the server.

fn has_reconnect_policy(&self) -> bool

Whether or not the client has a reconnection policy.

fn is_pipelined(&self) -> bool

Whether or not the client will automatically pipeline commands.

fn update_perf_config(&self, config: PerformanceConfig)

Update the internal PerformanceConfig in place with new values.

fn state(&self) -> ClientState

Read the state of the underlying connection(s).

fn is_connected(&self) -> bool

Whether or not the client has an active connection to the server(s).

fn connect(&self, policy: Option<ReconnectPolicy>) -> ConnectHandle

Connect to the Redis server with an optional reconnection policy.

fn wait_for_connect(&self) -> AsyncResult<()>

Wait for the client to connect to the server, or return an error if the initial connection cannot be established. If the client is already connected this future will resolve immediately.

fn on_error(&self) -> AsyncStream<RedisError>

Listen for protocol and connection errors. This stream can be used to more intelligently handle errors that may not appear in the request-response cycle, and so cannot be handled by response futures.

fn quit(&self) -> AsyncResult<()>

Close the connection to the Redis server. The returned future resolves when the command has been written to the socket, not when the connection has been fully closed. Some time after this future resolves the future returned by connect will resolve which indicates that the connection has been fully closed.

fn shutdown(&self, flags: Option<ShutdownFlags>) -> AsyncResult<()>

Shut down the server and quit the client.

fn ping(&self) -> AsyncResult<()>

Ping the Redis server.

fn info<R>(&self, section: Option<InfoKind>) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send, 

Read info about the server.

fn custom<R, T>(&self, cmd: CustomCommand, args: Vec<T>) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    T: TryInto<RedisValue>,
    T::Error: Into<RedisError>, 

Run a custom command that is not yet supported via another interface on this client. This is most useful when interacting with third party modules or extensions.

fn custom_raw<T>(
    &self,
    cmd: CustomCommand,
    args: Vec<T>
) -> AsyncResult<Resp3Frame> where
    T: TryInto<RedisValue>,
    T::Error: Into<RedisError>, 

Run a custom command similar to custom, but return the response frame directly without any parsing.

impl Clone for RedisClient

fn clone(&self) -> RedisClient

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl ClusterInterface for RedisClient

fn is_clustered(&self) -> bool

Whether or not the client is using a clustered Redis deployment.

fn cached_cluster_state(&self) -> Option<ClusterKeyCache>

Read the cached state of the cluster used for routing commands to the correct cluster nodes.

fn cluster_bumpepoch<R>(&self) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send, 

Advances the cluster config epoch.

fn cluster_flushslots(&self) -> AsyncResult<()>

Deletes all slots from a node.

fn cluster_myid<R>(&self) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send, 

Returns the node’s id.

fn cluster_nodes(&self) -> AsyncResult<String>

Read the current cluster node configuration.

fn cluster_saveconfig(&self) -> AsyncResult<()>

Forces a node to save the nodes.conf configuration on disk.

fn cluster_slots(&self) -> AsyncResult<RedisValue>

CLUSTER SLOTS returns details about which cluster slots map to which Redis instances.

fn cluster_info(&self) -> AsyncResult<ClusterInfo>

CLUSTER INFO provides INFO style information about Redis Cluster vital parameters.

fn cluster_add_slots<S>(&self, slots: S) -> AsyncResult<()> where
    S: Into<MultipleHashSlots>, 

This command is useful in order to modify a node’s view of the cluster configuration. Specifically it assigns a set of hash slots to the node receiving the command.

fn cluster_count_failure_reports<R, S>(&self, node_id: S) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    S: Into<Str>, 

The command returns the number of failure reports for the specified node.

fn cluster_count_keys_in_slot<R>(&self, slot: u16) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send, 

Returns the number of keys in the specified Redis Cluster hash slot.

fn cluster_del_slots<S>(&self, slots: S) -> AsyncResult<()> where
    S: Into<MultipleHashSlots>, 

The CLUSTER DELSLOTS command asks a particular Redis Cluster node to forget which master is serving the hash slots specified as arguments.

fn cluster_failover(&self, flag: Option<ClusterFailoverFlag>) -> AsyncResult<()>

This command, that can only be sent to a Redis Cluster replica node, forces the replica to start a manual failover of its master instance.

fn cluster_forget<S>(&self, node_id: S) -> AsyncResult<()> where
    S: Into<Str>, 

The command is used in order to remove a node, specified via its node ID, from the set of known nodes of the Redis Cluster node receiving the command. In other words the specified node is removed from the nodes table of the node receiving the command.

fn cluster_get_keys_in_slot<R>(&self, slot: u16, count: u64) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send, 

The command returns an array of keys names stored in the contacted node and hashing to the specified hash slot.

fn cluster_keyslot<R, K>(&self, key: K) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

Returns an integer identifying the hash slot the specified key hashes to.

fn cluster_meet<S>(&self, ip: S, port: u16) -> AsyncResult<()> where
    S: Into<Str>, 

CLUSTER MEET is used in order to connect different Redis nodes with cluster support enabled, into a working cluster.

fn cluster_replicate<S>(&self, node_id: S) -> AsyncResult<()> where
    S: Into<Str>, 

The command reconfigures a node as a replica of the specified master. If the node receiving the command is an empty master, as a side effect of the command, the node role is changed from master to replica.

fn cluster_replicas<S>(&self, node_id: S) -> AsyncResult<String> where
    S: Into<Str>, 

The command provides a list of replica nodes replicating from the specified master node.

fn cluster_reset(&self, mode: Option<ClusterResetFlag>) -> AsyncResult<()>

Reset a Redis Cluster node, in a more or less drastic way depending on the reset type, that can be hard or soft. Note that this command does not work for masters if they hold one or more keys, in that case to completely reset a master node keys must be removed first, e.g. by using FLUSHALL first, and then CLUSTER RESET.

fn cluster_set_config_epoch(&self, epoch: u64) -> AsyncResult<()>

This command sets a specific config epoch in a fresh node.

fn cluster_setslot(
    &self,
    slot: u16,
    state: ClusterSetSlotState
) -> AsyncResult<()>

CLUSTER SETSLOT is responsible of changing the state of a hash slot in the receiving node in different ways.

impl ConfigInterface for RedisClient

fn config_resetstat(&self) -> AsyncResult<()>

Resets the statistics reported by Redis using the INFO command.

fn config_rewrite(&self) -> AsyncResult<()>

The CONFIG REWRITE command rewrites the redis.conf file the server was started with, applying the minimal changes needed to make it reflect the configuration currently used by the server, which may be different compared to the original one because of the use of the CONFIG SET command.

fn config_get<R, S>(&self, parameter: S) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    S: Into<Str>, 

The CONFIG GET command is used to read the configuration parameters of a running Redis server.

fn config_set<P, V>(&self, parameter: P, value: V) -> AsyncResult<()> where
    P: Into<Str>,
    V: TryInto<RedisValue>,
    V::Error: Into<RedisError>, 

The CONFIG SET command is used in order to reconfigure the server at run time without the need to restart Redis.

impl Display for RedisClient

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> From<&'a RedisPool> for &'a RedisClient

fn from(p: &'a RedisPool) -> &'a RedisClient

Converts to this type from the input type.

impl<'a> From<&'a RedisPool> for RedisClient

fn from(p: &'a RedisPool) -> RedisClient

Converts to this type from the input type.

impl GeoInterface for RedisClient

fn geoadd<R, K, V>(
    &self,
    key: K,
    options: Option<SetOptions>,
    changed: bool,
    values: V
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    V: Into<MultipleGeoValues>, 

Adds the specified geospatial items (longitude, latitude, name) to the specified key.

fn geohash<R, K, V>(&self, key: K, members: V) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    V: TryInto<MultipleValues>,
    V::Error: Into<RedisError>, 

Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).

fn geopos<K, V>(&self, key: K, members: V) -> AsyncResult<RedisValue> where
    K: Into<RedisKey>,
    V: TryInto<MultipleValues>,
    V::Error: Into<RedisError>, 

Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.

fn geodist<R, K, S, D>(
    &self,
    key: K,
    src: S,
    dest: D,
    unit: Option<GeoUnit>
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    S: TryInto<RedisValue>,
    S::Error: Into<RedisError>,
    D: TryInto<RedisValue>,
    D::Error: Into<RedisError>, 

Return the distance between two members in the geospatial index represented by the sorted set.

fn georadius<K, P>(
    &self,
    key: K,
    position: P,
    radius: f64,
    unit: GeoUnit,
    withcoord: bool,
    withdist: bool,
    withhash: bool,
    count: Option<(u64, Any)>,
    ord: Option<SortOrder>,
    store: Option<RedisKey>,
    storedist: Option<RedisKey>
) -> AsyncResult<Vec<GeoRadiusInfo>> where
    K: Into<RedisKey>,
    P: Into<GeoPosition>, 

Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).

fn georadiusbymember<K, V>(
    &self,
    key: K,
    member: V,
    radius: f64,
    unit: GeoUnit,
    withcoord: bool,
    withdist: bool,
    withhash: bool,
    count: Option<(u64, Any)>,
    ord: Option<SortOrder>,
    store: Option<RedisKey>,
    storedist: Option<RedisKey>
) -> AsyncResult<Vec<GeoRadiusInfo>> where
    K: Into<RedisKey>,
    V: TryInto<RedisValue>,
    V::Error: Into<RedisError>, 

This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.

fn geosearch<K>(
    &self,
    key: K,
    from_member: Option<RedisValue>,
    from_lonlat: Option<GeoPosition>,
    by_radius: Option<(f64, GeoUnit)>,
    by_box: Option<(f64, f64, GeoUnit)>,
    ord: Option<SortOrder>,
    count: Option<(u64, Any)>,
    withcoord: bool,
    withdist: bool,
    withhash: bool
) -> AsyncResult<Vec<GeoRadiusInfo>> where
    K: Into<RedisKey>, 

Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified by a given shape.

fn geosearchstore<R, D, S>(
    &self,
    dest: D,
    source: S,
    from_member: Option<RedisValue>,
    from_lonlat: Option<GeoPosition>,
    by_radius: Option<(f64, GeoUnit)>,
    by_box: Option<(f64, f64, GeoUnit)>,
    ord: Option<SortOrder>,
    count: Option<(u64, Any)>,
    storedist: bool
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    D: Into<RedisKey>,
    S: Into<RedisKey>, 

This command is like GEOSEARCH, but stores the result in destination key. Returns the number of members added to the destination key.

impl HashesInterface for RedisClient

fn hgetall<R, K>(&self, key: K) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

Returns all fields and values of the hash stored at key.

fn hdel<R, K, F>(&self, key: K, fields: F) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    F: Into<MultipleKeys>, 

Removes the specified fields from the hash stored at key.

fn hexists<R, K, F>(&self, key: K, field: F) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    F: Into<RedisKey>, 

Returns if field is an existing field in the hash stored at key.

fn hget<R, K, F>(&self, key: K, field: F) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    F: Into<RedisKey>, 

Returns the value associated with field in the hash stored at key.

fn hincrby<R, K, F>(&self, key: K, field: F, increment: i64) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    F: Into<RedisKey>, 

Increments the number stored at field in the hash stored at key by increment.

fn hincrbyfloat<R, K, F>(
    &self,
    key: K,
    field: F,
    increment: f64
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    F: Into<RedisKey>, 

Increment the specified field of a hash stored at key, and representing a floating point number, by the specified increment.

fn hkeys<R, K>(&self, key: K) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

Returns all field names in the hash stored at key.

fn hlen<R, K>(&self, key: K) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

Returns the number of fields contained in the hash stored at key.

fn hmget<R, K, F>(&self, key: K, fields: F) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    F: Into<MultipleKeys>, 

Returns the values associated with the specified fields in the hash stored at key.

fn hmset<R, K, V>(&self, key: K, values: V) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    V: TryInto<RedisMap>,
    V::Error: Into<RedisError>, 

Sets the specified fields to their respective values in the hash stored at key.

fn hset<R, K, V>(&self, key: K, values: V) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    V: TryInto<RedisMap>,
    V::Error: Into<RedisError>, 

Sets fields in the hash stored at key to their provided values.

fn hsetnx<R, K, F, V>(&self, key: K, field: F, value: V) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    F: Into<RedisKey>,
    V: TryInto<RedisValue>,
    V::Error: Into<RedisError>, 

Sets field in the hash stored at key to value, only if field does not yet exist.

fn hrandfield<R, K>(&self, key: K, count: Option<(i64, bool)>) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

When called with just the key argument, return a random field from the hash value stored at key.

fn hstrlen<R, K, F>(&self, key: K, field: F) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    F: Into<RedisKey>, 

Returns the string length of the value associated with field in the hash stored at key.

fn hvals<R, K>(&self, key: K) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

Returns all values in the hash stored at key.

impl HeartbeatInterface for RedisClient

fn enable_heartbeat(
    &self,
    interval: Duration,
    break_on_error: bool
) -> AsyncResult<()>

Return a future that will ping the server on an interval.

impl HyperloglogInterface for RedisClient

fn pfadd<R, K, V>(&self, key: K, elements: V) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    V: TryInto<MultipleValues>,
    V::Error: Into<RedisError>, 

Adds all the element arguments to the HyperLogLog data structure stored at the variable name specified as first argument.

fn pfcount<R, K>(&self, keys: K) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<MultipleKeys>, 

When called with a single key, returns the approximated cardinality computed by the HyperLogLog data structure stored at the specified variable, which is 0 if the variable does not exist.

fn pfmerge<R, D, S>(&self, dest: D, sources: S) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    D: Into<RedisKey>,
    S: Into<MultipleKeys>, 

Merge multiple HyperLogLog values into an unique value that will approximate the cardinality of the union of the observed sets of the source HyperLogLog structures.

impl KeysInterface for RedisClient

fn randomkey<R>(&self) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send, 

Return a random key from the currently selected database.

fn copy<R, S, D>(
    &self,
    source: S,
    destination: D,
    db: Option<u8>,
    replace: bool
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    S: Into<RedisKey>,
    D: Into<RedisKey>, 

This command copies the value stored at the source key to the destination key.

fn dump<K>(&self, key: K) -> AsyncResult<RedisValue> where
    K: Into<RedisKey>, 

Serialize the value stored at key in a Redis-specific format and return it as bulk string.

fn restore<K>(
    &self,
    key: K,
    ttl: i64,
    serialized: RedisValue,
    replace: bool,
    absttl: bool,
    idletime: Option<i64>,
    frequency: Option<i64>
) -> AsyncResult<RedisValue> where
    K: Into<RedisKey>, 

Create a key associated with a value that is obtained by deserializing the provided serialized value

fn set<R, K, V>(
    &self,
    key: K,
    value: V,
    expire: Option<Expiration>,
    options: Option<SetOptions>,
    get: bool
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    V: TryInto<RedisValue>,
    V::Error: Into<RedisError>, 

Set a value with optional NX|XX, EX|PX|EXAT|PXAT|KEEPTTL, and GET arguments.

fn get<R, K>(&self, key: K) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

Read a value from the server.

fn getrange<R, K>(&self, key: K, start: usize, end: usize) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

Returns the substring of the string value stored at key with offsets start and end (both inclusive).

fn setrange<R, K, V>(&self, key: K, offset: u32, value: V) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    V: TryInto<RedisValue>,
    V::Error: Into<RedisError>, 

Overwrites part of the string stored at key, starting at the specified offset, for the entire length of value.

fn getset<R, K, V>(&self, key: K, value: V) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    V: TryInto<RedisValue>,
    V::Error: Into<RedisError>, 

Atomically sets key to value and returns the old value stored at key.

fn getdel<R, K>(&self, key: K) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

Get the value of key and delete the key. This command is similar to GET, except for the fact that it also deletes the key on success (if and only if the key’s value type is a string).

fn strlen<R, K>(&self, key: K) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

Returns the length of the string value stored at key. An error is returned when key holds a non-string value.

fn del<R, K>(&self, keys: K) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<MultipleKeys>, 

Removes the specified keys. A key is ignored if it does not exist.

fn mget<R, K>(&self, keys: K) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<MultipleKeys>, 

Returns the values of all specified keys. For every key that does not hold a string value or does not exist, the special value nil is returned.

fn mset<V>(&self, values: V) -> AsyncResult<()> where
    V: TryInto<RedisMap>,
    V::Error: Into<RedisError>, 

Sets the given keys to their respective values.

fn msetnx<R, V>(&self, values: V) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    V: TryInto<RedisMap>,
    V::Error: Into<RedisError>, 

Sets the given keys to their respective values. MSETNX will not perform any operation at all even if just a single key already exists.

fn incr<R, K>(&self, key: K) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

Increments the number stored at key by one. If the key does not exist, it is set to 0 before performing the operation.

fn incr_by<R, K>(&self, key: K, val: i64) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

Increments the number stored at key by val. If the key does not exist, it is set to 0 before performing the operation.

fn incr_by_float<R, K>(&self, key: K, val: f64) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

Increment the string representing a floating point number stored at key by val. If the key does not exist, it is set to 0 before performing the operation.

fn decr<R, K>(&self, key: K) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

Decrements the number stored at key by one. If the key does not exist, it is set to 0 before performing the operation.

fn decr_by<R, K>(&self, key: K, val: i64) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

Decrements the number stored at key by val. If the key does not exist, it is set to 0 before performing the operation.

fn ttl<R, K>(&self, key: K) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

Returns the remaining time to live of a key that has a timeout, in seconds.

fn pttl<R, K>(&self, key: K) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

Returns the remaining time to live of a key that has a timeout, in milliseconds.

fn persist<R, K>(&self, key: K) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

Remove the existing timeout on a key, turning the key from volatile (a key with an expiration) to persistent (a key that will never expire as no timeout is associated).

fn expire<R, K>(&self, key: K, seconds: i64) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

Set a timeout on key. After the timeout has expired, the key will be automatically deleted.

fn expire_at<R, K>(&self, key: K, timestamp: i64) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

Set a timeout on a key based on a UNIX timestamp.

fn exists<R, K>(&self, keys: K) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<MultipleKeys>, 

Returns number of keys that exist from the keys arguments.

impl ListInterface for RedisClient

fn blpop<R, K>(&self, keys: K, timeout: f64) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<MultipleKeys>, 

BLPOP is a blocking list pop primitive. It is the blocking version of LPOP because it blocks the connection when there are no elements to pop from any of the given lists. An element is popped from the head of the first list that is non-empty, with the given keys being checked in the order that they are given.

fn brpop<R, K>(&self, keys: K, timeout: f64) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<MultipleKeys>, 

BRPOP is a blocking list pop primitive. It is the blocking version of RPOP because it blocks the connection when there are no elements to pop from any of the given lists. An element is popped from the tail of the first list that is non-empty, with the given keys being checked in the order that they are given.

fn brpoplpush<R, S, D>(
    &self,
    source: S,
    destination: D,
    timeout: f64
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    S: Into<RedisKey>,
    D: Into<RedisKey>, 

The blocking equivalent of Self::rpoplpush.

fn blmove<R, S, D>(
    &self,
    source: S,
    destination: D,
    source_direction: LMoveDirection,
    destination_direction: LMoveDirection,
    timeout: f64
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    S: Into<RedisKey>,
    D: Into<RedisKey>, 

The blocking equivalent of Self::lmove.

fn lindex<R, K>(&self, key: K, index: i64) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

Returns the element at index index in the list stored at key.

fn linsert<R, K, P, V>(
    &self,
    key: K,
    location: ListLocation,
    pivot: P,
    element: V
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    P: TryInto<RedisValue>,
    P::Error: Into<RedisError>,
    V: TryInto<RedisValue>,
    V::Error: Into<RedisError>, 

Inserts element in the list stored at key either before or after the reference value pivot.

fn llen<R, K>(&self, key: K) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

Returns the length of the list stored at key.

fn lpop<R, K>(&self, key: K, count: Option<usize>) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

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

fn lpos<R, K, V>(
    &self,
    key: K,
    element: V,
    rank: Option<i64>,
    count: Option<i64>,
    maxlen: Option<i64>
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    V: TryInto<RedisValue>,
    V::Error: Into<RedisError>, 

The command returns the index of matching elements inside a Redis list.

fn lpush<R, K, V>(&self, key: K, elements: V) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    V: TryInto<MultipleValues>,
    V::Error: Into<RedisError>, 

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

fn lpushx<R, K, V>(&self, key: K, elements: V) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    V: TryInto<MultipleValues>,
    V::Error: Into<RedisError>, 

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

fn lrange<R, K>(&self, key: K, start: i64, stop: i64) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

Returns the specified elements of the list stored at key.

fn lrem<R, K, V>(&self, key: K, count: i64, element: V) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    V: TryInto<RedisValue>,
    V::Error: Into<RedisError>, 

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

fn lset<R, K, V>(&self, key: K, index: i64, element: V) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    V: TryInto<RedisValue>,
    V::Error: Into<RedisError>, 

Sets the list element at index to element.

fn ltrim<R, K>(&self, key: K, start: i64, stop: i64) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

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

fn rpop<R, K>(&self, key: K, count: Option<usize>) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

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

fn rpoplpush<R, S, D>(&self, source: S, dest: D) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    S: Into<RedisKey>,
    D: Into<RedisKey>, 

Atomically returns and removes the last element (tail) of the list stored at source, and pushes the element at the first element (head) of the list stored at destination.

fn lmove<R, S, D>(
    &self,
    source: S,
    dest: D,
    source_direction: LMoveDirection,
    dest_direction: LMoveDirection
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    S: Into<RedisKey>,
    D: Into<RedisKey>, 

Atomically returns and removes the first/last element (head/tail depending on the source direction argument) of the list stored at source, and pushes the element at the first/last element (head/tail depending on the destination direction argument) of the list stored at destination.

fn rpush<R, K, V>(&self, key: K, elements: V) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    V: TryInto<MultipleValues>,
    V::Error: Into<RedisError>, 

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

fn rpushx<R, K, V>(&self, key: K, elements: V) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    V: TryInto<MultipleValues>,
    V::Error: Into<RedisError>, 

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

impl LuaInterface for RedisClient

fn script_load<S>(&self, script: S) -> AsyncResult<String> where
    S: Into<Str>, 

Load a script into the scripts cache, without executing it. After the specified command is loaded into the script cache it will be callable using EVALSHA with the correct SHA1 digest of the script.

fn script_load_cluster<S>(&self, script: S) -> AsyncResult<String> where
    S: Into<Str>, 

A clustered variant of script_load that loads the script on all primary nodes in a cluster.

fn script_kill(&self) -> AsyncResult<()>

Kills the currently executing Lua script, assuming no write operation was yet performed by the script.

fn script_kill_cluster(&self) -> AsyncResult<()>

A clustered variant of the script_kill command that issues the command to all primary nodes in the cluster.

fn script_flush(&self, async: bool) -> AsyncResult<()>

Flush the Lua scripts cache.

fn script_flush_cluster(&self, async: bool) -> AsyncResult<()>

A clustered variant of script_flush that flushes the script cache on all primary nodes in the cluster.

fn script_exists<H>(&self, hashes: H) -> AsyncResult<Vec<bool>> where
    H: Into<MultipleStrings>, 

Returns information about the existence of the scripts in the script cache.

fn script_debug(&self, flag: ScriptDebugFlag) -> AsyncResult<()>

Set the debug mode for subsequent scripts executed with EVAL.

fn evalsha<R, S, K, V>(&self, hash: S, keys: K, args: V) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    S: Into<Str>,
    K: Into<MultipleKeys>,
    V: TryInto<MultipleValues>,
    V::Error: Into<RedisError>, 

Evaluates a script cached on the server side by its SHA1 digest.

fn eval<R, S, K, V>(&self, script: S, keys: K, args: V) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    S: Into<Str>,
    K: Into<MultipleKeys>,
    V: TryInto<MultipleValues>,
    V::Error: Into<RedisError>, 

Evaluate a Lua script on the server.

impl MemoryInterface for RedisClient

fn memory_doctor(&self) -> AsyncResult<String>

The MEMORY DOCTOR command reports about different memory-related issues that the Redis server experiences, and advises about possible remedies.

fn memory_malloc_stats(&self) -> AsyncResult<String>

The MEMORY MALLOC-STATS command provides an internal statistics report from the memory allocator.

fn memory_purge(&self) -> AsyncResult<()>

The MEMORY PURGE command attempts to purge dirty pages so these can be reclaimed by the allocator.

fn memory_stats(&self) -> AsyncResult<MemoryStats>

The MEMORY STATS command returns an Array reply about the memory usage of the server.

fn memory_usage<K>(
    &self,
    key: K,
    samples: Option<u32>
) -> AsyncResult<Option<u64>> where
    K: Into<RedisKey>, 

The MEMORY USAGE command reports the number of bytes that a key and its value require to be stored in RAM.

impl MetricsInterface for RedisClient

fn read_redelivery_count(&self) -> usize

Read the number of request redeliveries.

fn take_redelivery_count(&self) -> usize

Read and reset the number of request redeliveries.

fn command_queue_len(&self) -> usize

Read the number of buffered commands that have not yet been sent to the server.

fn read_latency_metrics(&self) -> Stats

Available on crate feature metrics only.

Read latency metrics across all commands.

fn take_latency_metrics(&self) -> Stats

Available on crate feature metrics only.

Read and consume latency metrics, resetting their values afterwards.

fn read_network_latency_metrics(&self) -> Stats

Available on crate feature metrics only.

Read network latency metrics across all commands.

fn take_network_latency_metrics(&self) -> Stats

Available on crate feature metrics only.

Read and consume network latency metrics, resetting their values afterwards.

fn read_req_size_metrics(&self) -> Stats

Available on crate feature metrics only.

Read request payload size metrics across all commands.

fn take_req_size_metrics(&self) -> Stats

Available on crate feature metrics only.

Read and consume request payload size metrics, resetting their values afterwards.

fn read_res_size_metrics(&self) -> Stats

Available on crate feature metrics only.

Read response payload size metrics across all commands.

fn take_res_size_metrics(&self) -> Stats

Available on crate feature metrics only.

Read and consume response payload size metrics, resetting their values afterwards.

impl PubsubInterface for RedisClient

fn on_message(&self) -> AsyncStream<(String, RedisValue)>

Listen for (channel, message) tuples on the publish-subscribe interface. Keyspace events are not sent on this interface.

fn on_keyspace_event(&self) -> AsyncStream<KeyspaceEvent>

Listen for keyspace and keyevent notifications on the publish subscribe interface.

fn subscribe<S>(&self, channel: S) -> AsyncResult<usize> where
    S: Into<Str>, 

Subscribe to a channel on the PubSub interface, returning the number of channels to which the client is subscribed.

fn unsubscribe<S>(&self, channel: S) -> AsyncResult<usize> where
    S: Into<Str>, 

Unsubscribe from a channel on the PubSub interface, returning the number of channels to which hte client is subscribed.

fn psubscribe<S>(&self, patterns: S) -> AsyncResult<Vec<usize>> where
    S: Into<MultipleStrings>, 

Subscribes the client to the given patterns.

fn punsubscribe<S>(&self, patterns: S) -> AsyncResult<Vec<usize>> where
    S: Into<MultipleStrings>, 

Unsubscribes the client from the given patterns, or from all of them if none is given.

fn publish<R, S, V>(&self, channel: S, message: V) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    S: Into<Str>,
    V: TryInto<RedisValue>,
    V::Error: Into<RedisError>, 

Publish a message on the PubSub interface, returning the number of clients that received the message.

impl ServerInterface for RedisClient

fn bgrewriteaof<R>(&self) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send, 

Instruct Redis to start an Append Only File rewrite process.

fn bgsave<R>(&self) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send, 

Save the DB in background.

fn dbsize<R>(&self) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send, 

Return the number of keys in the selected database.

fn flushall<R>(&self, async: bool) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send, 

Delete the keys in all databases.

fn flushall_cluster(&self) -> AsyncResult<()>

Delete the keys on all nodes in the cluster. This is a special function that does not map directly to the Redis interface.

fn select(&self, db: u8) -> AsyncResult<()>

Select the database this client should use.

fn failover(
    &self,
    to: Option<(String, u16)>,
    force: bool,
    abort: bool,
    timeout: Option<u32>
) -> AsyncResult<()>

This command will start a coordinated failover between the currently-connected-to master and one of its replicas.

fn lastsave<R>(&self) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send, 

Return the UNIX TIME of the last DB save executed with success.

impl SetsInterface for RedisClient

fn sadd<R, K, V>(&self, key: K, members: V) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    V: TryInto<MultipleValues>,
    V::Error: Into<RedisError>, 

Add the specified members to the set stored at key.

fn scard<R, K>(&self, key: K) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

Returns the set cardinality (number of elements) of the set stored at key.

fn sdiff<R, K>(&self, keys: K) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<MultipleKeys>, 

Returns the members of the set resulting from the difference between the first set and all the successive sets.

fn sdiffstore<R, D, K>(&self, dest: D, keys: K) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    D: Into<RedisKey>,
    K: Into<MultipleKeys>, 

This command is equal to SDIFF, but instead of returning the resulting set, it is stored in destination.

fn sinter<R, K>(&self, keys: K) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<MultipleKeys>, 

Returns the members of the set resulting from the intersection of all the given sets.

fn sinterstore<R, D, K>(&self, dest: D, keys: K) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    D: Into<RedisKey>,
    K: Into<MultipleKeys>, 

This command is equal to SINTER, but instead of returning the resulting set, it is stored in destination.

fn sismember<R, K, V>(&self, key: K, member: V) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    V: TryInto<RedisValue>,
    V::Error: Into<RedisError>, 

Returns if member is a member of the set stored at key.

fn smismember<R, K, V>(&self, key: K, members: V) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    V: TryInto<MultipleValues>,
    V::Error: Into<RedisError>, 

Returns whether each member is a member of the set stored at key.

fn smembers<R, K>(&self, key: K) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

Returns all the members of the set value stored at key.

fn smove<R, S, D, V>(&self, source: S, dest: D, member: V) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    S: Into<RedisKey>,
    D: Into<RedisKey>,
    V: TryInto<RedisValue>,
    V::Error: Into<RedisError>, 

Move member from the set at source to the set at destination.

fn spop<R, K>(&self, key: K, count: Option<usize>) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

Removes and returns one or more random members from the set value store at key.

fn srandmember<R, K>(&self, key: K, count: Option<usize>) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

When called with just the key argument, return a random element from the set value stored at key.

fn srem<R, K, V>(&self, key: K, members: V) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    V: TryInto<MultipleValues>,
    V::Error: Into<RedisError>, 

Remove the specified members from the set stored at key.

fn sunion<R, K>(&self, keys: K) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<MultipleKeys>, 

Returns the members of the set resulting from the union of all the given sets.

fn sunionstore<R, D, K>(&self, dest: D, keys: K) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    D: Into<RedisKey>,
    K: Into<MultipleKeys>, 

This command is equal to SUNION, but instead of returning the resulting set, it is stored in destination.

impl SlowlogInterface for RedisClient

fn slowlog_get(&self, count: Option<i64>) -> AsyncResult<Vec<SlowlogEntry>>

This command is used to read the slow queries log.

fn slowlog_length(&self) -> AsyncResult<u64>

This command is used to read length of the slow queries log.

fn slowlog_reset(&self) -> AsyncResult<()>

This command is used to reset the slow queries log.

impl SortedSetsInterface for RedisClient

fn bzpopmin<R, K>(&self, keys: K, timeout: f64) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<MultipleKeys>, 

The blocking variant of the ZPOPMIN command.

fn bzpopmax<R, K>(&self, keys: K, timeout: f64) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<MultipleKeys>, 

The blocking variant of the ZPOPMAX command.

fn zadd<R, K, V>(
    &self,
    key: K,
    options: Option<SetOptions>,
    ordering: Option<Ordering>,
    changed: bool,
    incr: bool,
    values: V
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    V: TryInto<MultipleZaddValues>,
    V::Error: Into<RedisError>, 

Adds all the specified members with the specified scores to the sorted set stored at key.

fn zcard<R, K>(&self, key: K) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

Returns the sorted set cardinality (number of elements) of the sorted set stored at key.

fn zcount<R, K>(&self, key: K, min: f64, max: f64) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

Returns the number of elements in the sorted set at key with a score between min and max.

fn zdiff<R, K>(&self, keys: K, withscores: bool) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<MultipleKeys>, 

This command is similar to ZDIFFSTORE, but instead of storing the resulting sorted set, it is returned to the client.

fn zdiffstore<R, D, K>(&self, dest: D, keys: K) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    D: Into<RedisKey>,
    K: Into<MultipleKeys>, 

Computes the difference between the first and all successive input sorted sets and stores the result in destination.

fn zincrby<R, K, V>(&self, key: K, increment: f64, member: V) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    V: TryInto<RedisValue>,
    V::Error: Into<RedisError>, 

Increments the score of member in the sorted set stored at key by increment.

fn zinter<R, K, W>(
    &self,
    keys: K,
    weights: W,
    aggregate: Option<AggregateOptions>,
    withscores: bool
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<MultipleKeys>,
    W: Into<MultipleWeights>, 

This command is similar to ZINTERSTORE, but instead of storing the resulting sorted set, it is returned to the client.

fn zinterstore<R, D, K, W>(
    &self,
    dest: D,
    keys: K,
    weights: W,
    aggregate: Option<AggregateOptions>
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    D: Into<RedisKey>,
    K: Into<MultipleKeys>,
    W: Into<MultipleWeights>, 

Computes the intersection of the sorted sets given by the specified keys, and stores the result in destination.

fn zlexcount<R, K, M, N>(&self, key: K, min: M, max: N) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    M: TryInto<ZRange>,
    M::Error: Into<RedisError>,
    N: TryInto<ZRange>,
    N::Error: Into<RedisError>, 

When all the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering, this command returns the number of elements in the sorted set at key with a value between min and max.

fn zpopmax<R, K>(&self, key: K, count: Option<usize>) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

Removes and returns up to count members with the highest scores in the sorted set stored at key.

fn zpopmin<R, K>(&self, key: K, count: Option<usize>) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

Removes and returns up to count members with the lowest scores in the sorted set stored at key.

fn zrandmember<R, K>(
    &self,
    key: K,
    count: Option<(i64, bool)>
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

When called with just the key argument, return a random element from the sorted set value stored at key.

fn zrangestore<R, D, S, M, N>(
    &self,
    dest: D,
    source: S,
    min: M,
    max: N,
    sort: Option<ZSort>,
    rev: bool,
    limit: Option<Limit>
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    D: Into<RedisKey>,
    S: Into<RedisKey>,
    M: TryInto<ZRange>,
    M::Error: Into<RedisError>,
    N: TryInto<ZRange>,
    N::Error: Into<RedisError>, 

This command is like ZRANGE, but stores the result in the destination key.

fn zrange<R, K, M, N>(
    &self,
    key: K,
    min: M,
    max: N,
    sort: Option<ZSort>,
    rev: bool,
    limit: Option<Limit>,
    withscores: bool
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    M: TryInto<ZRange>,
    M::Error: Into<RedisError>,
    N: TryInto<ZRange>,
    N::Error: Into<RedisError>, 

Returns the specified range of elements in the sorted set stored at key.

fn zrangebylex<R, K, M, N>(
    &self,
    key: K,
    min: M,
    max: N,
    limit: Option<Limit>
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    M: TryInto<ZRange>,
    M::Error: Into<RedisError>,
    N: TryInto<ZRange>,
    N::Error: Into<RedisError>, 

When all the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering, this command returns all the elements in the sorted set at key with a value between min and max.

fn zrevrangebylex<R, K, M, N>(
    &self,
    key: K,
    max: M,
    min: N,
    limit: Option<Limit>
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    M: TryInto<ZRange>,
    M::Error: Into<RedisError>,
    N: TryInto<ZRange>,
    N::Error: Into<RedisError>, 

When all the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering, this command returns all the elements in the sorted set at key with a value between max and min.

fn zrangebyscore<R, K, M, N>(
    &self,
    key: K,
    min: M,
    max: N,
    withscores: bool,
    limit: Option<Limit>
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    M: TryInto<ZRange>,
    M::Error: Into<RedisError>,
    N: TryInto<ZRange>,
    N::Error: Into<RedisError>, 

Returns all the elements in the sorted set at key with a score between min and max (including elements with score equal to min or max).

fn zrevrangebyscore<R, K, M, N>(
    &self,
    key: K,
    max: M,
    min: N,
    withscores: bool,
    limit: Option<Limit>
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    M: TryInto<ZRange>,
    M::Error: Into<RedisError>,
    N: TryInto<ZRange>,
    N::Error: Into<RedisError>, 

Returns all the elements in the sorted set at key with a score between max and min (including elements with score equal to max or min).

fn zrank<R, K, V>(&self, key: K, member: V) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    V: TryInto<RedisValue>,
    V::Error: Into<RedisError>, 

Returns the rank of member in the sorted set stored at key, with the scores ordered from low to high.

fn zrem<R, K, V>(&self, key: K, members: V) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    V: TryInto<MultipleValues>,
    V::Error: Into<RedisError>, 

Removes the specified members from the sorted set stored at key. Non existing members are ignored.

fn zremrangebylex<R, K, M, N>(&self, key: K, min: M, max: N) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    M: TryInto<ZRange>,
    M::Error: Into<RedisError>,
    N: TryInto<ZRange>,
    N::Error: Into<RedisError>, 

When all the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering, this command removes all elements in the sorted set stored at key between the lexicographical range specified by min and max.

fn zremrangebyrank<R, K>(&self, key: K, start: i64, stop: i64) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

Removes all elements in the sorted set stored at key with rank between start and stop.

fn zremrangebyscore<R, K, M, N>(&self, key: K, min: M, max: N) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    M: TryInto<ZRange>,
    M::Error: Into<RedisError>,
    N: TryInto<ZRange>,
    N::Error: Into<RedisError>, 

Removes all elements in the sorted set stored at key with a score between min and max.

fn zrevrange<R, K>(
    &self,
    key: K,
    start: i64,
    stop: i64,
    withscores: bool
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

Returns the specified range of elements in the sorted set stored at key.

fn zrevrank<R, K, V>(&self, key: K, member: V) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    V: TryInto<RedisValue>,
    V::Error: Into<RedisError>, 

Returns the rank of member in the sorted set stored at key, with the scores ordered from high to low.

fn zscore<R, K, V>(&self, key: K, member: V) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    V: TryInto<RedisValue>,
    V::Error: Into<RedisError>, 

Returns the score of member in the sorted set at key.

fn zunion<K, W>(
    &self,
    keys: K,
    weights: W,
    aggregate: Option<AggregateOptions>,
    withscores: bool
) -> AsyncResult<RedisValue> where
    K: Into<MultipleKeys>,
    W: Into<MultipleWeights>, 

This command is similar to ZUNIONSTORE, but instead of storing the resulting sorted set, it is returned to the client.

fn zunionstore<R, D, K, W>(
    &self,
    dest: D,
    keys: K,
    weights: W,
    aggregate: Option<AggregateOptions>
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    D: Into<RedisKey>,
    K: Into<MultipleKeys>,
    W: Into<MultipleWeights>, 

Computes the union of the sorted sets given by the specified keys, and stores the result in destination.

fn zmscore<R, K, V>(&self, key: K, members: V) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    V: TryInto<MultipleValues>,
    V::Error: Into<RedisError>, 

Returns the scores associated with the specified members in the sorted set stored at key.

impl StreamsInterface for RedisClient

fn xinfo_consumers<R, K, S>(&self, key: K, groupname: S) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    S: Into<Str>, 

This command returns the list of consumers that belong to the groupname consumer group of the stream stored at key.

fn xinfo_groups<R, K>(&self, key: K) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

This command returns the list of all consumers groups of the stream stored at key.

fn xinfo_stream<R, K>(
    &self,
    key: K,
    full: bool,
    count: Option<u64>
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

This command returns information about the stream stored at key.

fn xadd<R, K, C, I, F>(
    &self,
    key: K,
    nomkstream: bool,
    cap: C,
    id: I,
    fields: F
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    I: Into<XID>,
    F: TryInto<MultipleOrderedPairs>,
    F::Error: Into<RedisError>,
    C: TryInto<XCap>,
    C::Error: Into<RedisError>, 

Appends the specified stream entry to the stream at the specified key. If the key does not exist, as a side effect of running this command the key is created with a stream value. The creation of stream’s key can be disabled with the NOMKSTREAM option.

fn xtrim<R, K, C>(&self, key: K, cap: C) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    C: TryInto<XCap>,
    C::Error: Into<RedisError>, 

Trims the stream by evicting older entries (entries with lower IDs) if needed.

fn xdel<R, K, S>(&self, key: K, ids: S) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    S: Into<MultipleStrings>, 

Removes the specified entries from a stream, and returns the number of entries deleted.

fn xrange_values<Ri, Rk, Rv, K, S, E>(
    &self,
    key: K,
    start: S,
    end: E,
    count: Option<u64>
) -> AsyncResult<Vec<XReadValue<Ri, Rk, Rv>>> where
    Ri: FromRedis + Unpin + Send,
    Rk: FromRedisKey + Hash + Eq + Unpin + Send,
    Rv: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    S: TryInto<RedisValue>,
    S::Error: Into<RedisError>,
    E: TryInto<RedisValue>,
    E::Error: Into<RedisError>, 

Return the stream entries matching the provided range of IDs, automatically converting to a less verbose type definition.

fn xrange<R, K, S, E>(
    &self,
    key: K,
    start: S,
    end: E,
    count: Option<u64>
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    S: TryInto<RedisValue>,
    S::Error: Into<RedisError>,
    E: TryInto<RedisValue>,
    E::Error: Into<RedisError>, 

The command returns the stream entries matching a given range of IDs. The range is specified by a minimum and maximum ID. All the entries having an ID between the two specified or exactly one of the two IDs specified (closed interval) are returned.

fn xrevrange_values<Ri, Rk, Rv, K, E, S>(
    &self,
    key: K,
    end: E,
    start: S,
    count: Option<u64>
) -> AsyncResult<Vec<XReadValue<Ri, Rk, Rv>>> where
    Ri: FromRedis + Unpin + Send,
    Rk: FromRedisKey + Hash + Eq + Unpin + Send,
    Rv: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    S: TryInto<RedisValue>,
    S::Error: Into<RedisError>,
    E: TryInto<RedisValue>,
    E::Error: Into<RedisError>, 

Similar to XRANGE, but with the results returned in reverse order. The results will be automatically converted to a less verbose type definition.

fn xrevrange<R, K, S, E>(
    &self,
    key: K,
    end: E,
    start: S,
    count: Option<u64>
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    S: TryInto<RedisValue>,
    S::Error: Into<RedisError>,
    E: TryInto<RedisValue>,
    E::Error: Into<RedisError>, 

Similar to XRANGE, but with the results returned in reverse order.

fn xlen<R, K>(&self, key: K) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>, 

Returns the number of entries inside a stream.

fn xread_map<Rk1, Rk2, Rk3, Rv, K, I>(
    &self,
    count: Option<u64>,
    block: Option<u64>,
    keys: K,
    ids: I
) -> AsyncResult<XReadResponse<Rk1, Rk2, Rk3, Rv>> where
    Rk1: FromRedisKey + Hash + Eq + Unpin + Send,
    Rk2: FromRedis + Unpin + Send,
    Rk3: FromRedisKey + Hash + Eq + Unpin + Send,
    Rv: FromRedis + Unpin + Send,
    K: Into<MultipleKeys>,
    I: Into<MultipleIDs>, 

Read data from one or multiple streams, only returning entries with an ID greater than the last received ID reported by the caller.

fn xread<R, K, I>(
    &self,
    count: Option<u64>,
    block: Option<u64>,
    keys: K,
    ids: I
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<MultipleKeys>,
    I: Into<MultipleIDs>, 

Read data from one or multiple streams, only returning entries with an ID greater than the last received ID reported by the caller.

fn xgroup_create<R, K, S, I>(
    &self,
    key: K,
    groupname: S,
    id: I,
    mkstream: bool
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    S: Into<Str>,
    I: Into<XID>, 

This command creates a new consumer group uniquely identified by groupname for the stream stored at key.

fn xgroup_createconsumer<R, K, G, C>(
    &self,
    key: K,
    groupname: G,
    consumername: C
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    G: Into<Str>,
    C: Into<Str>, 

Create a consumer named consumername in the consumer group groupname of the stream that’s stored at key.

fn xgroup_delconsumer<R, K, G, C>(
    &self,
    key: K,
    groupname: G,
    consumername: C
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    G: Into<Str>,
    C: Into<Str>, 

Delete a consumer named consumername in the consumer group groupname of the stream that’s stored at key.

fn xgroup_destroy<R, K, S>(&self, key: K, groupname: S) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    S: Into<Str>, 

Completely destroy a consumer group.

fn xgroup_setid<R, K, S, I>(
    &self,
    key: K,
    groupname: S,
    id: I
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    S: Into<Str>,
    I: Into<XID>, 

Set the last delivered ID for a consumer group.

fn xreadgroup_map<Rk1, Rk2, Rk3, Rv, G, C, K, I>(
    &self,
    group: G,
    consumer: C,
    count: Option<u64>,
    block: Option<u64>,
    noack: bool,
    keys: K,
    ids: I
) -> AsyncResult<XReadResponse<Rk1, Rk2, Rk3, Rv>> where
    Rk1: FromRedisKey + Hash + Eq + Unpin + Send,
    Rk2: FromRedis + Unpin + Send,
    Rk3: FromRedisKey + Hash + Eq + Unpin + Send,
    Rv: FromRedis + Unpin + Send,
    G: Into<Str>,
    C: Into<Str>,
    K: Into<MultipleKeys>,
    I: Into<MultipleIDs>, 

A special version of the XREAD command with support for consumer groups.

fn xreadgroup<R, G, C, K, I>(
    &self,
    group: G,
    consumer: C,
    count: Option<u64>,
    block: Option<u64>,
    noack: bool,
    keys: K,
    ids: I
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    G: Into<Str>,
    C: Into<Str>,
    K: Into<MultipleKeys>,
    I: Into<MultipleIDs>, 

A special version of the XREAD command with support for consumer groups.

fn xack<R, K, G, I>(&self, key: K, group: G, ids: I) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    G: Into<Str>,
    I: Into<MultipleIDs>, 

Remove one or more messages from the Pending Entries List (PEL) of a stream consumer group.

fn xclaim_values<Ri, Rk, Rv, K, G, C, I>(
    &self,
    key: K,
    group: G,
    consumer: C,
    min_idle_time: u64,
    ids: I,
    idle: Option<u64>,
    time: Option<u64>,
    retry_count: Option<u64>,
    force: bool,
    justid: bool
) -> AsyncResult<Vec<XReadValue<Ri, Rk, Rv>>> where
    Ri: FromRedis + Unpin + Send,
    Rk: FromRedisKey + Hash + Eq + Unpin + Send,
    Rv: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    G: Into<Str>,
    C: Into<Str>,
    I: Into<MultipleIDs>, 

A variation of xclaim with a less verbose return type.

fn xclaim<R, K, G, C, I>(
    &self,
    key: K,
    group: G,
    consumer: C,
    min_idle_time: u64,
    ids: I,
    idle: Option<u64>,
    time: Option<u64>,
    retry_count: Option<u64>,
    force: bool,
    justid: bool
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    G: Into<Str>,
    C: Into<Str>,
    I: Into<MultipleIDs>, 

In the context of a stream consumer group, this command changes the ownership of a pending message, so that the new owner is the consumer specified as the command argument.

fn xautoclaim_values<Ri, Rk, Rv, K, G, C, I>(
    &self,
    key: K,
    group: G,
    consumer: C,
    min_idle_time: u64,
    start: I,
    count: Option<u64>,
    justid: bool
) -> AsyncResult<(String, Vec<XReadValue<Ri, Rk, Rv>>)> where
    Ri: FromRedis + Unpin + Send,
    Rk: FromRedisKey + Hash + Eq + Unpin + Send,
    Rv: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    G: Into<Str>,
    C: Into<Str>,
    I: Into<XID>, 

This command transfers ownership of pending stream entries that match the specified criteria. It also converts the response type to a less verbose type declaration and handles potential differences between RESP2 and RESP3.

fn xautoclaim<R, K, G, C, I>(
    &self,
    key: K,
    group: G,
    consumer: C,
    min_idle_time: u64,
    start: I,
    count: Option<u64>,
    justid: bool
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    G: Into<Str>,
    C: Into<Str>,
    I: Into<XID>, 

This command transfers ownership of pending stream entries that match the specified criteria.

fn xpending<R, K, G, A>(&self, key: K, group: G, args: A) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<RedisKey>,
    G: Into<Str>,
    A: Into<XPendingArgs>, 

Inspect the list of pending messages in a consumer group.

impl TransactionInterface for RedisClient

fn multi(&self, abort_on_error: bool) -> AsyncResult<TransactionClient>

Enter a MULTI block, executing subsequent commands as a transaction.

fn in_transaction(&self) -> bool

Whether or not the client is currently in the middle of a MULTI transaction.

fn force_discard_transaction(&self) -> AsyncResult<()>

Force the client to abort any in-flight transactions.

fn watch<K>(&self, keys: K) -> AsyncResult<()> where
    K: Into<MultipleKeys>, 

Marks the given keys to be watched for conditional execution of a transaction.

fn unwatch(&self) -> AsyncResult<()>

Flushes all the previously watched keys for a transaction.