Struct Pool 

pub struct Pool { /* private fields */ }

A cheaply cloneable round-robin client pool.

Restrictions

The following interfaces are not implemented on Pool:

• MetricsInterface
• PubsubInterface
• EventInterface
• ClientInterface
• AuthInterface

In many cases, such as publish, callers can work around this by adding a call to next, but in some scenarios this may not work. As a general rule, any commands that change or depend on local connection state will not be implemented directly on Pool. Callers can use clients, next, or last to operate on individual clients if needed.

Implementations

impl Pool

pub fn from_clients(clients: Vec<Client>) -> Result<Self, Error>

Create a new pool from an existing set of clients.

pub fn new( config: Config, perf: Option<PerformanceConfig>, connection: Option<ConnectionConfig>, policy: Option<ReconnectPolicy>, size: usize, ) -> Result<Self, Error>

Create a new pool without connecting to the server.

See the builder interface for more information.

pub fn prefer_connected(&self, val: bool) -> bool

Set whether the client will use next_connected or next when routing commands among the pooled clients.

pub fn clients(&self) -> &[Client]

Read the individual clients in the pool.

pub fn connect_pool(&self) -> Vec<ConnectHandle>

Connect each client to the server, returning the task driving each connection.

Use the base connect function to return one handle that drives all connections via join.

pub fn size(&self) -> usize

Read the size of the pool.

pub fn next_connected(&self) -> &Client

Read the next connected client that should run the next command.

pub fn next(&self) -> &Client

Read the client that should run the next command.

pub fn last(&self) -> &Client

Read the client that ran the last command.

pub fn replicas(&self) -> Replicas<Client>

Available on crate feature replicas only.

Create a client that interacts with the replica nodes associated with the next client.

Trait Implementations

impl AclInterface for Pool

Available on crate feature i-acl only.

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

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

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

fn acl_load(&self) -> impl Future<Output = FredResult<()>> + Send

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 = FredResult<()>> + Send

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 = FredResult<R>> + Send

where R: FromValue,

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

fn acl_users<R>(&self) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue,

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

fn acl_getuser<R, U>( &self, username: U, ) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue, U: TryInto<Value> + Send, U::Error: Into<Error> + Send,

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

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

where R: FromValue, S: Into<MultipleStrings> + Send,

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 = FredResult<R>> + Send

where R: FromValue,

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 = FredResult<R>> + Send

where R: FromValue,

Generate a password with length bits, returning the password.

fn acl_whoami<R>(&self) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue,

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 = FredResult<R>> + Send

where R: FromValue,

Read count recent ACL security events.

fn acl_log_reset(&self) -> impl Future<Output = FredResult<()>> + Send

Clear the ACL security events logs.

impl ClientInterface for Pool

Available on crate feature i-client only.

fn client_id<R>(&self) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue,

Return the ID of the current connection.

fn connection_ids(&self) -> HashMap<Server, i64>

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

fn client_info<R>(&self) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue,

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 = FredResult<R>> + Send

where R: FromValue,

Close a given connection or set of connections.

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

where R: FromValue,

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 = FredResult<R>> + Send

where R: FromValue,

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 = FredResult<()>> + Send

where S: Into<Str> + Send,

Assign a name to the current connection.

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

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 = FredResult<()>> + Send

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 = FredResult<()>> + Send

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 = FredResult<R>> + Send

where R: FromValue, S: Into<Value> + Send,

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 = FredResult<()>> + Send

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

fn echo<R, M>(&self, message: M) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue, M: TryInto<Value> + Send, M::Error: Into<Error> + Send,

Returns message.

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 = FredResult<R>> + Send

where R: FromValue, T: TryInto<Toggle> + Send, T::Error: Into<Error> + Send, P: Into<MultipleStrings> + Send,

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 = FredResult<R>> + Send

where R: FromValue,

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 = FredResult<R>> + Send

where R: FromValue,

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 = FredResult<R>> + Send

where R: FromValue,

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 Pool

fn update_perf_config(&self, config: PerformanceConfig)

Update the internal PerformanceConfig on each client in place with new values.

fn active_connections(&self) -> Vec<Server>

Read the set of active connections across all clients in the pool.

This may contain duplicates when separate clients are connected to the same server.

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

Available on crate feature dns only.

Override the DNS resolution logic for all clients in the pool.

fn connect(&self) -> ConnectHandle

Connect each client to the server.

This function returns a JoinHandle to a task that drives all connections via join.

See connect_pool for a variation of this function that separates the connection tasks.

See init for an alternative shorthand.

fn force_reconnection(&self) -> impl Future<Output = FredResult<()>> + Send

Force a reconnection to the server(s) for each client.

When running against a cluster this function will also refresh the cached cluster routing table.

fn wait_for_connect(&self) -> impl Future<Output = FredResult<()>> + Send

Wait for all the clients to connect to the server.

fn init(&self) -> impl Future<Output = FredResult<ConnectHandle>> + Send

Initialize a new routing and connection task for each client and wait for them to connect successfully.

The returned ConnectHandle refers to the task that drives the routing and connection layer for each client via join. It will not finish until the max reconnection count is reached.

Callers can also use connect and wait_for_connect separately if needed.

use fred::prelude::*;

#[tokio::main]
async fn main() -> Result<(), Error> {
  let pool = Builder::default_centralized().build_pool(5)?;
  let connection_task = pool.init().await?;

  // ...

  pool.quit().await?;
  connection_task.await?
}

fn quit(&self) -> impl Future<Output = FredResult<()>> + Send

Close the connection to the Redis server for each client. 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.

This function will also close all error, pubsub message, and reconnection event streams on all clients in the pool.

fn id(&self) -> &str

The unique ID identifying this client and underlying connections.

fn client_config(&self) -> Config

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_clustered(&self) -> bool

Whether the client is connected to a cluster.

fn uses_sentinels(&self) -> bool

Whether the client uses the sentinel interface.

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 server_version(&self) -> Option<Version>

Read the server version, if known.

fn shutdown( &self, flags: Option<ShutdownFlags>, ) -> impl Future<Output = FredResult<()>> + Send

Available on crate feature i-server only.

Shut down the server and quit the client.

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

where R: FromValue,

Delete the keys in all databases.

fn flushall_cluster(&self) -> impl Future<Output = FredResult<()>> + Send

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

fn ping<R>( &self, message: Option<String>, ) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue,

Ping the server.

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

where R: FromValue,

Read info about the server.

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

where R: FromValue, T: TryInto<Value> + Send, T::Error: Into<Error> + Send,

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 = FredResult<Resp3Frame>> + Send

where T: TryInto<Value> + Send, T::Error: Into<Error> + Send,

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 Pool

fn clone(&self) -> Pool

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ClusterInterface for Pool

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<(), Error>> + Send

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

fn cluster_bumpepoch<R>(&self) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue,

Advances the cluster config epoch.

fn cluster_flushslots(&self) -> impl Future<Output = FredResult<()>> + Send

Deletes all slots from a node.

fn cluster_myid<R>(&self) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue,

Returns the node’s id.

fn cluster_nodes<R>(&self) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue,

Read the current cluster node configuration.

fn cluster_saveconfig(&self) -> impl Future<Output = FredResult<()>> + Send

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

fn cluster_slots<R>(&self) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue,

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

fn cluster_info<R>(&self) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue,

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

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

where S: Into<MultipleHashSlots> + Send,

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 = FredResult<R>> + Send

where R: FromValue, S: Into<Str> + Send,

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 = FredResult<R>> + Send

where R: FromValue,

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

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

where S: Into<MultipleHashSlots> + Send,

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 = FredResult<()>> + Send

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 = FredResult<()>> + Send

where S: Into<Str> + Send,

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 = FredResult<R>> + Send

where R: FromValue,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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

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

where S: Into<Str> + Send,

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 = FredResult<()>> + Send

where S: Into<Str> + Send,

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 = FredResult<R>> + Send

where R: FromValue, S: Into<Str> + Send,

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

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

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 = FredResult<()>> + Send

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

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

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

impl ConfigInterface for Pool

Available on crate feature i-config only.

fn config_resetstat(&self) -> impl Future<Output = FredResult<()>> + Send

Resets the statistics reported by Redis using the INFO command.

fn config_rewrite(&self) -> impl Future<Output = FredResult<()>> + Send

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 = FredResult<R>> + Send

where R: FromValue, S: Into<Str> + Send,

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 = FredResult<()>> + Send

where P: Into<Str> + Send, V: TryInto<Value> + Send, V::Error: Into<Error> + Send,

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

impl Debug for Pool

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

Formats the value using the given formatter.

impl FunctionInterface for Pool

Available on crate feature i-scripts only.

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

where R: FromValue, F: Into<Str> + Send, K: Into<MultipleKeys> + Send, V: TryInto<MultipleValues> + Send, V::Error: Into<Error> + Send,

Invoke a function.

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

where R: FromValue, F: Into<Str> + Send, K: Into<MultipleKeys> + Send, V: TryInto<MultipleValues> + Send, V::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, S: Into<Str> + Send,

Delete a library and all its functions.

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

where S: Into<Str> + Send,

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

fn function_dump<R>(&self) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue,

Return the serialized payload of loaded libraries.

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

where R: FromValue,

Deletes all the libraries.

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

Deletes all the libraries on all cluster nodes concurrently.

fn function_kill<R>(&self) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue,

Kill a function that is currently executing.

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

where R: FromValue, S: Into<Str> + Send,

Return information about the functions and libraries.

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

where R: FromValue, S: Into<Str> + Send,

Load a library to Redis.

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

where R: FromValue, S: Into<Str> + Send,

Load a library to Redis on all cluster nodes concurrently.

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

where R: FromValue, B: Into<Bytes> + Send, P: TryInto<FnPolicy> + Send, P::Error: Into<Error> + Send,

Restore libraries from the serialized payload.

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

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

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

fn function_stats<R>(&self) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue,

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

impl GeoInterface for Pool

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, V: Into<MultipleGeoValues> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, V: TryInto<MultipleValues> + Send, V::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, V: TryInto<MultipleValues> + Send, V::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, S: TryInto<Value> + Send, S::Error: Into<Error> + Send, D: TryInto<Value> + Send, D::Error: Into<Error> + Send,

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<Key>, storedist: Option<Key>, ) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, P: Into<GeoPosition> + Send,

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<Key>, storedist: Option<Key>, ) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, V: TryInto<Value> + Send, V::Error: Into<Error> + Send,

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<Value>, 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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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<Value>, 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 = FredResult<R>> + Send

where R: FromValue, D: Into<Key> + Send, S: Into<Key> + Send,

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 Pool

Available on crate feature i-hashes only.

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

where R: FromValue, K: Into<Key> + Send,

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

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

where R: FromValue, K: Into<Key> + Send, F: Into<MultipleKeys> + Send,

Removes the specified fields from the hash stored at key.

fn hexists<R, K, F>( &self, key: K, field: F, ) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, F: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, F: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, F: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, F: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

Returns all field names in the hash stored at key.

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

where R: FromValue, K: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, F: Into<MultipleKeys> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, V: TryInto<Map> + Send, V::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, V: TryInto<Map> + Send, V::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, F: Into<Key> + Send, V: TryInto<Value> + Send, V::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, F: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

Returns all values in the hash stored at key.

fn httl<R, K, F>( &self, key: K, fields: F, ) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, F: Into<MultipleKeys> + Send,

Available on crate feature i-hexpire only.

Returns the remaining TTL (time to live) of a hash key’s field(s) that have a set expiration.

fn hexpire<R, K, F>( &self, key: K, seconds: i64, options: Option<ExpireOptions>, fields: F, ) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, F: Into<MultipleKeys> + Send,

Available on crate feature i-hexpire only.

Set an expiration (TTL or time to live) on one or more fields of a given hash key.

fn hexpire_at<R, K, F>( &self, key: K, time: i64, options: Option<ExpireOptions>, fields: F, ) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, F: Into<MultipleKeys> + Send,

Available on crate feature i-hexpire only.

HEXPIREAT has the same effect and semantics as HEXPIRE, but instead of specifying the number of seconds for the TTL (time to live), it takes an absolute Unix timestamp in seconds since Unix epoch.

fn hexpire_time<R, K, F>( &self, key: K, fields: F, ) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, F: Into<MultipleKeys> + Send,

Available on crate feature i-hexpire only.

Returns the absolute Unix timestamp in seconds since Unix epoch at which the given key’s field(s) will expire.

fn hpttl<R, K, F>( &self, key: K, fields: F, ) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, F: Into<MultipleKeys> + Send,

Available on crate feature i-hexpire only.

Like HTTL, this command returns the remaining TTL (time to live) of a field that has an expiration set, but in milliseconds instead of seconds.

fn hpexpire<R, K, F>( &self, key: K, milliseconds: i64, options: Option<ExpireOptions>, fields: F, ) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, F: Into<MultipleKeys> + Send,

Available on crate feature i-hexpire only.

This command works like HEXPIRE, but the expiration of a field is specified in milliseconds instead of seconds.

fn hpexpire_at<R, K, F>( &self, key: K, time: i64, options: Option<ExpireOptions>, fields: F, ) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, F: Into<MultipleKeys> + Send,

Available on crate feature i-hexpire only.

HPEXPIREAT has the same effect and semantics as HEXPIREAT, but the Unix time at which the field will expire is specified in milliseconds since Unix epoch instead of seconds.

fn hpexpire_time<R, K, F>( &self, key: K, fields: F, ) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, F: Into<MultipleKeys> + Send,

Available on crate feature i-hexpire only.

HPEXPIRETIME has the same semantics as HEXPIRETIME, but returns the absolute Unix expiration timestamp in milliseconds since Unix epoch instead of seconds.

fn hpersist<R, K, F>( &self, key: K, fields: F, ) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, F: Into<MultipleKeys> + Send,

Available on crate feature i-hexpire only.

Remove the existing expiration on a hash key’s field(s), turning the field(s) from volatile (a field with expiration set) to persistent (a field that will never expire as no TTL (time to live) is associated).

impl HeartbeatInterface for Pool

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

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

impl HyperloglogInterface for Pool

Available on crate feature i-hyperloglog only.

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

where R: FromValue, K: Into<Key> + Send, V: TryInto<MultipleValues> + Send, V::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<MultipleKeys> + Send,

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 = FredResult<R>> + Send

where R: FromValue, D: Into<Key> + Send, S: Into<MultipleKeys> + Send,

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 Pool

Available on crate feature i-keys only.

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

where K: Into<MultipleKeys> + Send,

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

fn unwatch(&self) -> impl Future<Output = FredResult<()>> + Send

Flushes all the previously watched keys for a transaction.

fn randomkey<R>(&self) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue,

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 = FredResult<R>> + Send

where R: FromValue, S: Into<Key> + Send, D: Into<Key> + Send,

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

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

where R: FromValue, K: Into<Key> + Send,

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

fn type<R, K>(&self, key: K) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

Returns the string representation of the type of the value stored at key. The different types that can be returned are: string, list, set, zset, hash and stream.

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

where R: FromValue, K: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, V: TryInto<Value> + Send, V::Error: Into<Error> + Send,

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

fn setnx<R, K, V>( &self, key: K, value: V, ) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, V: TryInto<Value> + Send, V::Error: Into<Error> + Send,

Sets key to value if key does not exist.

fn get<R, K>(&self, key: K) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

Read a value from the server.

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

where R: FromValue, K: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, V: TryInto<Value> + Send, V::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, V: TryInto<Value> + Send, V::Error: Into<Error> + Send,

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

fn getdel<R, K>(&self, key: K) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<MultipleKeys> + Send,

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

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

where R: FromValue, K: Into<MultipleKeys> + Send,

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 = FredResult<R>> + Send

where R: FromValue, S: Into<Key> + Send, D: Into<Key> + Send,

Renames source key to destination.

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

where R: FromValue, S: Into<Key> + Send, D: Into<Key> + Send,

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

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

where R: FromValue, K: Into<Key> + Send, V: TryInto<Value> + Send, V::Error: Into<Error> + Send,

Append value to key if it’s a string.

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

where R: FromValue, K: Into<MultipleKeys> + Send,

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 = FredResult<()>> + Send

where V: TryInto<Map> + Send, V::Error: Into<Error> + Send,

Sets the given keys to their respective values.

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

where R: FromValue, V: TryInto<Map> + Send, V::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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, options: Option<ExpireOptions>, ) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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, options: Option<ExpireOptions>, ) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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

fn expire_time<R, K>( &self, key: K, ) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

Returns the absolute Unix timestamp (since January 1, 1970) in seconds at which the given key will expire.

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

where R: FromValue, K: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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 pexpire_time<R, K>( &self, key: K, ) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

PEXPIRETIME has the same semantic as EXPIRETIME, but returns the absolute Unix expiration timestamp in milliseconds instead of seconds.

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

where R: FromValue, K: Into<MultipleKeys> + Send,

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, Error>> + Send

where R: FromValue, K1: Into<Key> + Send, K2: Into<Key> + Send,

Runs the longest common subsequence algorithm on two keys.

fn scan_page<R, S, P>( &self, cursor: S, pattern: P, count: Option<u32>, type: Option<ScanType>, ) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue, S: Into<Str> + Send, P: Into<Str> + Send,

Fetch one page of SCAN results with the provided cursor.

impl ListInterface for Pool

Available on crate feature i-lists only.

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

where R: FromValue, K: Into<MultipleKeys> + Send,

The blocking variant of Self::lmpop.

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

where R: FromValue, K: Into<MultipleKeys> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<MultipleKeys> + Send,

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 = FredResult<R>> + Send

where R: FromValue, S: Into<Key> + Send, D: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, S: Into<Key> + Send, D: Into<Key> + Send,

The blocking equivalent of Self::lmove.

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

where R: FromValue, K: Into<MultipleKeys> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, P: TryInto<Value> + Send, P::Error: Into<Error> + Send, V: TryInto<Value> + Send, V::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

Returns the length of the list stored at key.

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

where R: FromValue, K: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, V: TryInto<Value> + Send, V::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, V: TryInto<MultipleValues> + Send, V::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, V: TryInto<MultipleValues> + Send, V::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, V: TryInto<Value> + Send, V::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, V: TryInto<Value> + Send, V::Error: Into<Error> + Send,

Sets the list element at index to element.

fn ltrim<R, K>( &self, key: K, start: i64, stop: i64, ) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, S: Into<Key> + Send, D: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, S: Into<Key> + Send, D: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, V: TryInto<MultipleValues> + Send, V::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, V: TryInto<MultipleValues> + Send, V::Error: Into<Error> + Send,

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<Key>, ) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, S: Into<MultipleStrings> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, S: Into<MultipleStrings> + Send,

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 Pool

Available on crate feature i-scripts only.

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

where R: FromValue, S: Into<Str> + Send,

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_kill(&self) -> impl Future<Output = FredResult<()>> + Send

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

fn script_kill_cluster(&self) -> impl Future<Output = FredResult<()>> + Send

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 = FredResult<()>> + Send

Flush the Lua scripts cache.

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

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 = FredResult<R>> + Send

where R: FromValue, H: Into<MultipleStrings> + Send,

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

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

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 = FredResult<R>> + Send

where R: FromValue, S: Into<Str> + Send, K: Into<MultipleKeys> + Send, V: TryInto<MultipleValues> + Send, V::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, S: Into<Str> + Send, K: Into<MultipleKeys> + Send, V: TryInto<MultipleValues> + Send, V::Error: Into<Error> + Send,

Evaluate a Lua script on the server.

impl MemoryInterface for Pool

Available on crate feature i-memory only.

fn memory_doctor<R>(&self) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue,

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 = FredResult<R>> + Send

where R: FromValue,

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

fn memory_purge(&self) -> impl Future<Output = FredResult<()>> + Send

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 = FredResult<R>> + Send

where R: FromValue,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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

impl RediSearchInterface for Pool

Available on crate feature i-redisearch only.

fn ft_list<R>(&self) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue,

Returns a list of all existing indexes.

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

where R: FromValue, I: Into<Str> + Send, Q: Into<Str> + Send,

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 = FredResult<R>> + Send

where R: FromValue, I: Into<Str> + Send, Q: Into<Str> + Send,

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 = FredResult<R>> + Send

where R: FromValue, I: Into<Str> + Send,

Create an index with the given specification.

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

where R: FromValue, I: Into<Str> + Send,

Add a new attribute to the index.

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

where R: FromValue, A: Into<Str> + Send, I: Into<Str> + Send,

Add an alias to an index.

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

where R: FromValue, A: Into<Str> + Send,

Remove an alias from an index.

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

where R: FromValue, A: Into<Str> + Send, I: Into<Str> + Send,

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 = FredResult<R>> + Send

where R: FromValue, S: Into<Str> + Send,

Retrieve configuration options.

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

where R: FromValue, S: Into<Str> + Send, V: TryInto<Value> + Send, V::Error: Into<Error> + Send,

Set the value of a RediSearch configuration parameter.

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

where R: FromValue, I: Into<Str> + Send, C: TryInto<Value> + Send, C::Error: Into<Error> + Send,

Delete a cursor.

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

where R: FromValue, I: Into<Str> + Send, C: TryInto<Value> + Send, C::Error: Into<Error> + Send,

Read next results from an existing cursor.

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

where R: FromValue, D: Into<Str> + Send, S: Into<MultipleStrings> + Send,

Add terms to a dictionary.

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

where R: FromValue, D: Into<Str> + Send, S: Into<MultipleStrings> + Send,

Remove terms from a dictionary.

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

where R: FromValue, D: Into<Str> + Send,

Dump all terms in the given dictionary.

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

where R: FromValue, I: Into<Str> + Send,

Delete an index.

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

where R: FromValue, I: Into<Str> + Send, Q: Into<Str> + Send,

Return the execution plan for a complex query.

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

where R: FromValue, I: Into<Str> + Send,

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 = FredResult<R>> + Send

where R: FromValue, I: Into<Str> + Send, Q: Into<Str> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, S: Into<Str> + Send,

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

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

where R: FromValue, K: Into<Key> + Send, S: Into<Str> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, P: Into<Str> + Send,

Get completion suggestions for a prefix.

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

where R: FromValue, K: Into<Key> + Send,

Get the size of an auto-complete suggestion dictionary.

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

where R: FromValue, I: Into<Str> + Send,

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 = FredResult<R>> + Send

where R: FromValue, I: Into<Str> + Send, S: Into<Str> + Send, T: Into<MultipleStrings> + Send,

Update a synonym group.

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

where R: FromValue, I: Into<Str> + Send, F: Into<Str> + Send,

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

impl RedisJsonInterface for Pool

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, P: Into<Str> + Send, V: Into<Value> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, P: Into<Str> + Send, V: Into<Value> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, P: Into<Str> + Send, V: Into<Value> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, P: Into<Str> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, P: Into<Str> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, P: Into<Str> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, P: Into<Str> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, P: Into<Str> + Send,

Report a value’s memory usage in bytes

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

where R: FromValue, K: Into<Key> + Send, P: Into<Str> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, I: Into<Str> + Send, N: Into<Str> + Send, S: Into<Str> + Send, P: Into<MultipleStrings> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, P: Into<Str> + Send, V: Into<Value> + Send,

Merge a given JSON value into matching paths.

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

where R: FromValue, K: Into<MultipleKeys> + Send, P: Into<Str> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, P: Into<Str> + Send, V: Into<Value> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, P: Into<Str> + Send, V: Into<Value> + Send,

Increment the number value stored at path by number

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

where R: FromValue, K: Into<Key> + Send, P: Into<Str> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, P: Into<Str> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, P: Into<Str> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, P: Into<Str> + Send, V: Into<Value> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, P: Into<Str> + Send, V: Into<Value> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, P: Into<Str> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, P: Into<Str> + Send,

Toggle a Boolean value stored at path.

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

where R: FromValue, K: Into<Key> + Send, P: Into<Str> + Send,

Report the type of JSON value at path.

impl ServerInterface for Pool

Available on crate feature i-server only.

fn bgrewriteaof<R>(&self) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue,

Instruct Redis to start an Append Only File rewrite process.

fn bgsave<R>(&self) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue,

Save the DB in background.

fn dbsize<R>(&self) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue,

Return the number of keys in the selected database.

fn select<I>(&self, index: I) -> impl Future<Output = FredResult<()>> + Send

where I: TryInto<Value> + Send, I::Error: Into<Error> + Send,

Select the database this client should use.

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

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 = FredResult<R>> + Send

where R: FromValue,

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, Error>> + Send

where R: FromValue,

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 Pool

Available on crate feature i-sets only.

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

where R: FromValue, K: Into<Key> + Send, V: TryInto<MultipleValues> + Send, V::Error: Into<Error> + Send,

Add the specified members to the set stored at key.

fn scard<R, K>(&self, key: K) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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

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

where R: FromValue, K: Into<MultipleKeys> + Send,

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 = FredResult<R>> + Send

where R: FromValue, D: Into<Key> + Send, K: Into<MultipleKeys> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<MultipleKeys> + Send,

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 = FredResult<R>> + Send

where R: FromValue, D: Into<Key> + Send, K: Into<MultipleKeys> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, V: TryInto<Value> + Send, V::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, V: TryInto<MultipleValues> + Send, V::Error: Into<Error> + Send,

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

fn smembers<R, K>(&self, key: K) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, S: Into<Key> + Send, D: Into<Key> + Send, V: TryInto<Value> + Send, V::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, V: TryInto<MultipleValues> + Send, V::Error: Into<Error> + Send,

Remove the specified members from the set stored at key.

fn sunion<R, K>(&self, keys: K) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue, K: Into<MultipleKeys> + Send,

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 = FredResult<R>> + Send

where R: FromValue, D: Into<Key> + Send, K: Into<MultipleKeys> + Send,

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

impl SlowlogInterface for Pool

Available on crate feature i-slowlog only.

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

where R: FromValue,

This command is used to read the slow queries log.

fn slowlog_length<R>(&self) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue,

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

fn slowlog_reset(&self) -> impl Future<Output = FredResult<()>> + Send

This command is used to reset the slow queries log.

impl SortedSetsInterface for Pool

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 = FredResult<R>> + Send

where R: FromValue, K: Into<MultipleKeys> + Send,

The blocking variant of Self::zmpop.

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

where R: FromValue, K: Into<MultipleKeys> + Send,

The blocking variant of Self::zpopmin.

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

where R: FromValue, K: Into<MultipleKeys> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, V: TryInto<MultipleZaddValues> + Send, V::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<MultipleKeys> + Send,

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 = FredResult<R>> + Send

where R: FromValue, D: Into<Key> + Send, K: Into<MultipleKeys> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, V: TryInto<Value> + Send, V::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<MultipleKeys> + Send, W: Into<MultipleWeights> + Send,

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 = FredResult<R>> + Send

where R: FromValue, D: Into<Key> + Send, K: Into<MultipleKeys> + Send, W: Into<MultipleWeights> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, M: TryInto<ZRange> + Send, M::Error: Into<Error> + Send, N: TryInto<ZRange> + Send, N::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<MultipleKeys> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, D: Into<Key> + Send, S: Into<Key> + Send, M: TryInto<ZRange> + Send, M::Error: Into<Error> + Send, N: TryInto<ZRange> + Send, N::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, M: TryInto<ZRange> + Send, M::Error: Into<Error> + Send, N: TryInto<ZRange> + Send, N::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, M: TryInto<ZRange> + Send, M::Error: Into<Error> + Send, N: TryInto<ZRange> + Send, N::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, M: TryInto<ZRange> + Send, M::Error: Into<Error> + Send, N: TryInto<ZRange> + Send, N::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, M: TryInto<ZRange> + Send, M::Error: Into<Error> + Send, N: TryInto<ZRange> + Send, N::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, M: TryInto<ZRange> + Send, M::Error: Into<Error> + Send, N: TryInto<ZRange> + Send, N::Error: Into<Error> + Send,

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, withscore: bool, ) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, V: TryInto<Value> + Send, V::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, V: TryInto<MultipleValues> + Send, V::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, M: TryInto<ZRange> + Send, M::Error: Into<Error> + Send, N: TryInto<ZRange> + Send, N::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, M: TryInto<ZRange> + Send, M::Error: Into<Error> + Send, N: TryInto<ZRange> + Send, N::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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

fn zrevrank<R, K, V>( &self, key: K, member: V, withscore: bool, ) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, V: TryInto<Value> + Send, V::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, V: TryInto<Value> + Send, V::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<MultipleKeys> + Send, W: Into<MultipleWeights> + Send,

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 = FredResult<R>> + Send

where R: FromValue, D: Into<Key> + Send, K: Into<MultipleKeys> + Send, W: Into<MultipleWeights> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, V: TryInto<MultipleValues> + Send, V::Error: Into<Error> + Send,

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

impl StreamsInterface for Pool

Available on crate feature i-streams only.

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

where R: FromValue, K: Into<Key> + Send, S: Into<Str> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, I: Into<XID> + Send, F: TryInto<MultipleOrderedPairs> + Send, F::Error: Into<Error> + Send, C: TryInto<XCap> + Send, C::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, C: TryInto<XCap> + Send, C::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, S: Into<MultipleStrings> + Send,

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 = FredResult<Vec<XReadValue<Ri, Rk, Rv>>>> + Send

where Ri: FromValue, Rk: FromKey + Hash + Eq, Rv: FromValue, K: Into<Key> + Send, S: TryInto<Value> + Send, S::Error: Into<Error> + Send, E: TryInto<Value> + Send, E::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, S: TryInto<Value> + Send, S::Error: Into<Error> + Send, E: TryInto<Value> + Send, E::Error: Into<Error> + Send,

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 = FredResult<Vec<XReadValue<Ri, Rk, Rv>>>> + Send

where Ri: FromValue, Rk: FromKey + Hash + Eq, Rv: FromValue, K: Into<Key> + Send, S: TryInto<Value> + Send, S::Error: Into<Error> + Send, E: TryInto<Value> + Send, E::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, S: TryInto<Value> + Send, S::Error: Into<Error> + Send, E: TryInto<Value> + Send, E::Error: Into<Error> + Send,

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

fn xlen<R, K>(&self, key: K) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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 = FredResult<XReadResponse<Rk1, Rk2, Rk3, Rv>>> + Send

where Rk1: FromKey + Hash + Eq, Rk2: FromValue, Rk3: FromKey + Hash + Eq, Rv: FromValue, K: Into<MultipleKeys> + Send, I: Into<MultipleIDs> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<MultipleKeys> + Send, I: Into<MultipleIDs> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, S: Into<Str> + Send, I: Into<XID> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, G: Into<Str> + Send, C: Into<Str> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, G: Into<Str> + Send, C: Into<Str> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, S: Into<Str> + Send,

Completely destroy a consumer group.

fn xgroup_setid<R, K, S, I>( &self, key: K, groupname: S, id: I, ) -> impl Future<Output = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, S: Into<Str> + Send, I: Into<XID> + Send,

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 = FredResult<XReadResponse<Rk1, Rk2, Rk3, Rv>>> + Send

where Rk1: FromKey + Hash + Eq, Rk2: FromValue, Rk3: FromKey + Hash + Eq, Rv: FromValue, G: Into<Str> + Send, C: Into<Str> + Send, K: Into<MultipleKeys> + Send, I: Into<MultipleIDs> + Send,

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 = FredResult<R>> + Send

where R: FromValue, G: Into<Str> + Send, C: Into<Str> + Send, K: Into<MultipleKeys> + Send, I: Into<MultipleIDs> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, G: Into<Str> + Send, I: Into<MultipleIDs> + Send,

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 = FredResult<Vec<XReadValue<Ri, Rk, Rv>>>> + Send

where Ri: FromValue, Rk: FromKey + Hash + Eq, Rv: FromValue, K: Into<Key> + Send, G: Into<Str> + Send, C: Into<Str> + Send, I: Into<MultipleIDs> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, G: Into<Str> + Send, C: Into<Str> + Send, I: Into<MultipleIDs> + Send,

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 = FredResult<(String, Vec<XReadValue<Ri, Rk, Rv>>)>> + Send

where Ri: FromValue, Rk: FromKey + Hash + Eq, Rv: FromValue, K: Into<Key> + Send, G: Into<Str> + Send, C: Into<Str> + Send, I: Into<XID> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, G: Into<Str> + Send, C: Into<Str> + Send, I: Into<XID> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, G: Into<Str> + Send, A: Into<XPendingArgs> + Send,

Inspect the list of pending messages in a consumer group.

impl TimeSeriesInterface for Pool

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, T: TryInto<Timestamp> + Send, T::Error: Into<Error> + Send, L: TryInto<Map> + Send, L::Error: Into<Error>,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, L: TryInto<Map> + Send, L::Error: Into<Error>,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, L: TryInto<Map> + Send, L::Error: Into<Error>,

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 = FredResult<R>> + Send

where R: FromValue, S: Into<Key> + Send, D: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, L: TryInto<Map> + Send, L::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, S: Into<Key> + Send, D: Into<Key> + Send,

Delete a compaction rule.

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

where R: FromValue, K: Into<Key> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, L: TryInto<Map> + Send, L::Error: Into<Error> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send,

Return information and statistics for a time series.

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

where R: FromValue, K: Into<Key> + Send, I: IntoIterator<Item = (K, Timestamp, f64)> + Send,

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 = FredResult<R>> + Send

where R: FromValue, L: Into<GetLabels> + Send, S: Into<Str> + Send, I: IntoIterator<Item = S> + Send,

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 = FredResult<R>> + Send

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

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 = FredResult<R>> + Send

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

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 = FredResult<R>> + Send

where R: FromValue, S: Into<Str> + Send, I: IntoIterator<Item = S> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, F: TryInto<GetTimestamp> + Send, F::Error: Into<Error> + Send, T: TryInto<GetTimestamp> + Send, T::Error: Into<Error> + Send, I: IntoIterator<Item = i64> + Send,

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 = FredResult<R>> + Send

where R: FromValue, K: Into<Key> + Send, F: TryInto<GetTimestamp> + Send, F::Error: Into<Error> + Send, T: TryInto<GetTimestamp> + Send, T::Error: Into<Error> + Send, I: IntoIterator<Item = i64> + Send,

Query a range in reverse direction.

impl TransactionInterface for Pool

Available on crate feature transactions only.

fn multi(&self) -> Transaction

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