Struct fred::clients::RedisClient

pub struct RedisClient { /* private fields */ }

A cheaply cloneable Redis client struct.

Implementations

impl RedisClient

pub fn new( config: RedisConfig, perf: Option<PerformanceConfig>, connection: Option<ConnectionConfig>, policy: Option<ReconnectPolicy>, ) -> RedisClient

Create a new client instance without connecting to the server.

See the builder interface for more information.

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.

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

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

Alternatively, callers can use with_cluster_node to avoid creating new connections.

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.

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.

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. See split_cluster for use cases that require scanning to work while the cluster state changes.

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

pub fn pipeline(&self) -> Pipeline<RedisClient>

Send a series of commands in a pipeline.

pub fn with_cluster_node<S>(&self, server: S) -> WithOptions<Self>

where S: Into<Server>,

Shorthand to route subsequent commands to the provided server.

See with_options for more information.

async fn example(client: &RedisClient) -> Result<(), RedisError> {
  // discover servers via the `RedisConfig` or active connections
  let connections = client.active_connections().await?;

  // ping each node in the cluster individually
  for server in connections.into_iter() {
    let _: () = client.with_cluster_node(server).ping().await?;
  }

  // or use the cached cluster routing table to discover servers
  let servers = client
    .cached_cluster_state()
    .expect("Failed to read cached cluster state")
    .unique_primary_nodes();

  for server in servers.into_iter() {
    // verify the server address with `CLIENT INFO`
    let server_addr = client
      .with_cluster_node(&server)
      .client_info::<String>()
      .await?
      .split(" ")
      .find_map(|s| {
        let parts: Vec<&str> = s.split("=").collect();
        if parts[0] == "laddr" {
          Some(parts[1].to_owned())
        } else {
          None
        }
      })
      .expect("Failed to read or parse client info.");

    assert_eq!(server_addr, server.to_string());
  }

  Ok(())
}

pub fn replicas(&self) -> Replicas

Available on crate feature replicas only.

Create a client that interacts with replica nodes.

Trait Implementations

impl AclInterface for RedisClient

Available on crate feature i-acl only.

fn acl_setuser<S, V>( &self, username: S, rules: V, ) -> impl Future<Output = RedisResult<()>>

where S: Into<Str>, V: TryInto<MultipleValues>, V::Error: Into<RedisError>,

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

fn acl_load(&self) -> impl Future<Output = RedisResult<()>>

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) -> impl Future<Output = RedisResult<()>>

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) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

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

fn acl_users<R>(&self) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

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

fn acl_getuser<R, S>(&self, username: S) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, S: Into<Str>,

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

fn acl_deluser<R, S>( &self, usernames: S, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, S: Into<MultipleStrings>,

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

fn acl_cat<R>( &self, category: Option<Str>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

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<R>( &self, bits: Option<u16>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

Generate a password with length bits, returning the password.

fn acl_whoami<R>(&self) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

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

fn acl_log_count<R>( &self, count: Option<u32>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

Read count recent ACL security events.

fn acl_log_reset(&self) -> impl Future<Output = RedisResult<()>>

Clear the ACL security events logs.

impl AuthInterface for RedisClient

fn auth<S>( &self, username: Option<String>, password: S, ) -> impl Future<Output = RedisResult<()>>

where S: Into<Str>,

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

fn hello( &self, version: RespVersion, auth: Option<(Str, Str)>, setname: Option<Str>, ) -> impl Future<Output = RedisResult<()>>

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

impl ClientInterface for RedisClient

Available on crate feature i-client only.

fn client_id<R>(&self) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

Return the ID of the current connection.

fn connection_ids(&self) -> impl Future<Output = HashMap<Server, i64>>

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

fn client_info<R>(&self) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

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>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

Close a given connection or set of connections.

fn client_list<R, I>( &self, type: Option<ClientKillType>, ids: Option<Vec<String>>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

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

fn client_getname<R>(&self) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

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

fn client_setname<S>(&self, name: S) -> impl Future<Output = RedisResult<()>>

where S: Into<Str>,

Assign a name to the current connection.

fn client_pause( &self, timeout: i64, mode: Option<ClientPauseKind>, ) -> impl Future<Output = RedisResult<()>>

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) -> impl Future<Output = RedisResult<()>>

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

fn client_reply( &self, flag: ClientReplyFlag, ) -> impl Future<Output = RedisResult<()>>

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>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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>, ) -> impl Future<Output = RedisResult<()>>

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

fn client_tracking<R, T, P>( &self, toggle: T, redirect: Option<i64>, prefixes: P, bcast: bool, optin: bool, optout: bool, noloop: bool, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, T: TryInto<Toggle>, T::Error: Into<RedisError>, P: Into<MultipleStrings>,

Available on crate feature i-tracking only.

This command enables the tracking feature of the Redis server that is used for server assisted client side caching.

fn client_trackinginfo<R>(&self) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

Available on crate feature i-tracking only.

The command returns information about the current client connection’s use of the server assisted client side caching feature.

fn client_getredir<R>(&self) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

Available on crate feature i-tracking only.

This command returns the client ID we are redirecting our tracking notifications to.

fn client_caching<R>( &self, enabled: bool, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

Available on crate feature i-tracking only.

This command controls the tracking of the keys in the next command executed by the connection, when tracking is enabled in OPTIN or OPTOUT mode.

impl ClientLike for RedisClient

fn id(&self) -> &str

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 connection_config(&self) -> &ConnectionConfig

Read the connection config 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 the client has a reconnection policy.

fn is_pipelined(&self) -> bool

Whether the client will automatically pipeline commands.

fn is_clustered(&self) -> bool

Whether the client is connected to a cluster.

fn uses_sentinels(&self) -> bool

Whether the client uses the sentinel interface.

fn update_perf_config(&self, config: PerformanceConfig)

Update the internal PerformanceConfig in place with new values.

fn perf_config(&self) -> PerformanceConfig

Read the PerformanceConfig associated with this client.

fn state(&self) -> ClientState

Read the state of the underlying connection(s).

fn is_connected(&self) -> bool

Whether all underlying connections are healthy.

fn active_connections( &self, ) -> impl Future<Output = Result<Vec<Server>, RedisError>>

Read the set of active connections managed by the client.

fn server_version(&self) -> Option<Version>

Read the server version, if known.

fn set_resolver(&self, resolver: Rc<dyn Resolve>) -> impl Future

Available on crate feature dns only.

Override the DNS resolution logic for the client.

fn connect(&self) -> ConnectHandle

Connect to the server.

fn force_reconnection(&self) -> impl Future<Output = RedisResult<()>>

Force a reconnection to the server(s).

fn wait_for_connect(&self) -> impl Future<Output = RedisResult<()>>

Wait for the result of the next connection attempt.

fn init(&self) -> impl Future<Output = RedisResult<ConnectHandle>>

Initialize a new routing and connection task and wait for it to connect successfully.

fn quit(&self) -> impl Future<Output = RedisResult<()>>

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>, ) -> impl Future<Output = RedisResult<()>>

Available on crate feature i-server only.

Shut down the server and quit the client.

fn flushall<R>(&self, async: bool) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

Delete the keys in all databases.

fn flushall_cluster(&self) -> impl Future<Output = RedisResult<()>>

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

fn ping<R>(&self) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

Ping the Redis server.

fn info<R>( &self, section: Option<InfoKind>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

Read info about the server.

fn custom<R, T>( &self, cmd: CustomCommand, args: Vec<T>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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>, ) -> impl Future<Output = RedisResult<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.

fn with_options(&self, options: &Options) -> WithOptions<Self>

Customize various configuration options on commands.

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

Available on crate feature i-cluster only.

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

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

fn num_primary_cluster_nodes(&self) -> usize

Read the number of known primary cluster nodes, or 0 if the cluster state is not known.

fn sync_cluster(&self) -> impl Future<Output = Result<(), RedisError>>

Update the cached cluster state and add or remove any changed cluster node connections.

fn cluster_bumpepoch<R>(&self) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

Advances the cluster config epoch.

fn cluster_flushslots(&self) -> impl Future<Output = RedisResult<()>>

Deletes all slots from a node.

fn cluster_myid<R>(&self) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

Returns the node’s id.

fn cluster_nodes<R>(&self) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

Read the current cluster node configuration.

fn cluster_saveconfig(&self) -> impl Future<Output = RedisResult<()>>

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

fn cluster_slots<R>(&self) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

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

fn cluster_info<R>(&self) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

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

fn cluster_add_slots<S>( &self, slots: S, ) -> impl Future<Output = RedisResult<()>>

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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

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

fn cluster_del_slots<S>( &self, slots: S, ) -> impl Future<Output = RedisResult<()>>

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>, ) -> impl Future<Output = RedisResult<()>>

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) -> impl Future<Output = RedisResult<()>>

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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

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) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>,

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

fn cluster_meet<S>( &self, ip: S, port: u16, ) -> impl Future<Output = RedisResult<()>>

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, ) -> impl Future<Output = RedisResult<()>>

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<R, S>( &self, node_id: S, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, S: Into<Str>,

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

fn cluster_reset( &self, mode: Option<ClusterResetFlag>, ) -> impl Future<Output = RedisResult<()>>

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, ) -> impl Future<Output = RedisResult<()>>

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

fn cluster_setslot( &self, slot: u16, state: ClusterSetSlotState, ) -> impl Future<Output = RedisResult<()>>

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

impl ConfigInterface for RedisClient

Available on crate feature i-config only.

fn config_resetstat(&self) -> impl Future<Output = RedisResult<()>>

Resets the statistics reported by Redis using the INFO command.

fn config_rewrite(&self) -> impl Future<Output = RedisResult<()>>

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) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<()>>

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 Debug for RedisClient

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

Formats the value using the given formatter.

impl Default for RedisClient

fn default() -> Self

Returns the “default value” for a type.

impl Display for RedisClient

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

Formats the value using the given formatter.

impl EventInterface for RedisClient

fn on_message<F>(&self, func: F) -> JoinHandle<RedisResult<()>>

where F: Fn(Message) -> RedisResult<()> + 'static,

Spawn a task that runs the provided function on each publish-subscribe message.

fn on_keyspace_event<F>(&self, func: F) -> JoinHandle<RedisResult<()>>

where F: Fn(KeyspaceEvent) -> RedisResult<()> + 'static,

Spawn a task that runs the provided function on each keyspace event.

fn on_reconnect<F>(&self, func: F) -> JoinHandle<RedisResult<()>>

where F: Fn(Server) -> RedisResult<()> + 'static,

Spawn a task that runs the provided function on each reconnection event.

fn on_cluster_change<F>(&self, func: F) -> JoinHandle<RedisResult<()>>

where F: Fn(Vec<ClusterStateChange>) -> RedisResult<()> + 'static,

Spawn a task that runs the provided function on each cluster change event.

fn on_error<F>(&self, func: F) -> JoinHandle<RedisResult<()>>

where F: Fn(RedisError) -> RedisResult<()> + 'static,

Spawn a task that runs the provided function on each connection error event.

fn on_unresponsive<F>(&self, func: F) -> JoinHandle<RedisResult<()>>

where F: Fn(Server) -> RedisResult<()> + 'static,

Spawn a task that runs the provided function whenever the client detects an unresponsive connection.

fn on_any<Fe, Fr, Fc>( &self, error_fn: Fe, reconnect_fn: Fr, cluster_change_fn: Fc, ) -> JoinHandle<RedisResult<()>>

where Fe: Fn(RedisError) -> RedisResult<()> + 'static, Fr: Fn(Server) -> RedisResult<()> + 'static, Fc: Fn(Vec<ClusterStateChange>) -> RedisResult<()> + 'static,

Spawn one task that listens for all connection management event types.

fn message_rx(&self) -> BroadcastReceiver<Message>

Listen for messages on the publish-subscribe interface.

fn keyspace_event_rx(&self) -> BroadcastReceiver<KeyspaceEvent>

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

fn reconnect_rx(&self) -> BroadcastReceiver<Server>

Listen for reconnection notifications.

fn cluster_change_rx(&self) -> BroadcastReceiver<Vec<ClusterStateChange>>

Listen for notifications whenever the cluster state changes.

fn error_rx(&self) -> BroadcastReceiver<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 unresponsive_rx(&self) -> BroadcastReceiver<Server>

Receive a message when the client initiates a reconnection after detecting an unresponsive connection.

impl FunctionInterface for RedisClient

Available on crate feature i-scripts only.

fn fcall<R, F, K, V>( &self, func: F, keys: K, args: V, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, F: Into<Str>, K: Into<MultipleKeys>, V: TryInto<MultipleValues>, V::Error: Into<RedisError>,

Invoke a function.

fn fcall_ro<R, F, K, V>( &self, func: F, keys: K, args: V, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, F: Into<Str>, K: Into<MultipleKeys>, V: TryInto<MultipleValues>, V::Error: Into<RedisError>,

This is a read-only variant of the FCALL command that cannot execute commands that modify data.

fn function_delete<R, S>( &self, library_name: S, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, S: Into<Str>,

Delete a library and all its functions.

fn function_delete_cluster<S>( &self, library_name: S, ) -> impl Future<Output = RedisResult<()>>

where S: Into<Str>,

Delete a library and all its functions from each cluster node concurrently.

fn function_dump<R>(&self) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

Return the serialized payload of loaded libraries.

fn function_flush<R>(&self, async: bool) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

Deletes all the libraries.

fn function_flush_cluster( &self, async: bool, ) -> impl Future<Output = RedisResult<()>>

Deletes all the libraries on all cluster nodes concurrently.

fn function_kill<R>(&self) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

Kill a function that is currently executing.

fn function_list<R, S>( &self, library_name: Option<S>, withcode: bool, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, S: Into<Str>,

Return information about the functions and libraries.

fn function_load<R, S>( &self, replace: bool, code: S, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, S: Into<Str>,

Load a library to Redis.

fn function_load_cluster<R, S>( &self, replace: bool, code: S, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, S: Into<Str>,

Load a library to Redis on all cluster nodes concurrently.

fn function_restore<R, B, P>( &self, serialized: B, policy: P, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, B: Into<Bytes>, P: TryInto<FnPolicy>, P::Error: Into<RedisError>,

Restore libraries from the serialized payload.

fn function_restore_cluster<B, P>( &self, serialized: B, policy: P, ) -> impl Future<Output = RedisResult<()>>

where B: Into<Bytes>, P: TryInto<FnPolicy>, P::Error: Into<RedisError>,

Restore libraries from the serialized payload on all cluster nodes concurrently.

fn function_stats<R>(&self) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

Return information about the function that’s currently running and information about the available execution engines.

impl GeoInterface for RedisClient

Available on crate feature i-geo only.

fn geoadd<R, K, V>( &self, key: K, options: Option<SetOptions>, changed: bool, values: V, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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<R, K, V>( &self, key: K, members: V, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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<R, 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>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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<R, 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>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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<R, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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

Available on crate feature i-hashes only.

fn hgetall<R, K>(&self, key: K) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>,

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

fn hdel<R, K, F>( &self, key: K, fields: F, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>,

Returns all field names in the hash stored at key.

fn hlen<R, K>(&self, key: K) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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)>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>,

Returns all values in the hash stored at key.

impl HeartbeatInterface for RedisClient

Available on crate feature i-server only.

fn enable_heartbeat( &self, interval: Duration, break_on_error: bool, ) -> impl Future<Output = RedisResult<()>>

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

impl HyperloglogInterface for RedisClient

Available on crate feature i-hyperloglog only.

fn pfadd<R, K, V>( &self, key: K, elements: V, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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

Available on crate feature i-keys only.

fn watch<K>(&self, keys: K) -> impl Future<Output = RedisResult<()>>

where K: Into<MultipleKeys>,

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

fn unwatch(&self) -> impl Future<Output = RedisResult<()>>

Flushes all the previously watched keys for a transaction.

fn randomkey<R>(&self) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

Return a random key from the currently selected database.

fn copy<R, S, D>( &self, source: S, destination: D, db: Option<u8>, replace: bool, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, S: Into<RedisKey>, D: Into<RedisKey>,

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

fn dump<R, K>(&self, key: K) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>,

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

fn restore<R, K>( &self, key: K, ttl: i64, serialized: RedisValue, replace: bool, absttl: bool, idletime: Option<i64>, frequency: Option<i64>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>,

Read a value from the server.

fn getrange<R, K>( &self, key: K, start: usize, end: usize, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<MultipleKeys>,

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

fn unlink<R, K>(&self, keys: K) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<MultipleKeys>,

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

fn rename<R, S, D>( &self, source: S, destination: D, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, S: Into<RedisKey>, D: Into<RedisKey>,

Renames source key to destination.

fn renamenx<R, S, D>( &self, source: S, destination: D, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, S: Into<RedisKey>, D: Into<RedisKey>,

Renames source key to destination if destination does not yet exist.

fn append<R, K, V>( &self, key: K, value: V, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, V: TryInto<RedisValue>, V::Error: Into<RedisError>,

Append value to key if it’s a string.

fn mget<R, K>(&self, keys: K) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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) -> impl Future<Output = RedisResult<()>>

where V: TryInto<RedisMap>, V::Error: Into<RedisError>,

Sets the given keys to their respective values.

fn msetnx<R, V>(&self, values: V) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>,

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

fn pexpire<R, K>( &self, key: K, milliseconds: i64, options: Option<ExpireOptions>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>,

This command works exactly like EXPIRE but the time to live of the key is specified in milliseconds instead of seconds.

fn pexpire_at<R, K>( &self, key: K, timestamp: i64, options: Option<ExpireOptions>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>,

PEXPIREAT has the same effect and semantic as EXPIREAT, but the Unix time at which the key will expire is specified in milliseconds instead of seconds.

fn exists<R, K>(&self, keys: K) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<MultipleKeys>,

Returns number of keys that exist from the keys arguments.

fn lcs<R, K1, K2>( &self, key1: K1, key2: K2, len: bool, idx: bool, minmatchlen: Option<i64>, withmatchlen: bool, ) -> impl Future<Output = Result<R, RedisError>>

where R: FromRedis, K1: Into<RedisKey>, K2: Into<RedisKey>,

Runs the longest common subsequence algorithm on two keys.

impl ListInterface for RedisClient

Available on crate feature i-lists only.

fn blmpop<R, K>( &self, timeout: f64, keys: K, direction: LMoveDirection, count: Option<i64>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<MultipleKeys>,

The blocking variant of Self::lmpop.

fn blpop<R, K>( &self, keys: K, timeout: f64, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, S: Into<RedisKey>, D: Into<RedisKey>,

The blocking equivalent of Self::lmove.

fn lmpop<R, K>( &self, keys: K, direction: LMoveDirection, count: Option<i64>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<MultipleKeys>,

Pops one or more elements from the first non-empty list key from the list of provided key names.

fn lindex<R, K>( &self, key: K, index: i64, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>,

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

fn linsert<R, K, P, V>( &self, key: K, location: ListLocation, pivot: P, element: V, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>,

Returns the length of the list stored at key.

fn lpop<R, K>( &self, key: K, count: Option<usize>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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.

fn sort<R, K, S>( &self, key: K, by: Option<Str>, limit: Option<Limit>, get: S, order: Option<SortOrder>, alpha: bool, store: Option<RedisKey>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, S: Into<MultipleStrings>,

Returns or stores the elements contained in the list, set or sorted set at key.

fn sort_ro<R, K, S>( &self, key: K, by: Option<Str>, limit: Option<Limit>, get: S, order: Option<SortOrder>, alpha: bool, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, S: Into<MultipleStrings>,

Read-only variant of the SORT command. It is exactly like the original SORT but refuses the STORE option and can safely be used in read-only replicas.

impl LuaInterface for RedisClient

Available on crate feature i-scripts only.

fn script_load<R, S>(&self, script: S) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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<R, S>( &self, script: S, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, S: Into<Str>,

Available on crate feature sha-1 only.

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

fn script_kill(&self) -> impl Future<Output = RedisResult<()>>

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

fn script_kill_cluster(&self) -> impl Future<Output = RedisResult<()>>

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) -> impl Future<Output = RedisResult<()>>

Flush the Lua scripts cache.

fn script_flush_cluster( &self, async: bool, ) -> impl Future<Output = RedisResult<()>>

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

fn script_exists<R, H>(&self, hashes: H) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, H: Into<MultipleStrings>,

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

fn script_debug( &self, flag: ScriptDebugFlag, ) -> impl Future<Output = RedisResult<()>>

Set the debug mode for subsequent scripts executed with EVAL.

fn evalsha<R, S, K, V>( &self, hash: S, keys: K, args: V, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, S: Into<Str>, K: Into<MultipleKeys>, V: TryInto<MultipleValues>, V::Error: Into<RedisError>,

Evaluate a Lua script on the server.

impl MemoryInterface for RedisClient

Available on crate feature i-memory only.

fn memory_doctor<R>(&self) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

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

fn memory_malloc_stats<R>(&self) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

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

fn memory_purge(&self) -> impl Future<Output = RedisResult<()>>

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

fn memory_stats<R>(&self) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

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

fn memory_usage<R, K>( &self, key: K, samples: Option<u32>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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

Available on crate feature i-pubsub only.

fn subscribe<S>(&self, channels: S) -> impl Future<Output = RedisResult<()>>

where S: Into<MultipleStrings>,

Subscribe to a channel on the publish-subscribe interface.

fn unsubscribe<S>(&self, channels: S) -> impl Future<Output = RedisResult<()>>

where S: Into<MultipleStrings>,

Unsubscribe from a channel on the PubSub interface.

fn psubscribe<S>(&self, patterns: S) -> impl Future<Output = RedisResult<()>>

where S: Into<MultipleStrings>,

Subscribes the client to the given patterns.

fn punsubscribe<S>(&self, patterns: S) -> impl Future<Output = RedisResult<()>>

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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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.

fn ssubscribe<C>(&self, channels: C) -> impl Future<Output = RedisResult<()>>

where C: Into<MultipleStrings>,

Subscribes the client to the specified shard channels.

fn sunsubscribe<C>(&self, channels: C) -> impl Future<Output = RedisResult<()>>

where C: Into<MultipleStrings>,

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

fn spublish<R, S, V>( &self, channel: S, message: V, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, S: Into<Str>, V: TryInto<RedisValue>, V::Error: Into<RedisError>,

Posts a message to the given shard channel.

fn pubsub_channels<R, S>( &self, pattern: S, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, S: Into<Str>,

Lists the currently active channels.

fn pubsub_numpat<R>(&self) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

Returns the number of unique patterns that are subscribed to by clients.

fn pubsub_numsub<R, S>( &self, channels: S, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, S: Into<MultipleStrings>,

Returns the number of subscribers (exclusive of clients subscribed to patterns) for the specified channels.

fn pubsub_shardchannels<R, S>( &self, pattern: S, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, S: Into<Str>,

Lists the currently active shard channels.

fn pubsub_shardnumsub<R, S>( &self, channels: S, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, S: Into<MultipleStrings>,

Returns the number of subscribers for the specified shard channels.

impl RediSearchInterface for RedisClient

Available on crate feature i-redisearch only.

fn ft_list<R>(&self) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

Returns a list of all existing indexes.

fn ft_aggregate<R, I, Q>( &self, index: I, query: Q, options: FtAggregateOptions, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, I: Into<Str>, Q: Into<Str>,

Run a search query on an index, and perform aggregate transformations on the results.

fn ft_search<R, I, Q>( &self, index: I, query: Q, options: FtSearchOptions, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, I: Into<Str>, Q: Into<Str>,

Search the index with a textual query, returning either documents or just ids.

fn ft_create<R, I>( &self, index: I, options: FtCreateOptions, schema: Vec<SearchSchema>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, I: Into<Str>,

Create an index with the given specification.

fn ft_alter<R, I>( &self, index: I, options: FtAlterOptions, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, I: Into<Str>,

Add a new attribute to the index.

fn ft_aliasadd<R, A, I>( &self, alias: A, index: I, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, A: Into<Str>, I: Into<Str>,

Add an alias to an index.

fn ft_aliasdel<R, A>(&self, alias: A) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, A: Into<Str>,

Remove an alias from an index.

fn ft_aliasupdate<R, A, I>( &self, alias: A, index: I, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, A: Into<Str>, I: Into<Str>,

Add an alias to an index. If the alias is already associated with another index, FT.ALIASUPDATE removes the alias association with the previous index.

fn ft_config_get<R, S>(&self, option: S) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, S: Into<Str>,

Retrieve configuration options.

fn ft_config_set<R, S, V>( &self, option: S, value: V, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, S: Into<Str>, V: TryInto<RedisValue>, V::Error: Into<RedisError>,

Set the value of a RediSearch configuration parameter.

fn ft_cursor_del<R, I, C>( &self, index: I, cursor: C, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, I: Into<Str>, C: TryInto<RedisValue>, C::Error: Into<RedisError>,

Delete a cursor.

fn ft_cursor_read<R, I, C>( &self, index: I, cursor: C, count: Option<u64>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, I: Into<Str>, C: TryInto<RedisValue>, C::Error: Into<RedisError>,

Read next results from an existing cursor.

fn ft_dictadd<R, D, S>( &self, dict: D, terms: S, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, D: Into<Str>, S: Into<MultipleStrings>,

Add terms to a dictionary.

fn ft_dictdel<R, D, S>( &self, dict: D, terms: S, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, D: Into<Str>, S: Into<MultipleStrings>,

Remove terms from a dictionary.

fn ft_dictdump<R, D>(&self, dict: D) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, D: Into<Str>,

Dump all terms in the given dictionary.

fn ft_dropindex<R, I>( &self, index: I, dd: bool, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, I: Into<Str>,

Delete an index.

fn ft_explain<R, I, Q>( &self, index: I, query: Q, dialect: Option<i64>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, I: Into<Str>, Q: Into<Str>,

Return the execution plan for a complex query.

fn ft_info<R, I>(&self, index: I) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, I: Into<Str>,

Return information and statistics on the index.

fn ft_spellcheck<R, I, Q>( &self, index: I, query: Q, distance: Option<u8>, terms: Option<SpellcheckTerms>, dialect: Option<i64>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, I: Into<Str>, Q: Into<Str>,

Perform spelling correction on a query, returning suggestions for misspelled terms.

fn ft_sugadd<R, K, S>( &self, key: K, string: S, score: f64, incr: bool, payload: Option<Bytes>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, S: Into<Str>,

Add a suggestion string to an auto-complete suggestion dictionary.

fn ft_sugdel<R, K, S>( &self, key: K, string: S, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, S: Into<Str>,

Delete a string from a suggestion index.

fn ft_sugget<R, K, P>( &self, key: K, prefix: P, fuzzy: bool, withscores: bool, withpayloads: bool, max: Option<u64>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, P: Into<Str>,

Get completion suggestions for a prefix.

fn ft_suglen<R, K>(&self, key: K) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>,

Get the size of an auto-complete suggestion dictionary.

fn ft_syndump<R, I>(&self, index: I) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, I: Into<Str>,

Dump the contents of a synonym group.

fn ft_synupdate<R, I, S, T>( &self, index: I, synonym_group_id: S, skipinitialscan: bool, terms: T, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, I: Into<Str>, S: Into<Str>, T: Into<MultipleStrings>,

Update a synonym group.

fn ft_tagvals<R, I, F>( &self, index: I, field_name: F, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, I: Into<Str>, F: Into<Str>,

Return a distinct set of values indexed in a Tag field.

impl RedisJsonInterface for RedisClient

Available on crate feature i-redis-json only.

fn json_arrappend<R, K, P, V>( &self, key: K, path: P, values: Vec<V>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, P: Into<Str>, V: Into<Value>,

Append the json values into the array at path after the last element in it.

fn json_arrindex<R, K, P, V>( &self, key: K, path: P, value: V, start: Option<i64>, stop: Option<i64>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, P: Into<Str>, V: Into<Value>,

Search for the first occurrence of a JSON value in an array.

fn json_arrinsert<R, K, P, V>( &self, key: K, path: P, index: i64, values: Vec<V>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, P: Into<Str>, V: Into<Value>,

Insert the json values into the array at path before the index (shifts to the right).

fn json_arrlen<R, K, P>( &self, key: K, path: Option<P>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, P: Into<Str>,

Report the length of the JSON array at path in key.

fn json_arrpop<R, K, P>( &self, key: K, path: Option<P>, index: Option<i64>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, P: Into<Str>,

Remove and return an element from the index in the array

fn json_arrtrim<R, K, P>( &self, key: K, path: P, start: i64, stop: i64, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, P: Into<Str>,

Trim an array so that it contains only the specified inclusive range of elements

fn json_clear<R, K, P>( &self, key: K, path: Option<P>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, P: Into<Str>,

Clear container values (arrays/objects) and set numeric values to 0

fn json_debug_memory<R, K, P>( &self, key: K, path: Option<P>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, P: Into<Str>,

Report a value’s memory usage in bytes

fn json_del<R, K, P>( &self, key: K, path: P, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, P: Into<Str>,

Delete a value.

fn json_get<R, K, I, N, S, P>( &self, key: K, indent: Option<I>, newline: Option<N>, space: Option<S>, paths: P, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, I: Into<Str>, N: Into<Str>, S: Into<Str>, P: Into<MultipleStrings>,

Return the value at path in JSON serialized form.

fn json_merge<R, K, P, V>( &self, key: K, path: P, value: V, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, P: Into<Str>, V: Into<Value>,

Merge a given JSON value into matching paths.

fn json_mget<R, K, P>( &self, keys: K, path: P, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<MultipleKeys>, P: Into<Str>,

Return the values at path from multiple key arguments.

fn json_mset<R, K, P, V>( &self, values: Vec<(K, P, V)>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, P: Into<Str>, V: Into<Value>,

Set or update one or more JSON values according to the specified key-path-value triplets.

fn json_numincrby<R, K, P, V>( &self, key: K, path: P, value: V, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, P: Into<Str>, V: Into<Value>,

Increment the number value stored at path by number

fn json_objkeys<R, K, P>( &self, key: K, path: Option<P>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, P: Into<Str>,

Return the keys in the object that’s referenced by path.

fn json_objlen<R, K, P>( &self, key: K, path: Option<P>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, P: Into<Str>,

Report the number of keys in the JSON object at path in key.

fn json_resp<R, K, P>( &self, key: K, path: Option<P>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, P: Into<Str>,

Return the JSON in key in Redis serialization protocol specification form.

fn json_set<R, K, P, V>( &self, key: K, path: P, value: V, options: Option<SetOptions>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, P: Into<Str>, V: Into<Value>,

Set the JSON value at path in key.

fn json_strappend<R, K, P, V>( &self, key: K, path: Option<P>, value: V, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, P: Into<Str>, V: Into<Value>,

Append the json-string values to the string at path.

fn json_strlen<R, K, P>( &self, key: K, path: Option<P>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, P: Into<Str>,

Report the length of the JSON String at path in key.

fn json_toggle<R, K, P>( &self, key: K, path: P, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, P: Into<Str>,

Toggle a Boolean value stored at path.

fn json_type<R, K, P>( &self, key: K, path: Option<P>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, P: Into<Str>,

Report the type of JSON value at path.

impl ServerInterface for RedisClient

Available on crate feature i-server only.

fn bgrewriteaof<R>(&self) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

Instruct Redis to start an Append Only File rewrite process.

fn bgsave<R>(&self) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

Save the DB in background.

fn dbsize<R>(&self) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

Return the number of keys in the selected database.

fn select(&self, db: u8) -> impl Future<Output = RedisResult<()>>

Select the database this client should use.

fn failover( &self, to: Option<(String, u16)>, force: bool, abort: bool, timeout: Option<u32>, ) -> impl Future<Output = RedisResult<()>>

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

fn lastsave<R>(&self) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

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

fn wait<R>( &self, numreplicas: i64, timeout: i64, ) -> impl Future<Output = Result<R, RedisError>>

where R: FromRedis,

This command blocks the current client until all the previous write commands are successfully transferred and acknowledged by at least the specified number of replicas. If the timeout, specified in milliseconds, is reached, the command returns even if the specified number of replicas were not yet reached.

fn sentinel_primary(&self) -> Option<Server>

Read the primary Redis server identifier returned from the sentinel nodes.

fn sentinel_nodes(&self) -> Option<Vec<Server>>

Read the set of known sentinel nodes.

impl SetsInterface for RedisClient

Available on crate feature i-sets only.

fn sadd<R, K, V>( &self, key: K, members: V, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>,

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

fn sdiff<R, K>(&self, keys: K) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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

Available on crate feature i-slowlog only.

fn slowlog_get<R>( &self, count: Option<i64>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

This command is used to read the slow queries log.

fn slowlog_length<R>(&self) -> impl Future<Output = RedisResult<R>>

where R: FromRedis,

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

fn slowlog_reset(&self) -> impl Future<Output = RedisResult<()>>

This command is used to reset the slow queries log.

impl SortedSetsInterface for RedisClient

Available on crate feature i-sorted-sets only.

fn bzmpop<R, K>( &self, timeout: f64, keys: K, sort: ZCmp, count: Option<i64>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<MultipleKeys>,

The blocking variant of Self::zmpop.

fn bzpopmin<R, K>( &self, keys: K, timeout: f64, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<MultipleKeys>,

The blocking variant of Self::zpopmin.

fn bzpopmax<R, K>( &self, keys: K, timeout: f64, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<MultipleKeys>,

The blocking variant of Self::zpopmax.

fn zadd<R, K, V>( &self, key: K, options: Option<SetOptions>, ordering: Option<Ordering>, changed: bool, incr: bool, values: V, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>,

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

fn zmpop<R, K>( &self, keys: K, sort: ZCmp, count: Option<i64>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<MultipleKeys>,

Pops one or more elements, that are member-score pairs, from the first non-empty sorted set in the provided list of key names.

fn zrandmember<R, K>( &self, key: K, count: Option<(i64, bool)>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, V: TryInto<RedisValue>, V::Error: Into<RedisError>,

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

fn zunion<R, K, W>( &self, keys: K, weights: W, aggregate: Option<AggregateOptions>, withscores: bool, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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

Available on crate feature i-streams only.

fn xinfo_consumers<R, K, S>( &self, key: K, groupname: S, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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>, ) -> impl Future<Output = RedisResult<Vec<XReadValue<Ri, Rk, Rv>>>>

where Ri: FromRedis, Rk: FromRedisKey + Hash + Eq, Rv: FromRedis, 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>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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>, ) -> impl Future<Output = RedisResult<Vec<XReadValue<Ri, Rk, Rv>>>>

where Ri: FromRedis, Rk: FromRedisKey + Hash + Eq, Rv: FromRedis, 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>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<XReadResponse<Rk1, Rk2, Rk3, Rv>>>

where Rk1: FromRedisKey + Hash + Eq, Rk2: FromRedis, Rk3: FromRedisKey + Hash + Eq, Rv: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<XReadResponse<Rk1, Rk2, Rk3, Rv>>>

where Rk1: FromRedisKey + Hash + Eq, Rk2: FromRedis, Rk3: FromRedisKey + Hash + Eq, Rv: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<Vec<XReadValue<Ri, Rk, Rv>>>>

where Ri: FromRedis, Rk: FromRedisKey + Hash + Eq, Rv: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<(String, Vec<XReadValue<Ri, Rk, Rv>>)>>

where Ri: FromRedis, Rk: FromRedisKey + Hash + Eq, Rv: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, 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, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, G: Into<Str>, A: Into<XPendingArgs>,

Inspect the list of pending messages in a consumer group.

impl TimeSeriesInterface for RedisClient

Available on crate feature i-time-series only.

fn ts_add<R, K, T, L>( &self, key: K, timestamp: T, value: f64, retention: Option<u64>, encoding: Option<Encoding>, chunk_size: Option<u64>, on_duplicate: Option<DuplicatePolicy>, labels: L, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, T: TryInto<Timestamp>, T::Error: Into<RedisError>, L: TryInto<RedisMap>, L::Error: Into<RedisError>,

Append a sample to a time series.

fn ts_alter<R, K, L>( &self, key: K, retention: Option<u64>, chunk_size: Option<u64>, duplicate_policy: Option<DuplicatePolicy>, labels: L, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, L: TryInto<RedisMap>, L::Error: Into<RedisError>,

Update the retention, chunk size, duplicate policy, and labels of an existing time series.

fn ts_create<R, K, L>( &self, key: K, retention: Option<u64>, encoding: Option<Encoding>, chunk_size: Option<u64>, duplicate_policy: Option<DuplicatePolicy>, labels: L, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, L: TryInto<RedisMap>, L::Error: Into<RedisError>,

Create a new time series.

fn ts_createrule<R, S, D>( &self, src: S, dest: D, aggregation: (Aggregator, u64), align_timestamp: Option<u64>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, S: Into<RedisKey>, D: Into<RedisKey>,

Create a compaction rule.

fn ts_decrby<R, K, L>( &self, key: K, subtrahend: f64, timestamp: Option<Timestamp>, retention: Option<u64>, uncompressed: bool, chunk_size: Option<u64>, labels: L, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, L: TryInto<RedisMap>, L::Error: Into<RedisError>,

Decrease the value of the sample with the maximum existing timestamp, or create a new sample with a value equal to the value of the sample with the maximum existing timestamp with a given decrement.

fn ts_del<R, K>( &self, key: K, from: i64, to: i64, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>,

Delete all samples between two timestamps for a given time series.

fn ts_deleterule<R, S, D>( &self, src: S, dest: D, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, S: Into<RedisKey>, D: Into<RedisKey>,

Delete a compaction rule.

fn ts_get<R, K>( &self, key: K, latest: bool, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>,

Get the sample with the highest timestamp from a given time series.

fn ts_incrby<R, K, L>( &self, key: K, addend: f64, timestamp: Option<Timestamp>, retention: Option<u64>, uncompressed: bool, chunk_size: Option<u64>, labels: L, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, L: TryInto<RedisMap>, L::Error: Into<RedisError>,

Increase the value of the sample with the maximum existing timestamp, or create a new sample with a value equal to the value of the sample with the maximum existing timestamp with a given increment.

fn ts_info<R, K>( &self, key: K, debug: bool, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>,

Return information and statistics for a time series.

fn ts_madd<R, K, I>(&self, samples: I) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, I: IntoIterator<Item = (K, Timestamp, f64)>,

Append new samples to one or more time series.

fn ts_mget<R, L, S, I>( &self, latest: bool, labels: Option<L>, filters: I, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, L: Into<GetLabels>, S: Into<Str>, I: IntoIterator<Item = S>,

Get the sample with the highest timestamp from each time series matching a specific filter.

fn ts_mrange<R, F, T, I, S, J>( &self, from: F, to: T, latest: bool, filter_by_ts: I, filter_by_value: Option<(i64, i64)>, labels: Option<GetLabels>, count: Option<u64>, aggregation: Option<RangeAggregation>, filters: J, group_by: Option<GroupBy>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, F: TryInto<GetTimestamp>, F::Error: Into<RedisError>, T: TryInto<GetTimestamp>, T::Error: Into<RedisError>, S: Into<Str>, I: IntoIterator<Item = i64>, J: IntoIterator<Item = S>,

Query a range across multiple time series by filters in the forward direction.

fn ts_mrevrange<R, F, T, I, S, J>( &self, from: F, to: T, latest: bool, filter_by_ts: I, filter_by_value: Option<(i64, i64)>, labels: Option<GetLabels>, count: Option<u64>, aggregation: Option<RangeAggregation>, filters: J, group_by: Option<GroupBy>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, F: TryInto<GetTimestamp>, F::Error: Into<RedisError>, T: TryInto<GetTimestamp>, T::Error: Into<RedisError>, S: Into<Str>, I: IntoIterator<Item = i64>, J: IntoIterator<Item = S>,

Query a range across multiple time series by filters in the reverse direction.

fn ts_queryindex<R, S, I>( &self, filters: I, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, S: Into<Str>, I: IntoIterator<Item = S>,

Get all time series keys matching a filter list.

fn ts_range<R, K, F, T, I>( &self, key: K, from: F, to: T, latest: bool, filter_by_ts: I, filter_by_value: Option<(i64, i64)>, count: Option<u64>, aggregation: Option<RangeAggregation>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, F: TryInto<GetTimestamp>, F::Error: Into<RedisError>, T: TryInto<GetTimestamp>, T::Error: Into<RedisError>, I: IntoIterator<Item = i64>,

Query a range in forward direction.

fn ts_revrange<R, K, F, T, I>( &self, key: K, from: F, to: T, latest: bool, filter_by_ts: I, filter_by_value: Option<(i64, i64)>, count: Option<u64>, aggregation: Option<RangeAggregation>, ) -> impl Future<Output = RedisResult<R>>

where R: FromRedis, K: Into<RedisKey>, F: TryInto<GetTimestamp>, F::Error: Into<RedisError>, T: TryInto<GetTimestamp>, T::Error: Into<RedisError>, I: IntoIterator<Item = i64>,

Query a range in reverse direction.

impl TrackingInterface for RedisClient

Available on crate feature i-tracking only.

fn start_tracking<P>( &self, prefixes: P, bcast: bool, optin: bool, optout: bool, noloop: bool, ) -> impl Future<Output = RedisResult<()>>

where P: Into<MultipleStrings>,

Send the CLIENT TRACKING command to all connected servers, subscribing to invalidation messages on the same connection.

fn stop_tracking(&self) -> impl Future<Output = RedisResult<()>>

Disable client tracking on all connections.

fn on_invalidation<F>(&self, func: F) -> JoinHandle<RedisResult<()>>

where F: Fn(Invalidation) -> RedisResult<()> + 'static,

Spawn a task that processes invalidation messages from the server.

fn invalidation_rx(&self) -> BroadcastReceiver<Invalidation>

Subscribe to invalidation messages from the server(s).

impl TransactionInterface for RedisClient

Available on crate feature transactions only.

fn multi(&self) -> Transaction

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