Skip to main content

GlideClusterClient

Struct GlideClusterClient 

Source
pub struct GlideClusterClient { /* private fields */ }
Expand description

An async client for a cluster Valkey/Redis deployment.

Mirrors Python GlideClusterClient. Commands are routed automatically by the core based on their keys; use the *_with_route helpers (or crate::CustomCommand::custom_command_with_route) to override routing.

Implementations§

Source§

impl GlideClusterClient

Source

pub async fn connect( config: GlideClusterClientConfiguration, ) -> ValkeyResult<Self>

Connect using the given cluster configuration.

Source

pub async fn get_pubsub_message(&self) -> ValkeyResult<PubSubMessage>

Wait for the next Pub/Sub message (including shard messages) on this client’s configured subscriptions.

Source

pub async fn try_get_pubsub_message( &self, ) -> ValkeyResult<Option<PubSubMessage>>

Try to get the next Pub/Sub message without blocking. Returns None if no message is currently available.

Source

pub async fn route_command( &self, cmd: Cmd, route: Route, ) -> ValkeyResult<ValkeyValue>

Execute a raw command with an explicit route.

Source

pub async fn exec( &self, pipeline: &Pipeline, raise_on_error: bool, route: Option<Route>, options: &PipelineOptions, ) -> ValkeyResult<Vec<ValkeyValue>>

Execute a crate::Pipeline with GLIDE execution options, optionally routed. See crate::GlideClient::exec.

Source

pub async fn update_connection_password( &self, password: Option<String>, immediate_auth: bool, ) -> ValkeyResult<()>

Update the password used by this client to authenticate with the cluster, without changing the server-side password (update_connection_password).

The new password is stored and used for all future (re)connections to every node. Pass None to clear a previously-set password. When immediate_auth is true, an AUTH is issued right away and the call errors if rejected; when false, it applies on the next reconnection.

Mirrors Python’s update_connection_password.

Source

pub async fn cluster_scan( &self, cursor: &ClusterScanCursor, match_pattern: Option<&[u8]>, count: Option<u32>, object_type: Option<ObjectType>, ) -> ValkeyResult<(ClusterScanCursor, Vec<Bytes>)>

Incrementally iterate the entire keyspace of a cluster (SCAN for cluster). Returns the next ClusterScanCursor and the batch of keys found. Iteration is complete when the returned cursor’s ClusterScanCursor::is_finished is true.

Unlike standalone SCAN, the cluster scan is coordinated by glide-core across all shards using an opaque cursor.

Trait Implementations§

Source§

impl Clone for GlideClusterClient

Source§

fn clone(&self) -> Self

Returns a duplicate of the value. Read more
1.0.0 (const: unstable) · Source§

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

Performs copy-assignment from source. Read more
Source§

impl CommandExecutor for GlideClusterClient

Source§

fn execute_command<'life0, 'async_trait>( &'life0 self, cmd: Cmd, route: Option<Route>, ) -> Pin<Box<dyn Future<Output = ValkeyResult<ValkeyValue>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Execute cmd, optionally routed to a specific node/set of nodes (cluster). Standalone implementations ignore route.

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> AsyncCommands for T
where T: CommandDispatch,

Source§

fn glide_send_command<'a>(&'a self, cmd: Cmd) -> ValkeyFuture<'a, ValkeyValue>

Send an already-built command by value (no clone). A zero-extra-copy escape hatch for custom commands with large payloads. Read more
Source§

fn glide_send_command_as<'a, RV: FromValkeyValue>( &'a self, cmd: Cmd, ) -> ValkeyFuture<'a, RV>

Typed escape hatch: send an already-built Cmd by value and decode the reply into RV. An alternative to cmd(...).query_async(con) (Cmd::query_async delegates here) — same decode, no connection-object machinery, no payload copy. Read more
Source§

fn get<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

GET.
Source§

fn mget<'a, K: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

MGET.
Source§

fn set<'a, K: ToSingleValkeyArg + Send + Sync + 'a, V: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, value: V, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

SET.
Source§

fn set_options<'a, K: ToSingleValkeyArg + Send + Sync + 'a, V: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, value: V, options: SetOptions, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

SET.
Source§

fn mset<'a, K: ToValkeyArgs + Send + Sync + 'a, V: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, items: &'a [(K, V)], ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

MSET.
Source§

fn set_ex<'a, K: ToSingleValkeyArg + Send + Sync + 'a, V: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, value: V, seconds: u64, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

SETEX.
Source§

fn pset_ex<'a, K: ToSingleValkeyArg + Send + Sync + 'a, V: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, value: V, milliseconds: u64, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

PSETEX.
Source§

fn set_nx<'a, K: ToSingleValkeyArg + Send + Sync + 'a, V: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, value: V, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

SETNX.
Source§

fn mset_nx<'a, K: ToValkeyArgs + Send + Sync + 'a, V: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, items: &'a [(K, V)], ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

MSETNX.
Source§

fn getset<'a, K: ToSingleValkeyArg + Send + Sync + 'a, V: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, value: V, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

GETSET.
Source§

fn getrange<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, from: isize, to: isize, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

GETRANGE.
Source§

fn setrange<'a, K: ToSingleValkeyArg + Send + Sync + 'a, V: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, offset: isize, value: V, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

SETRANGE.
Source§

fn get_ex<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, expire_at: Expiry, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

GETEX.
Source§

fn get_del<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

GETDEL.
Source§

fn append<'a, K: ToSingleValkeyArg + Send + Sync + 'a, V: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, value: V, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

APPEND.
Source§

fn incr<'a, K: ToSingleValkeyArg + Send + Sync + 'a, V: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, delta: V, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

INCRBY/INCRBYFLOAT
Source§

fn decr<'a, K: ToSingleValkeyArg + Send + Sync + 'a, V: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, delta: V, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

DECRBY.
Source§

fn strlen<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

STRLEN.
Source§

fn keys<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

KEYS.
Source§

fn del<'a, K: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

DEL.
Source§

fn exists<'a, K: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

EXISTS.
Source§

fn key_type<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

TYPE.
Source§

fn expire<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, seconds: i64, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

EXPIRE.
Source§

fn expire_at<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, ts: i64, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

EXPIREAT.
Source§

fn expire_time<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

EXPIRETIME.
Source§

fn pexpire<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, ms: i64, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

PEXPIRE.
Source§

fn pexpire_at<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, ts: i64, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

PEXPIREAT.
Source§

fn pexpire_time<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

PEXPIRETIME.
Source§

fn persist<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

PERSIST.
Source§

fn ttl<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

TTL.
Source§

fn pttl<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

PTTL.
Source§

fn rename<'a, K: ToSingleValkeyArg + Send + Sync + 'a, N: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, new_key: N, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

RENAME.
Source§

fn rename_nx<'a, K: ToSingleValkeyArg + Send + Sync + 'a, N: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, new_key: N, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

RENAMENX.
UNLINK.
Source§

fn object_encoding<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

OBJECT ENCODING.
Source§

fn object_idletime<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

OBJECT IDLETIME.
Source§

fn object_freq<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

OBJECT FREQ.
Source§

fn object_refcount<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

OBJECT REFCOUNT.
Source§

fn copy<'a, KSrc: ToSingleValkeyArg + Send + Sync + 'a, KDst: ToSingleValkeyArg + Send + Sync + 'a, Db: ToString + Send + Sync + 'a, RV>( &'a self, source: KSrc, destination: KDst, options: CopyOptions<Db>, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

COPY.
Source§

fn blmove<'a, S: ToSingleValkeyArg + Send + Sync + 'a, D: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, srckey: S, dstkey: D, src_dir: Direction, dst_dir: Direction, timeout: f64, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

BLMOVE.
Source§

fn blmpop<'a, K: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, timeout: f64, numkeys: usize, key: K, dir: Direction, count: usize, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

BLMPOP.
Source§

fn blpop<'a, K: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, timeout: f64, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

BLPOP.
Source§

fn brpop<'a, K: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, timeout: f64, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

BRPOP.
Source§

fn brpoplpush<'a, S: ToSingleValkeyArg + Send + Sync + 'a, D: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, srckey: S, dstkey: D, timeout: f64, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

BRPOPLPUSH.
Source§

fn lindex<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, index: isize, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

LINDEX.
Source§

fn linsert_before<'a, K: ToSingleValkeyArg + Send + Sync + 'a, P: ToSingleValkeyArg + Send + Sync + 'a, V: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, pivot: P, value: V, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

LINSERT.
Source§

fn linsert_after<'a, K: ToSingleValkeyArg + Send + Sync + 'a, P: ToSingleValkeyArg + Send + Sync + 'a, V: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, pivot: P, value: V, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

LINSERT.
Source§

fn llen<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

LLEN.
Source§

fn lmove<'a, S: ToSingleValkeyArg + Send + Sync + 'a, D: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, srckey: S, dstkey: D, src_dir: Direction, dst_dir: Direction, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

LMOVE.
Source§

fn lmpop<'a, K: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, numkeys: usize, key: K, dir: Direction, count: usize, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

LMPOP.
Source§

fn lpop<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, count: Option<NonZeroUsize>, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

LPOP.
Source§

fn lpos<'a, K: ToSingleValkeyArg + Send + Sync + 'a, V: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, value: V, options: LposOptions, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

LPOS.
Source§

fn lpush<'a, K: ToSingleValkeyArg + Send + Sync + 'a, V: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, value: V, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

LPUSH.
Source§

fn lpush_exists<'a, K: ToSingleValkeyArg + Send + Sync + 'a, V: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, value: V, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

LPUSHX.
Source§

fn lrange<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, start: isize, stop: isize, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

LRANGE.
Source§

fn lrem<'a, K: ToSingleValkeyArg + Send + Sync + 'a, V: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, count: isize, value: V, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

LREM.
Source§

fn ltrim<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, start: isize, stop: isize, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

LTRIM.
Source§

fn lset<'a, K: ToSingleValkeyArg + Send + Sync + 'a, V: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, index: isize, value: V, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

LSET.
Source§

fn rpop<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, count: Option<NonZeroUsize>, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

RPOP.
Source§

fn rpoplpush<'a, K: ToSingleValkeyArg + Send + Sync + 'a, D: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, dstkey: D, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

RPOPLPUSH.
Source§

fn rpush<'a, K: ToSingleValkeyArg + Send + Sync + 'a, V: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, value: V, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

RPUSH.
Source§

fn rpush_exists<'a, K: ToSingleValkeyArg + Send + Sync + 'a, V: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, value: V, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

RPUSHX.
Source§

fn hget<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, field: F, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

HGET.
Source§

fn hmget<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, fields: F, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

HMGET.
Source§

fn hdel<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, field: F, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

HDEL.
Source§

fn hset<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToSingleValkeyArg + Send + Sync + 'a, V: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, field: F, value: V, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

HSET.
Source§

fn hset_multiple<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToValkeyArgs + Send + Sync + 'a, V: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, items: &'a [(F, V)], ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

HSET.
Source§

fn hset_nx<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToSingleValkeyArg + Send + Sync + 'a, V: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, field: F, value: V, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

HSETNX.
Source§

fn hincr<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToSingleValkeyArg + Send + Sync + 'a, D: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, field: F, delta: D, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

HINCRBY/HINCRBYFLOAT.
Source§

fn hexists<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, field: F, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

HEXISTS.
Source§

fn hkeys<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

HKEYS.
Source§

fn hvals<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

HVALS.
Source§

fn hgetall<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

HGETALL.
Source§

fn hlen<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

HLEN.
Source§

fn hget_ex<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, fields: F, expire_at: Expiry, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

HGETEX.
Source§

fn hset_ex<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToValkeyArgs + Send + Sync + 'a, V: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, hash_field_expiration_options: &'a HashFieldExpirationOptions, fields_values: &'a [(F, V)], ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

HSETEX.
Source§

fn httl<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, fields: F, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

HTTL.
Source§

fn hpttl<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, fields: F, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

HPTTL.
Source§

fn hexpire<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, seconds: i64, opt: ExpireOption, fields: F, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

HEXPIRE.
Source§

fn hexpire_at<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, ts: i64, opt: ExpireOption, fields: F, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

HEXPIREAT.
Source§

fn hexpire_time<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, fields: F, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

HEXPIRETIME.
Source§

fn hpersist<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, fields: F, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

HPERSIST.
Source§

fn hpexpire<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, milliseconds: i64, opt: ExpireOption, fields: F, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

HPEXPIRE.
Source§

fn hpexpire_at<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, ts: i64, opt: ExpireOption, fields: F, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

HPEXPIREAT.
Source§

fn hpexpire_time<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, fields: F, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

HPEXPIRETIME.
Source§

fn sadd<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, member: M, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

SADD.
Source§

fn scard<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

SCARD.
Source§

fn sdiff<'a, K: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, keys: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

SDIFF.
Source§

fn sdiffstore<'a, D: ToSingleValkeyArg + Send + Sync + 'a, K: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, dstkey: D, keys: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

SDIFFSTORE.
Source§

fn sinter<'a, K: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, keys: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

SINTER.
Source§

fn sinterstore<'a, D: ToSingleValkeyArg + Send + Sync + 'a, K: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, dstkey: D, keys: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

SINTERSTORE.
Source§

fn sismember<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, member: M, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

SISMEMBER.
Source§

fn smismember<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, members: M, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

SMISMEMBER.
Source§

fn smembers<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

SMEMBERS.
Source§

fn smove<'a, S: ToSingleValkeyArg + Send + Sync + 'a, D: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, srckey: S, dstkey: D, member: M, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

SMOVE.
Source§

fn spop<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

SPOP.
Source§

fn srandmember<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

SRANDMEMBER.
Source§

fn srandmember_multiple<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, count: isize, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

SRANDMEMBER.
Source§

fn srem<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, member: M, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

SREM.
Source§

fn sunion<'a, K: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, keys: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

SUNION.
Source§

fn sunionstore<'a, D: ToSingleValkeyArg + Send + Sync + 'a, K: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, dstkey: D, keys: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

SUNIONSTORE.
Source§

fn zadd<'a, K: ToSingleValkeyArg + Send + Sync + 'a, S: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, member: M, score: S, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZADD.
Source§

fn zadd_multiple<'a, K: ToSingleValkeyArg + Send + Sync + 'a, S: ToValkeyArgs + Send + Sync + 'a, M: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, items: &'a [(S, M)], ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZADD.
Source§

fn zcard<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZCARD.
Source§

fn zcount<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a, MM: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, min: M, max: MM, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZCOUNT.
Source§

fn zincr<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a, D: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, member: M, delta: D, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZINCRBY.
Source§

fn zinterstore<'a, D: ToSingleValkeyArg + Send + Sync + 'a, K: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, dstkey: D, keys: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZINTERSTORE.
Source§

fn zinterstore_min<'a, D: ToSingleValkeyArg + Send + Sync + 'a, K: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, dstkey: D, keys: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZINTERSTORE.
Source§

fn zinterstore_max<'a, D: ToSingleValkeyArg + Send + Sync + 'a, K: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, dstkey: D, keys: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZINTERSTORE.
Source§

fn zinterstore_weights<'a, D: ToSingleValkeyArg + Send + Sync + 'a, K: ToValkeyArgs + Send + Sync + 'a, W: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, dstkey: D, keys: &'a [(K, W)], ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZINTERSTORE.
Source§

fn zinterstore_min_weights<'a, D: ToSingleValkeyArg + Send + Sync + 'a, K: ToValkeyArgs + Send + Sync + 'a, W: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, dstkey: D, keys: &'a [(K, W)], ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZINTERSTORE.
Source§

fn zinterstore_max_weights<'a, D: ToSingleValkeyArg + Send + Sync + 'a, K: ToValkeyArgs + Send + Sync + 'a, W: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, dstkey: D, keys: &'a [(K, W)], ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZINTERSTORE.
Source§

fn zlexcount<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a, MM: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, min: M, max: MM, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZLEXCOUNT.
Source§

fn bzpopmax<'a, K: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, timeout: f64, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

BZPOPMAX.
Source§

fn zpopmax<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, count: isize, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZPOPMAX.
Source§

fn bzpopmin<'a, K: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, timeout: f64, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

BZPOPMIN.
Source§

fn zpopmin<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, count: isize, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZPOPMIN.
Source§

fn bzmpop_max<'a, K: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, timeout: f64, keys: K, count: isize, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

BZMPOP.
Source§

fn zmpop_max<'a, K: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, keys: K, count: isize, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZMPOP.
Source§

fn bzmpop_min<'a, K: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, timeout: f64, keys: K, count: isize, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

BZMPOP.
Source§

fn zmpop_min<'a, K: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, keys: K, count: isize, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZMPOP.
Source§

fn zrandmember<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, count: Option<isize>, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZRANDMEMBER.
Source§

fn zrandmember_withscores<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, count: isize, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZRANDMEMBER WITHSCORES.
Source§

fn zrange<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, start: isize, stop: isize, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZRANGE.
Source§

fn zrange_withscores<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, start: isize, stop: isize, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZRANGE WITHSCORES.
Source§

fn zrangebylex<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a, MM: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, min: M, max: MM, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZRANGEBYLEX.
Source§

fn zrangebylex_limit<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a, MM: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, min: M, max: MM, offset: isize, count: isize, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZRANGEBYLEX LIMIT.
Source§

fn zrevrangebylex<'a, K: ToSingleValkeyArg + Send + Sync + 'a, MM: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, max: MM, min: M, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZREVRANGEBYLEX.
Source§

fn zrevrangebylex_limit<'a, K: ToSingleValkeyArg + Send + Sync + 'a, MM: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, max: MM, min: M, offset: isize, count: isize, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZREVRANGEBYLEX LIMIT.
Source§

fn zrangebyscore<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a, MM: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, min: M, max: MM, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZRANGEBYSCORE.
Source§

fn zrangebyscore_withscores<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a, MM: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, min: M, max: MM, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZRANGEBYSCORE WITHSCORES.
Source§

fn zrangebyscore_limit<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a, MM: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, min: M, max: MM, offset: isize, count: isize, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZRANGEBYSCORE LIMIT.
Source§

fn zrangebyscore_limit_withscores<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a, MM: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, min: M, max: MM, offset: isize, count: isize, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZRANGEBYSCORE WITHSCORES LIMIT.
Source§

fn zrank<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, member: M, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZRANK.
Source§

fn zrem<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, members: M, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZREM.
Source§

fn zrembylex<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a, MM: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, min: M, max: MM, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZREMRANGEBYLEX.
Source§

fn zremrangebyrank<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, start: isize, stop: isize, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZREMRANGEBYRANK.
Source§

fn zrembyscore<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a, MM: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, min: M, max: MM, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZREMRANGEBYSCORE.
Source§

fn zrevrange<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, start: isize, stop: isize, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZREVRANGE.
Source§

fn zrevrange_withscores<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, start: isize, stop: isize, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZREVRANGE WITHSCORES.
Source§

fn zrevrangebyscore<'a, K: ToSingleValkeyArg + Send + Sync + 'a, MM: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, max: MM, min: M, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZREVRANGEBYSCORE.
Source§

fn zrevrangebyscore_withscores<'a, K: ToSingleValkeyArg + Send + Sync + 'a, MM: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, max: MM, min: M, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZREVRANGEBYSCORE WITHSCORES.
Source§

fn zrevrangebyscore_limit<'a, K: ToSingleValkeyArg + Send + Sync + 'a, MM: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, max: MM, min: M, offset: isize, count: isize, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZREVRANGEBYSCORE LIMIT.
Source§

fn zrevrangebyscore_limit_withscores<'a, K: ToSingleValkeyArg + Send + Sync + 'a, MM: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, max: MM, min: M, offset: isize, count: isize, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZREVRANGEBYSCORE WITHSCORES LIMIT.
Source§

fn zrevrank<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, member: M, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZREVRANK.
Source§

fn zscore<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, member: M, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZSCORE.
Source§

fn zscore_multiple<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, members: &'a [M], ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZMSCORE.
Source§

fn zunionstore<'a, D: ToSingleValkeyArg + Send + Sync + 'a, K: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, dstkey: D, keys: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZUNIONSTORE.
Source§

fn zunionstore_min<'a, D: ToSingleValkeyArg + Send + Sync + 'a, K: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, dstkey: D, keys: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZUNIONSTORE AGGREGATE MIN.
Source§

fn zunionstore_max<'a, D: ToSingleValkeyArg + Send + Sync + 'a, K: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, dstkey: D, keys: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZUNIONSTORE AGGREGATE MAX.
Source§

fn zunionstore_weights<'a, D: ToSingleValkeyArg + Send + Sync + 'a, K: ToValkeyArgs + Send + Sync + 'a, W: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, dstkey: D, keys: &'a [(K, W)], ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZUNIONSTORE WEIGHTS.
Source§

fn zunionstore_min_weights<'a, D: ToSingleValkeyArg + Send + Sync + 'a, K: ToValkeyArgs + Send + Sync + 'a, W: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, dstkey: D, keys: &'a [(K, W)], ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZUNIONSTORE AGGREGATE MIN WEIGHTS.
Source§

fn zunionstore_max_weights<'a, D: ToSingleValkeyArg + Send + Sync + 'a, K: ToValkeyArgs + Send + Sync + 'a, W: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, dstkey: D, keys: &'a [(K, W)], ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

ZUNIONSTORE AGGREGATE MAX WEIGHTS.
Source§

fn pfadd<'a, K: ToSingleValkeyArg + Send + Sync + 'a, E: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, element: E, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

PFADD.
Source§

fn pfcount<'a, K: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

PFCOUNT.
Source§

fn pfmerge<'a, D: ToSingleValkeyArg + Send + Sync + 'a, S: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, dstkey: D, srckeys: S, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

PFMERGE.
Source§

fn setbit<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, offset: usize, value: bool, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

SETBIT.
Source§

fn getbit<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, offset: usize, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

GETBIT.
Source§

fn bitcount<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

BITCOUNT.
Source§

fn bitcount_range<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, start: usize, end: usize, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

BITCOUNT.
Source§

fn bit_and<'a, D: ToSingleValkeyArg + Send + Sync + 'a, S: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, dstkey: D, srckeys: S, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

BITOP AND.
Source§

fn bit_or<'a, D: ToSingleValkeyArg + Send + Sync + 'a, S: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, dstkey: D, srckeys: S, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

BITOP OR.
Source§

fn bit_xor<'a, D: ToSingleValkeyArg + Send + Sync + 'a, S: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, dstkey: D, srckeys: S, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

BITOP XOR.
Source§

fn bit_not<'a, D: ToSingleValkeyArg + Send + Sync + 'a, S: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, dstkey: D, srckey: S, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

BITOP NOT.
Source§

fn geo_add<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, members: M, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

GEOADD.
Source§

fn geo_dist<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M1: ToSingleValkeyArg + Send + Sync + 'a, M2: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, key: K, member1: M1, member2: M2, unit: GeoUnit, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

GEODIST.
Source§

fn geo_hash<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, members: M, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

GEOHASH.
Source§

fn geo_pos<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, members: M, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

GEOPOS.
Source§

fn xack<'a, K: ToValkeyArgs + Send + Sync + 'a, G: ToValkeyArgs + Send + Sync + 'a, I: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, group: G, ids: &'a [I], ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

XACK.
Source§

fn xadd<'a, K: ToValkeyArgs + Send + Sync + 'a, ID: ToValkeyArgs + Send + Sync + 'a, F: ToValkeyArgs + Send + Sync + 'a, V: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, id: ID, items: &'a [(F, V)], ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

XADD.
Source§

fn xadd_options<'a, K: ToValkeyArgs + Send + Sync + 'a, ID: ToValkeyArgs + Send + Sync + 'a, I: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, id: ID, items: I, options: &'a StreamAddOptions, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

XADD with options.
Source§

fn xautoclaim_options<'a, K: ToSingleValkeyArg + Send + Sync + 'a, G: ToValkeyArgs + Send + Sync + 'a, C: ToValkeyArgs + Send + Sync + 'a, MIT: ToValkeyArgs + Send + Sync + 'a, S: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, group: G, consumer: C, min_idle_time: MIT, start: S, options: StreamAutoClaimOptions, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

XAUTOCLAIM.
Source§

fn xclaim<'a, K: ToSingleValkeyArg + Send + Sync + 'a, G: ToValkeyArgs + Send + Sync + 'a, C: ToValkeyArgs + Send + Sync + 'a, MIT: ToValkeyArgs + Send + Sync + 'a, ID: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, group: G, consumer: C, min_idle_time: MIT, ids: &'a [ID], ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

XCLAIM.
Source§

fn xclaim_options<'a, K: ToSingleValkeyArg + Send + Sync + 'a, G: ToValkeyArgs + Send + Sync + 'a, C: ToValkeyArgs + Send + Sync + 'a, MIT: ToValkeyArgs + Send + Sync + 'a, ID: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, group: G, consumer: C, min_idle_time: MIT, ids: &'a [ID], options: StreamClaimOptions, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

XCLAIM.
Source§

fn xdel<'a, K: ToSingleValkeyArg + Send + Sync + 'a, ID: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, ids: &'a [ID], ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

XDEL.
Source§

fn xgroup_create<'a, K: ToValkeyArgs + Send + Sync + 'a, G: ToValkeyArgs + Send + Sync + 'a, ID: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, group: G, id: ID, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

XGROUP CREATE.
Source§

fn xgroup_create_mkstream<'a, K: ToValkeyArgs + Send + Sync + 'a, G: ToValkeyArgs + Send + Sync + 'a, ID: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, group: G, id: ID, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

XGROUP CREATE ... MKSTREAM.
Source§

fn xgroup_createconsumer<'a, K: ToValkeyArgs + Send + Sync + 'a, G: ToValkeyArgs + Send + Sync + 'a, C: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, group: G, consumer: C, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

XGROUP CREATECONSUMER.
Source§

fn xgroup_delconsumer<'a, K: ToValkeyArgs + Send + Sync + 'a, G: ToValkeyArgs + Send + Sync + 'a, C: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, group: G, consumer: C, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

XGROUP DELCONSUMER.
Source§

fn xgroup_destroy<'a, K: ToValkeyArgs + Send + Sync + 'a, G: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, group: G, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

XGROUP DESTROY.
Source§

fn xgroup_setid<'a, K: ToValkeyArgs + Send + Sync + 'a, G: ToValkeyArgs + Send + Sync + 'a, ID: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, group: G, id: ID, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

XGROUP SETID.
Source§

fn xinfo_consumers<'a, K: ToValkeyArgs + Send + Sync + 'a, G: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, group: G, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

XINFO CONSUMERS.
Source§

fn xinfo_groups<'a, K: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

XINFO GROUPS.
Source§

fn xinfo_stream<'a, K: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

XINFO STREAM.
Source§

fn xlen<'a, K: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

XLEN.
Source§

fn xpending<'a, K: ToValkeyArgs + Send + Sync + 'a, G: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, group: G, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

XPENDING.
Source§

fn xpending_count<'a, K: ToValkeyArgs + Send + Sync + 'a, G: ToValkeyArgs + Send + Sync + 'a, S: ToValkeyArgs + Send + Sync + 'a, E: ToValkeyArgs + Send + Sync + 'a, C: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, group: G, start: S, end: E, count: C, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

XPENDING (extended form).
Source§

fn xpending_consumer_count<'a, K: ToValkeyArgs + Send + Sync + 'a, G: ToValkeyArgs + Send + Sync + 'a, S: ToValkeyArgs + Send + Sync + 'a, E: ToValkeyArgs + Send + Sync + 'a, C: ToValkeyArgs + Send + Sync + 'a, CN: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, group: G, start: S, end: E, count: C, consumer: CN, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

XPENDING (extended form, filtered by consumer).
Source§

fn xrange<'a, K: ToValkeyArgs + Send + Sync + 'a, S: ToValkeyArgs + Send + Sync + 'a, E: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, start: S, end: E, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

XRANGE.
Source§

fn xread<'a, K: ToValkeyArgs + Send + Sync + 'a, ID: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, keys: &'a [K], ids: &'a [ID], ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

XREAD.
Source§

fn xread_options<'a, K: ToValkeyArgs + Send + Sync + 'a, ID: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, keys: &'a [K], ids: &'a [ID], options: &'a StreamReadOptions, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

XREAD.
Source§

fn xrevrange<'a, K: ToValkeyArgs + Send + Sync + 'a, E: ToValkeyArgs + Send + Sync + 'a, S: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, end: E, start: S, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

XREVRANGE.
Source§

fn xtrim<'a, K: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, maxlen: StreamMaxlen, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

XTRIM ... MAXLEN.
Source§

fn xtrim_options<'a, K: ToValkeyArgs + Send + Sync + 'a, RV>( &'a self, key: K, options: &'a StreamTrimOptions, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

XTRIM.
Source§

fn ping<'a, RV>(&'a self) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

PING.
Source§

fn ping_message<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, message: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

PING with a message.
Source§

fn client_getname<'a, RV>(&'a self) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

CLIENT GETNAME.
Source§

fn client_id<'a, RV>(&'a self) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

CLIENT ID.
Source§

fn client_setname<'a, K: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, connection_name: K, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

CLIENT SETNAME.
Source§

fn flushall<'a, RV>(&'a self) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

FLUSHALL.
Source§

fn flushall_options<'a, RV>( &'a self, options: &'a FlushAllOptions, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

FLUSHALL.
Source§

fn flushdb<'a, RV>(&'a self) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

FLUSHDB.
Source§

fn flushdb_options<'a, RV>( &'a self, options: &'a FlushDbOptions, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

FLUSHDB.
Source§

fn publish<'a, K: ToSingleValkeyArg + Send + Sync + 'a, E: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, channel: K, message: E, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

PUBLISH.
Source§

fn spublish<'a, K: ToSingleValkeyArg + Send + Sync + 'a, E: ToSingleValkeyArg + Send + Sync + 'a, RV>( &'a self, channel: K, message: E, ) -> ValkeyFuture<'a, RV>
where RV: FromValkeyValue,

SPUBLISH.
Source§

fn scan<'s, RV: FromValkeyValue + 's>( &'s self, ) -> ValkeyFuture<'s, ScanIter<'s, Self, RV>>

Cursor-driven SCAN over the whole keyspace.
Source§

fn scan_match<'s, P: ToSingleValkeyArg, RV: FromValkeyValue + 's>( &'s self, pattern: P, ) -> ValkeyFuture<'s, ScanIter<'s, Self, RV>>

Cursor-driven SCAN over the keyspace, filtered by a MATCH pattern.
Source§

fn hscan<'s, K: ToSingleValkeyArg, RV: FromValkeyValue + 's>( &'s self, key: K, ) -> ValkeyFuture<'s, ScanIter<'s, Self, RV>>

Cursor-driven HSCAN over a hash’s fields and values.
Source§

fn hscan_match<'s, K: ToSingleValkeyArg, P: ToSingleValkeyArg, RV: FromValkeyValue + 's>( &'s self, key: K, pattern: P, ) -> ValkeyFuture<'s, ScanIter<'s, Self, RV>>

Cursor-driven HSCAN, filtered by a field-name MATCH pattern.
Source§

fn sscan<'s, K: ToSingleValkeyArg, RV: FromValkeyValue + 's>( &'s self, key: K, ) -> ValkeyFuture<'s, ScanIter<'s, Self, RV>>

Cursor-driven SSCAN over a set’s members.
Source§

fn sscan_match<'s, K: ToSingleValkeyArg, P: ToSingleValkeyArg, RV: FromValkeyValue + 's>( &'s self, key: K, pattern: P, ) -> ValkeyFuture<'s, ScanIter<'s, Self, RV>>

Cursor-driven SSCAN, filtered by a MATCH pattern.
Source§

fn zscan<'s, K: ToSingleValkeyArg, RV: FromValkeyValue + 's>( &'s self, key: K, ) -> ValkeyFuture<'s, ScanIter<'s, Self, RV>>

Cursor-driven ZSCAN over a sorted set’s members and scores.
Source§

fn zscan_match<'s, K: ToSingleValkeyArg, P: ToSingleValkeyArg, RV: FromValkeyValue + 's>( &'s self, key: K, pattern: P, ) -> ValkeyFuture<'s, ScanIter<'s, Self, RV>>

Cursor-driven ZSCAN, filtered by a MATCH pattern.
Source§

impl<T> AsyncTypedCommands for T
where T: CommandDispatch,

Source§

fn get<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, ) -> ValkeyFuture<'a, Option<String>>

GET.
Source§

fn mget<'a, K: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, ) -> ValkeyFuture<'a, Vec<Option<String>>>

MGET.
Source§

fn set<'a, K: ToSingleValkeyArg + Send + Sync + 'a, V: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, value: V, ) -> ValkeyFuture<'a, ()>

SET.
Source§

fn set_options<'a, K: ToSingleValkeyArg + Send + Sync + 'a, V: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, value: V, options: SetOptions, ) -> ValkeyFuture<'a, Option<String>>

SET.
Source§

fn mset<'a, K: ToValkeyArgs + Send + Sync + 'a, V: ToValkeyArgs + Send + Sync + 'a>( &'a self, items: &'a [(K, V)], ) -> ValkeyFuture<'a, ()>

MSET.
Source§

fn set_ex<'a, K: ToSingleValkeyArg + Send + Sync + 'a, V: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, value: V, seconds: u64, ) -> ValkeyFuture<'a, ()>

SETEX.
Source§

fn pset_ex<'a, K: ToSingleValkeyArg + Send + Sync + 'a, V: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, value: V, milliseconds: u64, ) -> ValkeyFuture<'a, ()>

PSETEX.
Source§

fn set_nx<'a, K: ToSingleValkeyArg + Send + Sync + 'a, V: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, value: V, ) -> ValkeyFuture<'a, bool>

SETNX.
Source§

fn mset_nx<'a, K: ToValkeyArgs + Send + Sync + 'a, V: ToValkeyArgs + Send + Sync + 'a>( &'a self, items: &'a [(K, V)], ) -> ValkeyFuture<'a, bool>

MSETNX.
Source§

fn getset<'a, K: ToSingleValkeyArg + Send + Sync + 'a, V: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, value: V, ) -> ValkeyFuture<'a, Option<String>>

GETSET.
Source§

fn getrange<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, from: isize, to: isize, ) -> ValkeyFuture<'a, String>

GETRANGE.
Source§

fn setrange<'a, K: ToSingleValkeyArg + Send + Sync + 'a, V: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, offset: isize, value: V, ) -> ValkeyFuture<'a, usize>

SETRANGE.
Source§

fn get_ex<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, expire_at: Expiry, ) -> ValkeyFuture<'a, Option<String>>

GETEX.
Source§

fn get_del<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, ) -> ValkeyFuture<'a, Option<String>>

GETDEL.
Source§

fn append<'a, K: ToSingleValkeyArg + Send + Sync + 'a, V: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, value: V, ) -> ValkeyFuture<'a, usize>

APPEND.
Source§

fn incr<'a, K: ToSingleValkeyArg + Send + Sync + 'a, V: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, delta: V, ) -> ValkeyFuture<'a, isize>

INCRBY/INCRBYFLOAT
Source§

fn decr<'a, K: ToSingleValkeyArg + Send + Sync + 'a, V: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, delta: V, ) -> ValkeyFuture<'a, isize>

DECRBY.
Source§

fn strlen<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, ) -> ValkeyFuture<'a, usize>

STRLEN.
Source§

fn keys<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, ) -> ValkeyFuture<'a, Vec<String>>

KEYS.
Source§

fn del<'a, K: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, ) -> ValkeyFuture<'a, usize>

DEL.
Source§

fn exists<'a, K: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, ) -> ValkeyFuture<'a, bool>

EXISTS.
Source§

fn key_type<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, ) -> ValkeyFuture<'a, ValueType>

TYPE.
Source§

fn expire<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, seconds: i64, ) -> ValkeyFuture<'a, bool>

EXPIRE.
Source§

fn expire_at<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, ts: i64, ) -> ValkeyFuture<'a, bool>

EXPIREAT.
Source§

fn expire_time<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, ) -> ValkeyFuture<'a, IntegerReplyOrNoOp>

EXPIRETIME.
Source§

fn pexpire<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, ms: i64, ) -> ValkeyFuture<'a, bool>

PEXPIRE.
Source§

fn pexpire_at<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, ts: i64, ) -> ValkeyFuture<'a, bool>

PEXPIREAT.
Source§

fn pexpire_time<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, ) -> ValkeyFuture<'a, IntegerReplyOrNoOp>

PEXPIRETIME.
Source§

fn persist<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, ) -> ValkeyFuture<'a, bool>

PERSIST.
Source§

fn ttl<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, ) -> ValkeyFuture<'a, IntegerReplyOrNoOp>

TTL.
Source§

fn pttl<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, ) -> ValkeyFuture<'a, IntegerReplyOrNoOp>

PTTL.
Source§

fn rename<'a, K: ToSingleValkeyArg + Send + Sync + 'a, N: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, new_key: N, ) -> ValkeyFuture<'a, ()>

RENAME.
Source§

fn rename_nx<'a, K: ToSingleValkeyArg + Send + Sync + 'a, N: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, new_key: N, ) -> ValkeyFuture<'a, bool>

RENAMENX.
UNLINK.
Source§

fn object_encoding<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, ) -> ValkeyFuture<'a, Option<String>>

OBJECT ENCODING.
Source§

fn object_idletime<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, ) -> ValkeyFuture<'a, Option<usize>>

OBJECT IDLETIME.
Source§

fn object_freq<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, ) -> ValkeyFuture<'a, Option<usize>>

OBJECT FREQ.
Source§

fn object_refcount<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, ) -> ValkeyFuture<'a, Option<usize>>

OBJECT REFCOUNT.
Source§

fn copy<'a, KSrc: ToSingleValkeyArg + Send + Sync + 'a, KDst: ToSingleValkeyArg + Send + Sync + 'a, Db: ToString + Send + Sync + 'a>( &'a self, source: KSrc, destination: KDst, options: CopyOptions<Db>, ) -> ValkeyFuture<'a, bool>

COPY.
Source§

fn blmove<'a, S: ToSingleValkeyArg + Send + Sync + 'a, D: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, srckey: S, dstkey: D, src_dir: Direction, dst_dir: Direction, timeout: f64, ) -> ValkeyFuture<'a, Option<String>>

BLMOVE.
Source§

fn blmpop<'a, K: ToValkeyArgs + Send + Sync + 'a>( &'a self, timeout: f64, numkeys: usize, key: K, dir: Direction, count: usize, ) -> ValkeyFuture<'a, Option<(String, Vec<String>)>>

BLMPOP.
Source§

fn blpop<'a, K: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, timeout: f64, ) -> ValkeyFuture<'a, Option<[String; 2]>>

BLPOP.
Source§

fn brpop<'a, K: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, timeout: f64, ) -> ValkeyFuture<'a, Option<[String; 2]>>

BRPOP.
Source§

fn brpoplpush<'a, S: ToSingleValkeyArg + Send + Sync + 'a, D: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, srckey: S, dstkey: D, timeout: f64, ) -> ValkeyFuture<'a, Option<String>>

BRPOPLPUSH.
Source§

fn lindex<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, index: isize, ) -> ValkeyFuture<'a, Option<String>>

LINDEX.
Source§

fn linsert_before<'a, K: ToSingleValkeyArg + Send + Sync + 'a, P: ToSingleValkeyArg + Send + Sync + 'a, V: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, pivot: P, value: V, ) -> ValkeyFuture<'a, isize>

LINSERT.
Source§

fn linsert_after<'a, K: ToSingleValkeyArg + Send + Sync + 'a, P: ToSingleValkeyArg + Send + Sync + 'a, V: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, pivot: P, value: V, ) -> ValkeyFuture<'a, isize>

LINSERT.
Source§

fn llen<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, ) -> ValkeyFuture<'a, usize>

LLEN.
Source§

fn lmove<'a, S: ToSingleValkeyArg + Send + Sync + 'a, D: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, srckey: S, dstkey: D, src_dir: Direction, dst_dir: Direction, ) -> ValkeyFuture<'a, String>

LMOVE.
Source§

fn lmpop<'a, K: ToValkeyArgs + Send + Sync + 'a>( &'a self, numkeys: usize, key: K, dir: Direction, count: usize, ) -> ValkeyFuture<'a, Option<(String, Vec<String>)>>

LMPOP.
Source§

fn lpop<'a, RV: FromValkeyValue, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, count: Option<NonZeroUsize>, ) -> ValkeyFuture<'a, RV>

LPOP.
Source§

fn lpos<'a, RV: FromValkeyValue, K: ToSingleValkeyArg + Send + Sync + 'a, V: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, value: V, options: LposOptions, ) -> ValkeyFuture<'a, RV>

LPOS.
Source§

fn lpush<'a, K: ToSingleValkeyArg + Send + Sync + 'a, V: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, value: V, ) -> ValkeyFuture<'a, usize>

LPUSH.
Source§

fn lpush_exists<'a, K: ToSingleValkeyArg + Send + Sync + 'a, V: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, value: V, ) -> ValkeyFuture<'a, usize>

LPUSHX.
Source§

fn lrange<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, start: isize, stop: isize, ) -> ValkeyFuture<'a, Vec<String>>

LRANGE.
Source§

fn lrem<'a, K: ToSingleValkeyArg + Send + Sync + 'a, V: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, count: isize, value: V, ) -> ValkeyFuture<'a, usize>

LREM.
Source§

fn ltrim<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, start: isize, stop: isize, ) -> ValkeyFuture<'a, ()>

LTRIM.
Source§

fn lset<'a, K: ToSingleValkeyArg + Send + Sync + 'a, V: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, index: isize, value: V, ) -> ValkeyFuture<'a, ()>

LSET.
Source§

fn rpop<'a, RV: FromValkeyValue, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, count: Option<NonZeroUsize>, ) -> ValkeyFuture<'a, RV>

RPOP.
Source§

fn rpoplpush<'a, K: ToSingleValkeyArg + Send + Sync + 'a, D: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, dstkey: D, ) -> ValkeyFuture<'a, Option<String>>

RPOPLPUSH.
Source§

fn rpush<'a, K: ToSingleValkeyArg + Send + Sync + 'a, V: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, value: V, ) -> ValkeyFuture<'a, usize>

RPUSH.
Source§

fn rpush_exists<'a, K: ToSingleValkeyArg + Send + Sync + 'a, V: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, value: V, ) -> ValkeyFuture<'a, usize>

RPUSHX.
Source§

fn hget<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, field: F, ) -> ValkeyFuture<'a, Option<String>>

HGET.
Source§

fn hmget<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, fields: F, ) -> ValkeyFuture<'a, Vec<String>>

HMGET.
Source§

fn hdel<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, field: F, ) -> ValkeyFuture<'a, usize>

HDEL.
Source§

fn hset<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToSingleValkeyArg + Send + Sync + 'a, V: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, field: F, value: V, ) -> ValkeyFuture<'a, usize>

HSET.
Source§

fn hset_multiple<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToValkeyArgs + Send + Sync + 'a, V: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, items: &'a [(F, V)], ) -> ValkeyFuture<'a, usize>

HSET.
Source§

fn hset_nx<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToSingleValkeyArg + Send + Sync + 'a, V: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, field: F, value: V, ) -> ValkeyFuture<'a, bool>

HSETNX.
Source§

fn hincr<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToSingleValkeyArg + Send + Sync + 'a, D: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, field: F, delta: D, ) -> ValkeyFuture<'a, f64>

HINCRBY/HINCRBYFLOAT.
Source§

fn hexists<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, field: F, ) -> ValkeyFuture<'a, bool>

HEXISTS.
Source§

fn hkeys<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, ) -> ValkeyFuture<'a, Vec<String>>

HKEYS.
Source§

fn hvals<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, ) -> ValkeyFuture<'a, Vec<String>>

HVALS.
Source§

fn hgetall<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, ) -> ValkeyFuture<'a, HashMap<String, String>>

HGETALL.
Source§

fn hlen<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, ) -> ValkeyFuture<'a, usize>

HLEN.
Source§

fn hget_ex<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, fields: F, expire_at: Expiry, ) -> ValkeyFuture<'a, Vec<String>>

HGETEX.
Source§

fn hset_ex<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToValkeyArgs + Send + Sync + 'a, V: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, hash_field_expiration_options: &'a HashFieldExpirationOptions, fields_values: &'a [(F, V)], ) -> ValkeyFuture<'a, bool>

HSETEX.
Source§

fn httl<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, fields: F, ) -> ValkeyFuture<'a, Vec<IntegerReplyOrNoOp>>

HTTL.
Source§

fn hpttl<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, fields: F, ) -> ValkeyFuture<'a, Vec<IntegerReplyOrNoOp>>

HPTTL.
Source§

fn hexpire<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, seconds: i64, opt: ExpireOption, fields: F, ) -> ValkeyFuture<'a, Vec<IntegerReplyOrNoOp>>

HEXPIRE.
Source§

fn hexpire_at<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, ts: i64, opt: ExpireOption, fields: F, ) -> ValkeyFuture<'a, Vec<IntegerReplyOrNoOp>>

HEXPIREAT.
Source§

fn hexpire_time<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, fields: F, ) -> ValkeyFuture<'a, Vec<IntegerReplyOrNoOp>>

HEXPIRETIME.
Source§

fn hpersist<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, fields: F, ) -> ValkeyFuture<'a, Vec<IntegerReplyOrNoOp>>

HPERSIST.
Source§

fn hpexpire<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, milliseconds: i64, opt: ExpireOption, fields: F, ) -> ValkeyFuture<'a, Vec<IntegerReplyOrNoOp>>

HPEXPIRE.
Source§

fn hpexpire_at<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, ts: i64, opt: ExpireOption, fields: F, ) -> ValkeyFuture<'a, Vec<IntegerReplyOrNoOp>>

HPEXPIREAT.
Source§

fn hpexpire_time<'a, K: ToSingleValkeyArg + Send + Sync + 'a, F: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, fields: F, ) -> ValkeyFuture<'a, Vec<IntegerReplyOrNoOp>>

HPEXPIRETIME.
Source§

fn sadd<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, member: M, ) -> ValkeyFuture<'a, usize>

SADD.
Source§

fn scard<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, ) -> ValkeyFuture<'a, usize>

SCARD.
Source§

fn sdiff<'a, K: ToValkeyArgs + Send + Sync + 'a>( &'a self, keys: K, ) -> ValkeyFuture<'a, HashSet<String>>

SDIFF.
Source§

fn sdiffstore<'a, D: ToSingleValkeyArg + Send + Sync + 'a, K: ToValkeyArgs + Send + Sync + 'a>( &'a self, dstkey: D, keys: K, ) -> ValkeyFuture<'a, usize>

SDIFFSTORE.
Source§

fn sinter<'a, K: ToValkeyArgs + Send + Sync + 'a>( &'a self, keys: K, ) -> ValkeyFuture<'a, HashSet<String>>

SINTER.
Source§

fn sinterstore<'a, D: ToSingleValkeyArg + Send + Sync + 'a, K: ToValkeyArgs + Send + Sync + 'a>( &'a self, dstkey: D, keys: K, ) -> ValkeyFuture<'a, usize>

SINTERSTORE.
Source§

fn sismember<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, member: M, ) -> ValkeyFuture<'a, bool>

SISMEMBER.
Source§

fn smismember<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, members: M, ) -> ValkeyFuture<'a, Vec<bool>>

SMISMEMBER.
Source§

fn smembers<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, ) -> ValkeyFuture<'a, HashSet<String>>

SMEMBERS.
Source§

fn smove<'a, S: ToSingleValkeyArg + Send + Sync + 'a, D: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, srckey: S, dstkey: D, member: M, ) -> ValkeyFuture<'a, bool>

SMOVE.
Source§

fn spop<'a, RV: FromValkeyValue, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, ) -> ValkeyFuture<'a, RV>

SPOP.
Source§

fn srandmember<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, ) -> ValkeyFuture<'a, Option<String>>

SRANDMEMBER.
Source§

fn srandmember_multiple<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, count: isize, ) -> ValkeyFuture<'a, Vec<String>>

SRANDMEMBER.
Source§

fn srem<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, member: M, ) -> ValkeyFuture<'a, usize>

SREM.
Source§

fn sunion<'a, K: ToValkeyArgs + Send + Sync + 'a>( &'a self, keys: K, ) -> ValkeyFuture<'a, HashSet<String>>

SUNION.
Source§

fn sunionstore<'a, D: ToSingleValkeyArg + Send + Sync + 'a, K: ToValkeyArgs + Send + Sync + 'a>( &'a self, dstkey: D, keys: K, ) -> ValkeyFuture<'a, usize>

SUNIONSTORE.
Source§

fn zadd<'a, K: ToSingleValkeyArg + Send + Sync + 'a, S: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, member: M, score: S, ) -> ValkeyFuture<'a, usize>

ZADD.
Source§

fn zadd_multiple<'a, K: ToSingleValkeyArg + Send + Sync + 'a, S: ToValkeyArgs + Send + Sync + 'a, M: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, items: &'a [(S, M)], ) -> ValkeyFuture<'a, usize>

ZADD.
Source§

fn zcard<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, ) -> ValkeyFuture<'a, usize>

ZCARD.
Source§

fn zcount<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a, MM: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, min: M, max: MM, ) -> ValkeyFuture<'a, usize>

ZCOUNT.
Source§

fn zincr<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a, D: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, member: M, delta: D, ) -> ValkeyFuture<'a, f64>

ZINCRBY.
Source§

fn zinterstore<'a, D: ToSingleValkeyArg + Send + Sync + 'a, K: ToValkeyArgs + Send + Sync + 'a>( &'a self, dstkey: D, keys: K, ) -> ValkeyFuture<'a, usize>

ZINTERSTORE.
Source§

fn zinterstore_min<'a, D: ToSingleValkeyArg + Send + Sync + 'a, K: ToValkeyArgs + Send + Sync + 'a>( &'a self, dstkey: D, keys: K, ) -> ValkeyFuture<'a, usize>

ZINTERSTORE.
Source§

fn zinterstore_max<'a, D: ToSingleValkeyArg + Send + Sync + 'a, K: ToValkeyArgs + Send + Sync + 'a>( &'a self, dstkey: D, keys: K, ) -> ValkeyFuture<'a, usize>

ZINTERSTORE.
Source§

fn zinterstore_weights<'a, D: ToSingleValkeyArg + Send + Sync + 'a, K: ToValkeyArgs + Send + Sync + 'a, W: ToValkeyArgs + Send + Sync + 'a>( &'a self, dstkey: D, keys: &'a [(K, W)], ) -> ValkeyFuture<'a, usize>

ZINTERSTORE.
Source§

fn zinterstore_min_weights<'a, D: ToSingleValkeyArg + Send + Sync + 'a, K: ToValkeyArgs + Send + Sync + 'a, W: ToValkeyArgs + Send + Sync + 'a>( &'a self, dstkey: D, keys: &'a [(K, W)], ) -> ValkeyFuture<'a, usize>

ZINTERSTORE.
Source§

fn zinterstore_max_weights<'a, D: ToSingleValkeyArg + Send + Sync + 'a, K: ToValkeyArgs + Send + Sync + 'a, W: ToValkeyArgs + Send + Sync + 'a>( &'a self, dstkey: D, keys: &'a [(K, W)], ) -> ValkeyFuture<'a, usize>

ZINTERSTORE.
Source§

fn zlexcount<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a, MM: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, min: M, max: MM, ) -> ValkeyFuture<'a, usize>

ZLEXCOUNT.
Source§

fn bzpopmax<'a, K: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, timeout: f64, ) -> ValkeyFuture<'a, Option<(String, String, f64)>>

BZPOPMAX.
Source§

fn zpopmax<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, count: isize, ) -> ValkeyFuture<'a, Vec<(String, f64)>>

ZPOPMAX.
Source§

fn bzpopmin<'a, K: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, timeout: f64, ) -> ValkeyFuture<'a, Option<(String, String, f64)>>

BZPOPMIN.
Source§

fn zpopmin<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, count: isize, ) -> ValkeyFuture<'a, Vec<(String, f64)>>

ZPOPMIN.
Source§

fn bzmpop_max<'a, K: ToValkeyArgs + Send + Sync + 'a>( &'a self, timeout: f64, keys: K, count: isize, ) -> ValkeyFuture<'a, Option<(String, Vec<(String, f64)>)>>

BZMPOP.
Source§

fn zmpop_max<'a, K: ToValkeyArgs + Send + Sync + 'a>( &'a self, keys: K, count: isize, ) -> ValkeyFuture<'a, Option<(String, Vec<(String, f64)>)>>

ZMPOP.
Source§

fn bzmpop_min<'a, K: ToValkeyArgs + Send + Sync + 'a>( &'a self, timeout: f64, keys: K, count: isize, ) -> ValkeyFuture<'a, Option<(String, Vec<(String, f64)>)>>

BZMPOP.
Source§

fn zmpop_min<'a, K: ToValkeyArgs + Send + Sync + 'a>( &'a self, keys: K, count: isize, ) -> ValkeyFuture<'a, Option<(String, Vec<(String, f64)>)>>

ZMPOP.
Source§

fn zrandmember<'a, RV: FromValkeyValue, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, count: Option<isize>, ) -> ValkeyFuture<'a, RV>

ZRANDMEMBER.
Source§

fn zrandmember_withscores<'a, RV: FromValkeyValue, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, count: isize, ) -> ValkeyFuture<'a, RV>

ZRANDMEMBER WITHSCORES.
Source§

fn zrange<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, start: isize, stop: isize, ) -> ValkeyFuture<'a, Vec<String>>

ZRANGE.
Source§

fn zrange_withscores<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, start: isize, stop: isize, ) -> ValkeyFuture<'a, Vec<(String, f64)>>

ZRANGE WITHSCORES.
Source§

fn zrangebylex<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a, MM: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, min: M, max: MM, ) -> ValkeyFuture<'a, Vec<String>>

ZRANGEBYLEX.
Source§

fn zrangebylex_limit<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a, MM: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, min: M, max: MM, offset: isize, count: isize, ) -> ValkeyFuture<'a, Vec<String>>

ZRANGEBYLEX LIMIT.
Source§

fn zrevrangebylex<'a, K: ToSingleValkeyArg + Send + Sync + 'a, MM: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, max: MM, min: M, ) -> ValkeyFuture<'a, Vec<String>>

ZREVRANGEBYLEX.
Source§

fn zrevrangebylex_limit<'a, K: ToSingleValkeyArg + Send + Sync + 'a, MM: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, max: MM, min: M, offset: isize, count: isize, ) -> ValkeyFuture<'a, Vec<String>>

ZREVRANGEBYLEX LIMIT.
Source§

fn zrangebyscore<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a, MM: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, min: M, max: MM, ) -> ValkeyFuture<'a, Vec<String>>

ZRANGEBYSCORE.
Source§

fn zrangebyscore_withscores<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a, MM: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, min: M, max: MM, ) -> ValkeyFuture<'a, Vec<(String, usize)>>

ZRANGEBYSCORE WITHSCORES.
Source§

fn zrangebyscore_limit<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a, MM: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, min: M, max: MM, offset: isize, count: isize, ) -> ValkeyFuture<'a, Vec<String>>

ZRANGEBYSCORE LIMIT.
Source§

fn zrangebyscore_limit_withscores<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a, MM: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, min: M, max: MM, offset: isize, count: isize, ) -> ValkeyFuture<'a, Vec<(String, usize)>>

ZRANGEBYSCORE WITHSCORES LIMIT.
Source§

fn zrank<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, member: M, ) -> ValkeyFuture<'a, Option<usize>>

ZRANK.
Source§

fn zrem<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, members: M, ) -> ValkeyFuture<'a, usize>

ZREM.
Source§

fn zrembylex<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a, MM: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, min: M, max: MM, ) -> ValkeyFuture<'a, usize>

ZREMRANGEBYLEX.
Source§

fn zremrangebyrank<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, start: isize, stop: isize, ) -> ValkeyFuture<'a, usize>

ZREMRANGEBYRANK.
Source§

fn zrembyscore<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a, MM: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, min: M, max: MM, ) -> ValkeyFuture<'a, usize>

ZREMRANGEBYSCORE.
Source§

fn zrevrange<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, start: isize, stop: isize, ) -> ValkeyFuture<'a, Vec<String>>

ZREVRANGE.
Source§

fn zrevrange_withscores<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, start: isize, stop: isize, ) -> ValkeyFuture<'a, Vec<(String, f64)>>

ZREVRANGE WITHSCORES.
Source§

fn zrevrangebyscore<'a, K: ToSingleValkeyArg + Send + Sync + 'a, MM: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, max: MM, min: M, ) -> ValkeyFuture<'a, Vec<String>>

ZREVRANGEBYSCORE.
Source§

fn zrevrangebyscore_withscores<'a, K: ToSingleValkeyArg + Send + Sync + 'a, MM: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, max: MM, min: M, ) -> ValkeyFuture<'a, Vec<(String, f64)>>

ZREVRANGEBYSCORE WITHSCORES.
Source§

fn zrevrangebyscore_limit<'a, K: ToSingleValkeyArg + Send + Sync + 'a, MM: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, max: MM, min: M, offset: isize, count: isize, ) -> ValkeyFuture<'a, Vec<String>>

ZREVRANGEBYSCORE LIMIT.
Source§

fn zrevrangebyscore_limit_withscores<'a, K: ToSingleValkeyArg + Send + Sync + 'a, MM: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, max: MM, min: M, offset: isize, count: isize, ) -> ValkeyFuture<'a, Vec<(String, f64)>>

ZREVRANGEBYSCORE WITHSCORES LIMIT.
Source§

fn zrevrank<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, member: M, ) -> ValkeyFuture<'a, Option<usize>>

ZREVRANK.
Source§

fn zscore<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, member: M, ) -> ValkeyFuture<'a, Option<f64>>

ZSCORE.
Source§

fn zscore_multiple<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, members: &'a [M], ) -> ValkeyFuture<'a, Option<Vec<f64>>>

ZMSCORE.
Source§

fn zunionstore<'a, D: ToSingleValkeyArg + Send + Sync + 'a, K: ToValkeyArgs + Send + Sync + 'a>( &'a self, dstkey: D, keys: K, ) -> ValkeyFuture<'a, usize>

ZUNIONSTORE.
Source§

fn zunionstore_min<'a, D: ToSingleValkeyArg + Send + Sync + 'a, K: ToValkeyArgs + Send + Sync + 'a>( &'a self, dstkey: D, keys: K, ) -> ValkeyFuture<'a, usize>

ZUNIONSTORE AGGREGATE MIN.
Source§

fn zunionstore_max<'a, D: ToSingleValkeyArg + Send + Sync + 'a, K: ToValkeyArgs + Send + Sync + 'a>( &'a self, dstkey: D, keys: K, ) -> ValkeyFuture<'a, usize>

ZUNIONSTORE AGGREGATE MAX.
Source§

fn zunionstore_weights<'a, D: ToSingleValkeyArg + Send + Sync + 'a, K: ToValkeyArgs + Send + Sync + 'a, W: ToValkeyArgs + Send + Sync + 'a>( &'a self, dstkey: D, keys: &'a [(K, W)], ) -> ValkeyFuture<'a, usize>

ZUNIONSTORE WEIGHTS.
Source§

fn zunionstore_min_weights<'a, D: ToSingleValkeyArg + Send + Sync + 'a, K: ToValkeyArgs + Send + Sync + 'a, W: ToValkeyArgs + Send + Sync + 'a>( &'a self, dstkey: D, keys: &'a [(K, W)], ) -> ValkeyFuture<'a, usize>

ZUNIONSTORE AGGREGATE MIN WEIGHTS.
Source§

fn zunionstore_max_weights<'a, D: ToSingleValkeyArg + Send + Sync + 'a, K: ToValkeyArgs + Send + Sync + 'a, W: ToValkeyArgs + Send + Sync + 'a>( &'a self, dstkey: D, keys: &'a [(K, W)], ) -> ValkeyFuture<'a, usize>

ZUNIONSTORE AGGREGATE MAX WEIGHTS.
Source§

fn pfadd<'a, K: ToSingleValkeyArg + Send + Sync + 'a, E: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, element: E, ) -> ValkeyFuture<'a, bool>

PFADD.
Source§

fn pfcount<'a, K: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, ) -> ValkeyFuture<'a, usize>

PFCOUNT.
Source§

fn pfmerge<'a, D: ToSingleValkeyArg + Send + Sync + 'a, S: ToValkeyArgs + Send + Sync + 'a>( &'a self, dstkey: D, srckeys: S, ) -> ValkeyFuture<'a, ()>

PFMERGE.
Source§

fn setbit<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, offset: usize, value: bool, ) -> ValkeyFuture<'a, bool>

SETBIT.
Source§

fn getbit<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, offset: usize, ) -> ValkeyFuture<'a, bool>

GETBIT.
Source§

fn bitcount<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, ) -> ValkeyFuture<'a, usize>

BITCOUNT.
Source§

fn bitcount_range<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, start: usize, end: usize, ) -> ValkeyFuture<'a, usize>

BITCOUNT.
Source§

fn bit_and<'a, D: ToSingleValkeyArg + Send + Sync + 'a, S: ToValkeyArgs + Send + Sync + 'a>( &'a self, dstkey: D, srckeys: S, ) -> ValkeyFuture<'a, usize>

BITOP AND.
Source§

fn bit_or<'a, D: ToSingleValkeyArg + Send + Sync + 'a, S: ToValkeyArgs + Send + Sync + 'a>( &'a self, dstkey: D, srckeys: S, ) -> ValkeyFuture<'a, usize>

BITOP OR.
Source§

fn bit_xor<'a, D: ToSingleValkeyArg + Send + Sync + 'a, S: ToValkeyArgs + Send + Sync + 'a>( &'a self, dstkey: D, srckeys: S, ) -> ValkeyFuture<'a, usize>

BITOP XOR.
Source§

fn bit_not<'a, D: ToSingleValkeyArg + Send + Sync + 'a, S: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, dstkey: D, srckey: S, ) -> ValkeyFuture<'a, usize>

BITOP NOT.
Source§

fn geo_add<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, members: M, ) -> ValkeyFuture<'a, usize>

GEOADD.
Source§

fn geo_dist<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M1: ToSingleValkeyArg + Send + Sync + 'a, M2: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, key: K, member1: M1, member2: M2, unit: GeoUnit, ) -> ValkeyFuture<'a, Option<f64>>

GEODIST.
Source§

fn geo_hash<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, members: M, ) -> ValkeyFuture<'a, Vec<String>>

GEOHASH.
Source§

fn geo_pos<'a, K: ToSingleValkeyArg + Send + Sync + 'a, M: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, members: M, ) -> ValkeyFuture<'a, Vec<Option<GeoCoord<f64>>>>

GEOPOS.
Source§

fn xack<'a, K: ToValkeyArgs + Send + Sync + 'a, G: ToValkeyArgs + Send + Sync + 'a, I: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, group: G, ids: &'a [I], ) -> ValkeyFuture<'a, usize>

XACK.
Source§

fn xadd<'a, K: ToValkeyArgs + Send + Sync + 'a, ID: ToValkeyArgs + Send + Sync + 'a, F: ToValkeyArgs + Send + Sync + 'a, V: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, id: ID, items: &'a [(F, V)], ) -> ValkeyFuture<'a, Option<String>>

XADD.
Source§

fn xadd_options<'a, K: ToValkeyArgs + Send + Sync + 'a, ID: ToValkeyArgs + Send + Sync + 'a, I: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, id: ID, items: I, options: &'a StreamAddOptions, ) -> ValkeyFuture<'a, Option<String>>

XADD with options.
Source§

fn xautoclaim_options<'a, K: ToSingleValkeyArg + Send + Sync + 'a, G: ToValkeyArgs + Send + Sync + 'a, C: ToValkeyArgs + Send + Sync + 'a, MIT: ToValkeyArgs + Send + Sync + 'a, S: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, group: G, consumer: C, min_idle_time: MIT, start: S, options: StreamAutoClaimOptions, ) -> ValkeyFuture<'a, StreamAutoClaimReply>

XAUTOCLAIM.
Source§

fn xclaim<'a, K: ToSingleValkeyArg + Send + Sync + 'a, G: ToValkeyArgs + Send + Sync + 'a, C: ToValkeyArgs + Send + Sync + 'a, MIT: ToValkeyArgs + Send + Sync + 'a, ID: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, group: G, consumer: C, min_idle_time: MIT, ids: &'a [ID], ) -> ValkeyFuture<'a, StreamClaimReply>

XCLAIM.
Source§

fn xclaim_options<'a, RV: FromValkeyValue, K: ToSingleValkeyArg + Send + Sync + 'a, G: ToValkeyArgs + Send + Sync + 'a, C: ToValkeyArgs + Send + Sync + 'a, MIT: ToValkeyArgs + Send + Sync + 'a, ID: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, group: G, consumer: C, min_idle_time: MIT, ids: &'a [ID], options: StreamClaimOptions, ) -> ValkeyFuture<'a, RV>

XCLAIM.
Source§

fn xdel<'a, K: ToSingleValkeyArg + Send + Sync + 'a, ID: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, ids: &'a [ID], ) -> ValkeyFuture<'a, usize>

XDEL.
Source§

fn xgroup_create<'a, K: ToValkeyArgs + Send + Sync + 'a, G: ToValkeyArgs + Send + Sync + 'a, ID: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, group: G, id: ID, ) -> ValkeyFuture<'a, ()>

XGROUP CREATE.
Source§

fn xgroup_create_mkstream<'a, K: ToValkeyArgs + Send + Sync + 'a, G: ToValkeyArgs + Send + Sync + 'a, ID: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, group: G, id: ID, ) -> ValkeyFuture<'a, ()>

XGROUP CREATE ... MKSTREAM.
Source§

fn xgroup_createconsumer<'a, K: ToValkeyArgs + Send + Sync + 'a, G: ToValkeyArgs + Send + Sync + 'a, C: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, group: G, consumer: C, ) -> ValkeyFuture<'a, bool>

XGROUP CREATECONSUMER.
Source§

fn xgroup_delconsumer<'a, K: ToValkeyArgs + Send + Sync + 'a, G: ToValkeyArgs + Send + Sync + 'a, C: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, group: G, consumer: C, ) -> ValkeyFuture<'a, usize>

XGROUP DELCONSUMER.
Source§

fn xgroup_destroy<'a, K: ToValkeyArgs + Send + Sync + 'a, G: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, group: G, ) -> ValkeyFuture<'a, bool>

XGROUP DESTROY.
Source§

fn xgroup_setid<'a, K: ToValkeyArgs + Send + Sync + 'a, G: ToValkeyArgs + Send + Sync + 'a, ID: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, group: G, id: ID, ) -> ValkeyFuture<'a, ()>

XGROUP SETID.
Source§

fn xinfo_consumers<'a, K: ToValkeyArgs + Send + Sync + 'a, G: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, group: G, ) -> ValkeyFuture<'a, StreamInfoConsumersReply>

XINFO CONSUMERS.
Source§

fn xinfo_groups<'a, K: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, ) -> ValkeyFuture<'a, StreamInfoGroupsReply>

XINFO GROUPS.
Source§

fn xinfo_stream<'a, K: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, ) -> ValkeyFuture<'a, StreamInfoStreamReply>

XINFO STREAM.
Source§

fn xlen<'a, K: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, ) -> ValkeyFuture<'a, usize>

XLEN.
Source§

fn xpending<'a, K: ToValkeyArgs + Send + Sync + 'a, G: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, group: G, ) -> ValkeyFuture<'a, StreamPendingReply>

XPENDING.
Source§

fn xpending_count<'a, K: ToValkeyArgs + Send + Sync + 'a, G: ToValkeyArgs + Send + Sync + 'a, S: ToValkeyArgs + Send + Sync + 'a, E: ToValkeyArgs + Send + Sync + 'a, C: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, group: G, start: S, end: E, count: C, ) -> ValkeyFuture<'a, StreamPendingCountReply>

XPENDING (extended form).
Source§

fn xpending_consumer_count<'a, K: ToValkeyArgs + Send + Sync + 'a, G: ToValkeyArgs + Send + Sync + 'a, S: ToValkeyArgs + Send + Sync + 'a, E: ToValkeyArgs + Send + Sync + 'a, C: ToValkeyArgs + Send + Sync + 'a, CN: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, group: G, start: S, end: E, count: C, consumer: CN, ) -> ValkeyFuture<'a, StreamPendingCountReply>

XPENDING (extended form, filtered by consumer).
Source§

fn xrange<'a, K: ToValkeyArgs + Send + Sync + 'a, S: ToValkeyArgs + Send + Sync + 'a, E: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, start: S, end: E, ) -> ValkeyFuture<'a, StreamRangeReply>

XRANGE.
Source§

fn xread<'a, K: ToValkeyArgs + Send + Sync + 'a, ID: ToValkeyArgs + Send + Sync + 'a>( &'a self, keys: &'a [K], ids: &'a [ID], ) -> ValkeyFuture<'a, Option<StreamReadReply>>

XREAD.
Source§

fn xread_options<'a, K: ToValkeyArgs + Send + Sync + 'a, ID: ToValkeyArgs + Send + Sync + 'a>( &'a self, keys: &'a [K], ids: &'a [ID], options: &'a StreamReadOptions, ) -> ValkeyFuture<'a, Option<StreamReadReply>>

XREAD.
Source§

fn xrevrange<'a, K: ToValkeyArgs + Send + Sync + 'a, E: ToValkeyArgs + Send + Sync + 'a, S: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, end: E, start: S, ) -> ValkeyFuture<'a, StreamRangeReply>

XREVRANGE.
Source§

fn xtrim<'a, K: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, maxlen: StreamMaxlen, ) -> ValkeyFuture<'a, usize>

XTRIM ... MAXLEN.
Source§

fn xtrim_options<'a, K: ToValkeyArgs + Send + Sync + 'a>( &'a self, key: K, options: &'a StreamTrimOptions, ) -> ValkeyFuture<'a, usize>

XTRIM.
Source§

fn ping<'a>(&'a self) -> ValkeyFuture<'a, String>

PING.
Source§

fn ping_message<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, message: K, ) -> ValkeyFuture<'a, String>

PING with a message.
Source§

fn client_getname<'a>(&'a self) -> ValkeyFuture<'a, Option<String>>

CLIENT GETNAME.
Source§

fn client_id<'a>(&'a self) -> ValkeyFuture<'a, isize>

CLIENT ID.
Source§

fn client_setname<'a, K: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, connection_name: K, ) -> ValkeyFuture<'a, ()>

CLIENT SETNAME.
Source§

fn flushall<'a>(&'a self) -> ValkeyFuture<'a, ()>

FLUSHALL.
Source§

fn flushall_options<'a>( &'a self, options: &'a FlushAllOptions, ) -> ValkeyFuture<'a, ()>

FLUSHALL.
Source§

fn flushdb<'a>(&'a self) -> ValkeyFuture<'a, ()>

FLUSHDB.
Source§

fn flushdb_options<'a>( &'a self, options: &'a FlushDbOptions, ) -> ValkeyFuture<'a, ()>

FLUSHDB.
Source§

fn publish<'a, K: ToSingleValkeyArg + Send + Sync + 'a, E: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, channel: K, message: E, ) -> ValkeyFuture<'a, usize>

PUBLISH.
Source§

fn spublish<'a, K: ToSingleValkeyArg + Send + Sync + 'a, E: ToSingleValkeyArg + Send + Sync + 'a>( &'a self, channel: K, message: E, ) -> ValkeyFuture<'a, usize>

SPUBLISH.
Source§

fn scan<'s, RV: FromValkeyValue + 's>( &'s self, ) -> ValkeyFuture<'s, ScanIter<'s, Self, RV>>

Cursor-driven SCAN over the whole keyspace.
Source§

fn scan_match<'s, P: ToSingleValkeyArg, RV: FromValkeyValue + 's>( &'s self, pattern: P, ) -> ValkeyFuture<'s, ScanIter<'s, Self, RV>>

Cursor-driven SCAN over the keyspace, filtered by a MATCH pattern.
Source§

fn hscan<'s, K: ToSingleValkeyArg, RV: FromValkeyValue + 's>( &'s self, key: K, ) -> ValkeyFuture<'s, ScanIter<'s, Self, RV>>

Cursor-driven HSCAN over a hash’s fields and values.
Source§

fn hscan_match<'s, K: ToSingleValkeyArg, P: ToSingleValkeyArg, RV: FromValkeyValue + 's>( &'s self, key: K, pattern: P, ) -> ValkeyFuture<'s, ScanIter<'s, Self, RV>>

Cursor-driven HSCAN, filtered by a field-name MATCH pattern.
Source§

fn sscan<'s, K: ToSingleValkeyArg, RV: FromValkeyValue + 's>( &'s self, key: K, ) -> ValkeyFuture<'s, ScanIter<'s, Self, RV>>

Cursor-driven SSCAN over a set’s members.
Source§

fn sscan_match<'s, K: ToSingleValkeyArg, P: ToSingleValkeyArg, RV: FromValkeyValue + 's>( &'s self, key: K, pattern: P, ) -> ValkeyFuture<'s, ScanIter<'s, Self, RV>>

Cursor-driven SSCAN, filtered by a MATCH pattern.
Source§

fn zscan<'s, K: ToSingleValkeyArg, RV: FromValkeyValue + 's>( &'s self, key: K, ) -> ValkeyFuture<'s, ScanIter<'s, Self, RV>>

Cursor-driven ZSCAN over a sorted set’s members and scores.
Source§

fn zscan_match<'s, K: ToSingleValkeyArg, P: ToSingleValkeyArg, RV: FromValkeyValue + 's>( &'s self, key: K, pattern: P, ) -> ValkeyFuture<'s, ScanIter<'s, Self, RV>>

Cursor-driven ZSCAN, filtered by a MATCH pattern.
Source§

impl<T> BitmapCommands for T
where T: CommandExecutor + ?Sized,

Source§

fn bitpos<'life0, 'async_trait, K>( &'life0 self, key: K, bit: u8, ) -> Pin<Box<dyn Future<Output = ValkeyResult<i64>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Find the position of the first bit set to bit (BITPOS).
Source§

fn bitpos_range<'life0, 'async_trait, K>( &'life0 self, key: K, bit: u8, start: i64, end: i64, index_type: Option<BitmapIndexType>, ) -> Pin<Box<dyn Future<Output = ValkeyResult<i64>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Find the position of the first bit set to bit within a range (BITPOS key bit start end [BYTE|BIT]).
Source§

fn bitfield<'life0, 'life1, 'async_trait, K>( &'life0 self, key: K, subcommands: &'life1 [BitFieldSubcommand], ) -> Pin<Box<dyn Future<Output = ValkeyResult<Vec<Option<i64>>>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Perform arbitrary bit-field operations (BITFIELD). Returns one result per non-OVERFLOW subcommand; a None indicates a FAIL overflow.
Source§

fn bitfield_readonly<'life0, 'life1, 'async_trait, K>( &'life0 self, key: K, subcommands: &'life1 [BitFieldSubcommand], ) -> Pin<Box<dyn Future<Output = ValkeyResult<Vec<Option<i64>>>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Read-only bit-field operations (BITFIELD_RO). Only GET subcommands are permitted by the server.
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
where ST: ?Sized, DT: ?Sized,

Source§

impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
where ST: ?Sized, DT: ?Sized,

Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> ConnectionManagementCommands for T
where T: CommandExecutor + ?Sized,

Source§

fn echo<'life0, 'async_trait, M>( &'life0 self, message: M, ) -> Pin<Box<dyn Future<Output = ValkeyResult<Bytes>> + Send + 'async_trait>>
where M: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Echo a message (ECHO).
Source§

fn select<'life0, 'async_trait>( &'life0 self, index: i64, ) -> Pin<Box<dyn Future<Output = ValkeyResult<()>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait,

Select the logical database with the given index (SELECT).
Source§

fn client_no_evict<'life0, 'async_trait>( &'life0 self, on: bool, ) -> Pin<Box<dyn Future<Output = ValkeyResult<()>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait,

Enable or disable eviction for the current connection (CLIENT NO-EVICT).
Source§

fn client_no_touch<'life0, 'async_trait>( &'life0 self, on: bool, ) -> Pin<Box<dyn Future<Output = ValkeyResult<()>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait,

Enable or disable access-time updates for the current connection (CLIENT NO-TOUCH).
Source§

fn reset<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ValkeyResult<()>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait,

Reset the connection to its initial state (RESET).
Source§

impl<T> CustomCommand for T
where T: CommandExecutor + ?Sized,

Source§

fn custom_command<'life0, 'life1, 'async_trait, A>( &'life0 self, args: &'life1 [A], ) -> Pin<Box<dyn Future<Output = ValkeyResult<ValkeyValue>> + Send + 'async_trait>>
where A: ToValkeyArgs + Sync + 'async_trait, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Execute an arbitrary command given its already-encoded arguments, e.g. client.custom_command(&["SET", "key", "value"]).await. Read more
Source§

fn custom_command_with_route<'life0, 'life1, 'async_trait, A>( &'life0 self, args: &'life1 [A], route: Route, ) -> Pin<Box<dyn Future<Output = ValkeyResult<ValkeyValue>> + Send + 'async_trait>>
where A: ToValkeyArgs + Sync + 'async_trait, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Like CustomCommand::custom_command but routed (cluster). Ignored for standalone clients.
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T> FutureExt for T

Source§

fn with_context(self, otel_cx: Context) -> WithContext<Self> ⓘ

Attaches the provided Context to this type, returning a WithContext wrapper. Read more
Source§

fn with_current_context(self) -> WithContext<Self> ⓘ

Attaches the current Context to this type, returning a WithContext wrapper. Read more
Source§

impl<T> GenericCommands for T
where T: CommandExecutor + ?Sized,

Source§

fn randomkey<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ValkeyResult<Option<Bytes>>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait,

Return a random key from the keyspace (RANDOMKEY).
Source§

fn dump<'life0, 'async_trait, K>( &'life0 self, key: K, ) -> Pin<Box<dyn Future<Output = ValkeyResult<Option<Bytes>>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Serialize key (DUMP). Returns None if the key does not exist.
Source§

fn touch<'life0, 'life1, 'async_trait, K>( &'life0 self, keys: &'life1 [K], ) -> Pin<Box<dyn Future<Output = ValkeyResult<i64>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send + Sync, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Touch the given keys, returning how many were touched (TOUCH).
Source§

fn sort<'life0, 'async_trait, K>( &'life0 self, key: K, order: Option<OrderBy>, limit: Option<Limit>, alpha: bool, ) -> Pin<Box<dyn Future<Output = ValkeyResult<Vec<Bytes>>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Sort the elements at key (SORT), optionally by order and with an optional LIMIT offset count.
Source§

fn restore<'life0, 'async_trait, K, V>( &'life0 self, key: K, ttl_ms: i64, serialized: V, options: RestoreOptions, ) -> Pin<Box<dyn Future<Output = ValkeyResult<()>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, V: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Create a key from a serialized payload produced by DUMP (RESTORE).
Source§

fn wait<'life0, 'async_trait>( &'life0 self, numreplicas: i64, timeout_ms: i64, ) -> Pin<Box<dyn Future<Output = ValkeyResult<i64>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait,

Block until numreplicas replicas acknowledge previous writes, or until timeout_ms elapses (WAIT). Returns the number of replicas reached.
Source§

fn sort_store<'life0, 'async_trait, K, D>( &'life0 self, key: K, destination: D, order: Option<OrderBy>, limit: Option<Limit>, alpha: bool, ) -> Pin<Box<dyn Future<Output = ValkeyResult<i64>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, D: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Sort the elements at key and store the result into destination (SORT ... STORE destination). Returns the number of elements stored.
Source§

fn sort_ro<'life0, 'async_trait, K>( &'life0 self, key: K, order: Option<OrderBy>, limit: Option<Limit>, alpha: bool, ) -> Pin<Box<dyn Future<Output = ValkeyResult<Vec<Bytes>>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Read-only variant of SORT (SORT_RO); returns the sorted elements.
Source§

fn move_key<'life0, 'async_trait, K>( &'life0 self, key: K, db: i64, ) -> Pin<Box<dyn Future<Output = ValkeyResult<bool>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Move key to another logical database (MOVE). Returns whether the key was moved.
Source§

fn migrate<'life0, 'async_trait, H, K>( &'life0 self, host: H, port: i64, key: K, destination_db: i64, timeout_ms: i64, options: MigrateOptions, ) -> Pin<Box<dyn Future<Output = ValkeyResult<()>> + Send + 'async_trait>>
where H: 'async_trait + ToValkeyArgs + Send, K: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Atomically transfer a key to another instance (MIGRATE).
Source§

fn watch<'life0, 'life1, 'async_trait, K>( &'life0 self, keys: &'life1 [K], ) -> Pin<Box<dyn Future<Output = ValkeyResult<()>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send + Sync, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Watch the given keys for changes before a transaction (WATCH). Read more
Source§

fn unwatch<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ValkeyResult<()>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait,

Forget all watched keys (UNWATCH). Read more
Source§

impl<T> GeoCommands for T
where T: CommandExecutor + ?Sized,

Source§

fn geosearch_by_radius_from_member<'life0, 'async_trait, K, M>( &'life0 self, key: K, member: M, radius: f64, unit: GeoUnit, ) -> Pin<Box<dyn Future<Output = ValkeyResult<Vec<Bytes>>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, M: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Search a geospatial index by radius from a member (GEOSEARCH ... FROMMEMBER ... BYRADIUS).
Source§

fn geoadd_options<'life0, 'async_trait, K, M>( &'life0 self, key: K, members: M, existence_check: Option<ExistenceCheck>, changed: bool, ) -> Pin<Box<dyn Future<Output = ValkeyResult<i64>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, M: 'async_trait + ToValkeyArgs + Send + Sync, Self: Sync + 'async_trait, 'life0: 'async_trait,

Add geospatial members with options (GEOADD with NX/XX/CH). Returns the number of added (or, with changed, changed) members.
Source§

fn geosearch_from_member<'life0, 'async_trait, K, M>( &'life0 self, key: K, member: M, shape: GeoSearchShape, options: GeoSearchOptions, ) -> Pin<Box<dyn Future<Output = ValkeyResult<Vec<GeoSearchResult>>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, M: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Search a geospatial index from a member with a given shape. Returns the matching members.
Source§

fn geosearch_from_coord<'life0, 'async_trait, K>( &'life0 self, key: K, coord: GeoCoord<f64>, shape: GeoSearchShape, options: GeoSearchOptions, ) -> Pin<Box<dyn Future<Output = ValkeyResult<Vec<GeoSearchResult>>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Search a geospatial index from a coordinate with a given shape. Returns the matching members.
Source§

fn geosearchstore_from_member<'life0, 'async_trait, D, S, M>( &'life0 self, destination: D, source: S, member: M, shape: GeoSearchShape, options: GeoSearchStoreOptions, ) -> Pin<Box<dyn Future<Output = ValkeyResult<i64>> + Send + 'async_trait>>
where D: 'async_trait + ToValkeyArgs + Send, S: 'async_trait + ToValkeyArgs + Send, M: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Search from a member and store the results into destination. Returns the number of members stored.
Source§

fn geosearchstore_from_coord<'life0, 'async_trait, D, S>( &'life0 self, destination: D, source: S, coord: GeoCoord<f64>, shape: GeoSearchShape, options: GeoSearchStoreOptions, ) -> Pin<Box<dyn Future<Output = ValkeyResult<i64>> + Send + 'async_trait>>
where D: 'async_trait + ToValkeyArgs + Send, S: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Search from a coordinate and store the results into destination. Returns the number of members stored.
Source§

impl<T> HashCommands for T
where T: CommandExecutor + ?Sized,

Source§

fn hstrlen<'life0, 'async_trait, K, F>( &'life0 self, key: K, field: F, ) -> Pin<Box<dyn Future<Output = ValkeyResult<i64>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, F: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Get the string length of a field’s value (HSTRLEN).
Source§

fn hrandfield<'life0, 'async_trait, K>( &'life0 self, key: K, ) -> Pin<Box<dyn Future<Output = ValkeyResult<Option<Bytes>>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Get a random field from the hash (HRANDFIELD).
Source§

fn hrandfield_count<'life0, 'async_trait, K>( &'life0 self, key: K, count: i64, ) -> Pin<Box<dyn Future<Output = ValkeyResult<Vec<Bytes>>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Get count random fields from the hash (HRANDFIELD key count).
Source§

fn hrandfield_withvalues<'life0, 'async_trait, K>( &'life0 self, key: K, count: i64, ) -> Pin<Box<dyn Future<Output = ValkeyResult<Vec<(Bytes, Bytes)>>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Get count random fields with their values (HRANDFIELD key count WITHVALUES).
Source§

fn hscan_novalues<'life0, 'life1, 'life2, 'async_trait, K>( &'life0 self, key: K, cursor: &'life1 str, pattern: Option<&'life2 [u8]>, count: Option<i64>, ) -> Pin<Box<dyn Future<Output = ValkeyResult<(String, Vec<Bytes>)>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Incrementally iterate a hash returning only field names (HSCAN ... NOVALUES). Returns (cursor, fields).
Source§

impl<T> Instrument for T

Source§

fn instrument(self, span: Span) -> Instrumented<Self> ⓘ

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
Source§

fn in_current_span(self) -> Instrumented<Self> ⓘ

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<T> IntoRequest<T> for T

Source§

fn into_request(self) -> Request<T>

Wrap the input message T in a tonic::Request
Source§

impl<Unshared, Shared> IntoShared<Shared> for Unshared
where Shared: FromUnshared<Unshared>,

Source§

fn into_shared(self) -> Shared

Creates a shared type from an unshared type.
Source§

impl<T> JsonCommands for T
where T: CommandExecutor + ?Sized,

Source§

fn json_set<'life0, 'async_trait, K, P, V>( &'life0 self, key: K, path: P, value: V, ) -> Pin<Box<dyn Future<Output = ValkeyResult<()>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, P: 'async_trait + ToValkeyArgs + Send, V: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Set the JSON value at path in key (JSON.SET).
Source§

fn json_get<'life0, 'life1, 'async_trait, K, P>( &'life0 self, key: K, paths: &'life1 [P], ) -> Pin<Box<dyn Future<Output = ValkeyResult<Option<Bytes>>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, P: 'async_trait + ToValkeyArgs + Send + Sync, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get the JSON value(s) at paths in key (JSON.GET).
Source§

fn json_del<'life0, 'async_trait, K, P>( &'life0 self, key: K, path: P, ) -> Pin<Box<dyn Future<Output = ValkeyResult<i64>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, P: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Delete the value(s) at path (JSON.DEL); returns the number deleted.
Source§

fn json_forget<'life0, 'async_trait, K, P>( &'life0 self, key: K, path: P, ) -> Pin<Box<dyn Future<Output = ValkeyResult<i64>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, P: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Delete the value(s) at path (JSON.FORGET, an alias of JSON.DEL).
Source§

fn json_type<'life0, 'async_trait, K, P>( &'life0 self, key: K, path: P, ) -> Pin<Box<dyn Future<Output = ValkeyResult<ValkeyValue>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, P: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Get the type of the value(s) at path (JSON.TYPE).
Source§

fn json_numincrby<'life0, 'async_trait, K, P>( &'life0 self, key: K, path: P, value: f64, ) -> Pin<Box<dyn Future<Output = ValkeyResult<Option<Bytes>>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, P: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Increment the number(s) at path by value (JSON.NUMINCRBY). Returns the resulting value(s) encoded as a JSON string.
Source§

fn json_nummultby<'life0, 'async_trait, K, P>( &'life0 self, key: K, path: P, value: f64, ) -> Pin<Box<dyn Future<Output = ValkeyResult<Option<Bytes>>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, P: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Multiply the number(s) at path by value (JSON.NUMMULTBY).
Source§

fn json_strappend<'life0, 'async_trait, K, P, V>( &'life0 self, key: K, path: P, value: V, ) -> Pin<Box<dyn Future<Output = ValkeyResult<ValkeyValue>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, P: 'async_trait + ToValkeyArgs + Send, V: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Append value to the string(s) at path (JSON.STRAPPEND). Returns the new string length(s).
Source§

fn json_strlen<'life0, 'async_trait, K, P>( &'life0 self, key: K, path: P, ) -> Pin<Box<dyn Future<Output = ValkeyResult<ValkeyValue>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, P: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Get the length of the string(s) at path (JSON.STRLEN).
Source§

fn json_arrappend<'life0, 'life1, 'async_trait, K, P, V>( &'life0 self, key: K, path: P, values: &'life1 [V], ) -> Pin<Box<dyn Future<Output = ValkeyResult<ValkeyValue>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, P: 'async_trait + ToValkeyArgs + Send, V: 'async_trait + ToValkeyArgs + Send + Sync, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Append values to the array(s) at path (JSON.ARRAPPEND).
Source§

fn json_arrinsert<'life0, 'life1, 'async_trait, K, P, V>( &'life0 self, key: K, path: P, index: i64, values: &'life1 [V], ) -> Pin<Box<dyn Future<Output = ValkeyResult<ValkeyValue>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, P: 'async_trait + ToValkeyArgs + Send, V: 'async_trait + ToValkeyArgs + Send + Sync, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Insert values into the array(s) at path starting at index (JSON.ARRINSERT).
Source§

fn json_arrlen<'life0, 'async_trait, K, P>( &'life0 self, key: K, path: P, ) -> Pin<Box<dyn Future<Output = ValkeyResult<ValkeyValue>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, P: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Get the length of the array(s) at path (JSON.ARRLEN).
Source§

fn json_arrpop<'life0, 'async_trait, K, P>( &'life0 self, key: K, path: P, index: Option<i64>, ) -> Pin<Box<dyn Future<Output = ValkeyResult<ValkeyValue>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, P: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Pop an element from the array(s) at path at index (JSON.ARRPOP).
Source§

fn json_arrtrim<'life0, 'async_trait, K, P>( &'life0 self, key: K, path: P, start: i64, stop: i64, ) -> Pin<Box<dyn Future<Output = ValkeyResult<ValkeyValue>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, P: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Trim the array(s) at path to the inclusive range [start, stop] (JSON.ARRTRIM).
Source§

fn json_objkeys<'life0, 'async_trait, K, P>( &'life0 self, key: K, path: P, ) -> Pin<Box<dyn Future<Output = ValkeyResult<ValkeyValue>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, P: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Get the keys of the object(s) at path (JSON.OBJKEYS).
Source§

fn json_objlen<'life0, 'async_trait, K, P>( &'life0 self, key: K, path: P, ) -> Pin<Box<dyn Future<Output = ValkeyResult<ValkeyValue>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, P: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Get the number of keys in the object(s) at path (JSON.OBJLEN).
Source§

fn json_toggle<'life0, 'async_trait, K, P>( &'life0 self, key: K, path: P, ) -> Pin<Box<dyn Future<Output = ValkeyResult<ValkeyValue>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, P: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Toggle the boolean value(s) at path (JSON.TOGGLE).
Source§

fn json_clear<'life0, 'async_trait, K, P>( &'life0 self, key: K, path: P, ) -> Pin<Box<dyn Future<Output = ValkeyResult<i64>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, P: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Clear container value(s) at path (JSON.CLEAR); returns the number of values cleared.
Source§

fn json_arrindex<'life0, 'async_trait, K, P, V>( &'life0 self, key: K, path: P, value: V, range: Option<(i64, i64)>, ) -> Pin<Box<dyn Future<Output = ValkeyResult<ValkeyValue>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, P: 'async_trait + ToValkeyArgs + Send, V: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Find the index of value in the array(s) at path (JSON.ARRINDEX). Optionally restrict the search to [start, end).
Source§

fn json_mget<'life0, 'life1, 'async_trait, K, P>( &'life0 self, keys: &'life1 [K], path: P, ) -> Pin<Box<dyn Future<Output = ValkeyResult<Vec<Option<Bytes>>>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send + Sync, P: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get the value(s) at path from multiple keys (JSON.MGET).
Source§

fn json_resp<'life0, 'async_trait, K, P>( &'life0 self, key: K, path: P, ) -> Pin<Box<dyn Future<Output = ValkeyResult<ValkeyValue>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, P: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Get the value(s) at path in RESP form (JSON.RESP).
Source§

fn json_debug_memory<'life0, 'async_trait, K, P>( &'life0 self, key: K, path: P, ) -> Pin<Box<dyn Future<Output = ValkeyResult<ValkeyValue>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, P: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Report the memory usage of the value(s) at path (JSON.DEBUG MEMORY).
Source§

fn json_debug_fields<'life0, 'async_trait, K, P>( &'life0 self, key: K, path: P, ) -> Pin<Box<dyn Future<Output = ValkeyResult<ValkeyValue>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, P: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Report the number of fields in the value(s) at path (JSON.DEBUG FIELDS).
Source§

impl<L> LayerExt<L> for L

Source§

fn named_layer<S>(&self, service: S) -> Layered<<L as Layer<S>>::Service, S>
where L: Layer<S>,

Applies the layer to a service and wraps it in Layered.
Source§

impl<T> PolicyExt for T
where T: ?Sized,

Source§

fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Sized + Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns Action::Follow only if self and other return Action::Follow. Read more
Source§

fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Sized + Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns Action::Follow if either self or other returns Action::Follow. Read more
Source§

impl<T> PubSubCommands for T
where T: CommandExecutor + ?Sized,

Source§

fn subscribe<'life0, 'life1, 'async_trait, C>( &'life0 self, channels: &'life1 [C], ) -> Pin<Box<dyn Future<Output = ValkeyResult<()>> + Send + 'async_trait>>
where C: 'async_trait + ToValkeyArgs + Send + Sync, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Subscribe to one or more exact channels at runtime (SUBSCRIBE). Read more
Source§

fn unsubscribe<'life0, 'life1, 'async_trait, C>( &'life0 self, channels: &'life1 [C], ) -> Pin<Box<dyn Future<Output = ValkeyResult<()>> + Send + 'async_trait>>
where C: 'async_trait + ToValkeyArgs + Send + Sync, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Unsubscribe from exact channels (UNSUBSCRIBE). An empty slice unsubscribes from all exact channels.
Source§

fn psubscribe<'life0, 'life1, 'async_trait, C>( &'life0 self, patterns: &'life1 [C], ) -> Pin<Box<dyn Future<Output = ValkeyResult<()>> + Send + 'async_trait>>
where C: 'async_trait + ToValkeyArgs + Send + Sync, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Subscribe to one or more glob patterns at runtime (PSUBSCRIBE). See Self::subscribe for delivery requirements.
Source§

fn punsubscribe<'life0, 'life1, 'async_trait, C>( &'life0 self, patterns: &'life1 [C], ) -> Pin<Box<dyn Future<Output = ValkeyResult<()>> + Send + 'async_trait>>
where C: 'async_trait + ToValkeyArgs + Send + Sync, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Unsubscribe from patterns (PUNSUBSCRIBE). An empty slice unsubscribes from all patterns.
Source§

fn ssubscribe<'life0, 'life1, 'async_trait, C>( &'life0 self, channels: &'life1 [C], ) -> Pin<Box<dyn Future<Output = ValkeyResult<()>> + Send + 'async_trait>>
where C: 'async_trait + ToValkeyArgs + Send + Sync, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Subscribe to one or more shard channels at runtime (SSUBSCRIBE, cluster only). See Self::subscribe for delivery requirements.
Source§

fn sunsubscribe<'life0, 'life1, 'async_trait, C>( &'life0 self, channels: &'life1 [C], ) -> Pin<Box<dyn Future<Output = ValkeyResult<()>> + Send + 'async_trait>>
where C: 'async_trait + ToValkeyArgs + Send + Sync, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Unsubscribe from shard channels (SUNSUBSCRIBE). An empty slice unsubscribes from all shard channels.
Source§

fn pubsub_channels<'life0, 'life1, 'async_trait>( &'life0 self, pattern: Option<&'life1 [u8]>, ) -> Pin<Box<dyn Future<Output = ValkeyResult<Vec<Bytes>>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List active channels, optionally matching pattern (PUBSUB CHANNELS).
Source§

fn pubsub_shardchannels<'life0, 'life1, 'async_trait>( &'life0 self, pattern: Option<&'life1 [u8]>, ) -> Pin<Box<dyn Future<Output = ValkeyResult<Vec<Bytes>>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List active shard channels, optionally matching pattern (PUBSUB SHARDCHANNELS).
Source§

fn pubsub_numpat<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ValkeyResult<i64>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait,

Get the number of subscriptions to patterns (PUBSUB NUMPAT).
Source§

fn pubsub_numsub<'life0, 'life1, 'async_trait, C>( &'life0 self, channels: &'life1 [C], ) -> Pin<Box<dyn Future<Output = ValkeyResult<Vec<(Bytes, i64)>>> + Send + 'async_trait>>
where C: 'async_trait + ToValkeyArgs + Send + Sync, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get the number of subscribers per channel (PUBSUB NUMSUB).
Source§

fn pubsub_shardnumsub<'life0, 'life1, 'async_trait, C>( &'life0 self, channels: &'life1 [C], ) -> Pin<Box<dyn Future<Output = ValkeyResult<Vec<(Bytes, i64)>>> + Send + 'async_trait>>
where C: 'async_trait + ToValkeyArgs + Send + Sync, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get the number of subscribers per shard channel (PUBSUB SHARDNUMSUB).
Source§

impl<T> Read<Exclusive, BecauseExclusive> for T
where T: ?Sized,

Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

impl<T> ScriptingCommands for T
where T: CommandExecutor + ?Sized,

Source§

fn eval<'life0, 'life1, 'life2, 'life3, 'async_trait, K, A>( &'life0 self, script: &'life1 str, keys: &'life2 [K], args: &'life3 [A], ) -> Pin<Box<dyn Future<Output = ValkeyResult<ValkeyValue>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send + Sync, A: 'async_trait + ToValkeyArgs + Send + Sync, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Evaluate a Lua script (EVAL). Returns the raw reply.
Source§

fn evalsha<'life0, 'life1, 'life2, 'life3, 'async_trait, K, A>( &'life0 self, sha1: &'life1 str, keys: &'life2 [K], args: &'life3 [A], ) -> Pin<Box<dyn Future<Output = ValkeyResult<ValkeyValue>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send + Sync, A: 'async_trait + ToValkeyArgs + Send + Sync, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Evaluate a cached script by its SHA1 hash (EVALSHA).
Source§

fn script_load<'life0, 'life1, 'async_trait>( &'life0 self, script: &'life1 str, ) -> Pin<Box<dyn Future<Output = ValkeyResult<String>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Load a script into the script cache, returning its SHA1 (SCRIPT LOAD).
Source§

fn script_exists<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, sha1s: &'life1 [&'life2 str], ) -> Pin<Box<dyn Future<Output = ValkeyResult<Vec<bool>>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Check whether scripts exist in the cache by SHA1 (SCRIPT EXISTS).
Source§

fn script_flush<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ValkeyResult<()>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait,

Flush the script cache (SCRIPT FLUSH).
Source§

fn fcall<'life0, 'life1, 'life2, 'life3, 'async_trait, K, A>( &'life0 self, function: &'life1 str, keys: &'life2 [K], args: &'life3 [A], ) -> Pin<Box<dyn Future<Output = ValkeyResult<ValkeyValue>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send + Sync, A: 'async_trait + ToValkeyArgs + Send + Sync, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Invoke a function registered with FUNCTION LOAD (FCALL).
Source§

fn fcall_ro<'life0, 'life1, 'life2, 'life3, 'async_trait, K, A>( &'life0 self, function: &'life1 str, keys: &'life2 [K], args: &'life3 [A], ) -> Pin<Box<dyn Future<Output = ValkeyResult<ValkeyValue>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send + Sync, A: 'async_trait + ToValkeyArgs + Send + Sync, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Read-only variant of ScriptingCommands::fcall (FCALL_RO).
Source§

fn fcall_route<'life0, 'life1, 'life2, 'life3, 'async_trait, K, A>( &'life0 self, function: &'life1 str, keys: &'life2 [K], args: &'life3 [A], route: Route, ) -> Pin<Box<dyn Future<Output = ValkeyResult<ValkeyValue>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send + Sync, A: 'async_trait + ToValkeyArgs + Send + Sync, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

FCALL routed to specific cluster node(s) (route). Keyless function calls are commonly invoked with an explicit route (e.g. AllPrimaries); on a standalone client the route is ignored.
Source§

fn fcall_ro_route<'life0, 'life1, 'life2, 'life3, 'async_trait, K, A>( &'life0 self, function: &'life1 str, keys: &'life2 [K], args: &'life3 [A], route: Route, ) -> Pin<Box<dyn Future<Output = ValkeyResult<ValkeyValue>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send + Sync, A: 'async_trait + ToValkeyArgs + Send + Sync, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Read-only FCALL_RO routed to specific cluster node(s) (route). On a standalone client the route is ignored.
Source§

fn function_load<'life0, 'life1, 'async_trait>( &'life0 self, code: &'life1 str, replace: bool, ) -> Pin<Box<dyn Future<Output = ValkeyResult<String>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Load a function library (FUNCTION LOAD); returns the library name.
Source§

fn function_delete<'life0, 'life1, 'async_trait>( &'life0 self, library_name: &'life1 str, ) -> Pin<Box<dyn Future<Output = ValkeyResult<()>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete a function library (FUNCTION DELETE).
Source§

fn function_flush<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ValkeyResult<()>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait,

Flush all function libraries (FUNCTION FLUSH).
Source§

fn function_flush_options<'life0, 'life1, 'async_trait>( &'life0 self, options: &'life1 FunctionFlushOptions, ) -> Pin<Box<dyn Future<Output = ValkeyResult<()>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Flush all function libraries (FUNCTION FLUSH SYNC|ASYNC).
Source§

fn function_list<'life0, 'life1, 'async_trait>( &'life0 self, library_name: Option<&'life1 str>, with_code: bool, ) -> Pin<Box<dyn Future<Output = ValkeyResult<ValkeyValue>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List registered function libraries (FUNCTION LIST). Set with_code to include the library source. Returns the raw structured reply.
Source§

fn function_dump<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ValkeyResult<Bytes>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait,

Dump the serialized payload of all function libraries (FUNCTION DUMP).
Source§

fn function_restore<'life0, 'async_trait, P>( &'life0 self, payload: P, policy: FunctionRestorePolicy, ) -> Pin<Box<dyn Future<Output = ValkeyResult<()>> + Send + 'async_trait>>
where P: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Restore function libraries from a FUNCTION DUMP payload (FUNCTION RESTORE).
Source§

fn function_stats<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ValkeyResult<ValkeyValue>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait,

Get information about the function engine and running function (FUNCTION STATS). Returns the raw structured reply.
Source§

fn function_kill<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ValkeyResult<()>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait,

Kill a running function that made no write commands (FUNCTION KILL).
Source§

fn script_kill<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ValkeyResult<()>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait,

Kill a running script that made no write commands (SCRIPT KILL).
Source§

fn script_show<'life0, 'life1, 'async_trait>( &'life0 self, sha1: &'life1 str, ) -> Pin<Box<dyn Future<Output = ValkeyResult<Bytes>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Show the source of a cached script by its SHA1 (SCRIPT SHOW, Valkey 8+).
Source§

impl<T> ServerManagementCommands for T
where T: CommandExecutor + ?Sized,

Source§

fn info<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ValkeyResult<String>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait,

Get server information and statistics (INFO).
Source§

fn info_sections<'life0, 'life1, 'async_trait, S>( &'life0 self, sections: &'life1 [S], ) -> Pin<Box<dyn Future<Output = ValkeyResult<String>> + Send + 'async_trait>>
where S: 'async_trait + ToValkeyArgs + Send + Sync, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get server information for specific sections (INFO section...).
Source§

fn dbsize<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ValkeyResult<i64>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait,

Get the number of keys in the current database (DBSIZE).
Source§

fn config_get<'life0, 'async_trait, P>( &'life0 self, parameter: P, ) -> Pin<Box<dyn Future<Output = ValkeyResult<HashMap<String, Bytes>>> + Send + 'async_trait>>
where P: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Get configuration parameters matching parameter (CONFIG GET).
Source§

fn config_set<'life0, 'async_trait, P, V>( &'life0 self, parameter: P, value: V, ) -> Pin<Box<dyn Future<Output = ValkeyResult<()>> + Send + 'async_trait>>
where P: 'async_trait + ToValkeyArgs + Send, V: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Set a configuration parameter (CONFIG SET).
Source§

fn config_resetstat<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ValkeyResult<()>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait,

Reset configuration statistics (CONFIG RESETSTAT).
Source§

fn time<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ValkeyResult<(i64, i64)>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait,

Get the server time as (unix_seconds, microseconds) (TIME).
Source§

fn lastsave<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ValkeyResult<i64>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait,

Get the Unix time of the last successful save to disk (LASTSAVE).
Source§

fn config_rewrite<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ValkeyResult<()>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait,

Rewrite the configuration file with the in-memory configuration (CONFIG REWRITE).
Source§

fn lolwut<'life0, 'async_trait>( &'life0 self, version: Option<i64>, ) -> Pin<Box<dyn Future<Output = ValkeyResult<String>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait,

Display a piece of generative art and the server version (LOLWUT), optionally selecting a rendering version.
Source§

fn bgrewriteaof<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ValkeyResult<String>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait,

Asynchronously rewrite the append-only file (BGREWRITEAOF). Returns the server’s status message.
Source§

fn bgsave<'life0, 'async_trait>( &'life0 self, schedule: bool, ) -> Pin<Box<dyn Future<Output = ValkeyResult<String>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait,

Asynchronously save the dataset to disk (BGSAVE). Set schedule to defer until no other save is running. Returns the server’s status message.
Source§

fn save<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ValkeyResult<()>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait,

Synchronously save the dataset to disk (SAVE).
Source§

fn replicaof<'life0, 'async_trait, H>( &'life0 self, host: H, port: i64, ) -> Pin<Box<dyn Future<Output = ValkeyResult<()>> + Send + 'async_trait>>
where H: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Make the server a replica of another instance (REPLICAOF host port).
Source§

fn replicaof_no_one<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ValkeyResult<()>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait,

Promote the server to a primary (REPLICAOF NO ONE).
Source§

fn failover<'life0, 'async_trait, H>( &'life0 self, to: Option<(H, i64)>, force: bool, timeout_ms: Option<i64>, ) -> Pin<Box<dyn Future<Output = ValkeyResult<()>> + Send + 'async_trait>>
where H: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Start a coordinated failover between the primary and a replica (FAILOVER).
Source§

fn failover_abort<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ValkeyResult<()>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait,

Abort an in-progress coordinated failover (FAILOVER ABORT).
Source§

fn client_pause<'life0, 'async_trait>( &'life0 self, timeout_ms: i64, mode: Option<ClientPauseMode>, ) -> Pin<Box<dyn Future<Output = ValkeyResult<()>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait,

Suspend client commands for up to timeout_ms (CLIENT PAUSE).
Source§

fn client_unpause<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ValkeyResult<()>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait,

Resume paused clients (CLIENT UNPAUSE).
Source§

fn latency_history<'life0, 'async_trait, E>( &'life0 self, event: E, ) -> Pin<Box<dyn Future<Output = ValkeyResult<ValkeyValue>> + Send + 'async_trait>>
where E: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Get latency time series for an event (LATENCY HISTORY).
Source§

fn latency_latest<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ValkeyResult<ValkeyValue>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait,

Get the latest latency samples for all events (LATENCY LATEST).
Source§

fn latency_reset<'life0, 'life1, 'async_trait, E>( &'life0 self, events: &'life1 [E], ) -> Pin<Box<dyn Future<Output = ValkeyResult<i64>> + Send + 'async_trait>>
where E: 'async_trait + ToValkeyArgs + Send + Sync, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Reset latency data, returning the number of event time series reset (LATENCY RESET).
Source§

fn latency_doctor<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ValkeyResult<String>> + Send + 'async_trait>>
where Self: Sync + 'async_trait, 'life0: 'async_trait,

Get a human-readable latency diagnosis report (LATENCY DOCTOR).
Source§

fn latency_graph<'life0, 'async_trait, E>( &'life0 self, event: E, ) -> Pin<Box<dyn Future<Output = ValkeyResult<String>> + Send + 'async_trait>>
where E: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Get a latency graph for an event (LATENCY GRAPH).
Source§

impl<T> SetCommands for T
where T: CommandExecutor + ?Sized,

Source§

fn sintercard<'life0, 'life1, 'async_trait, K>( &'life0 self, keys: &'life1 [K], ) -> Pin<Box<dyn Future<Output = ValkeyResult<i64>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send + Sync, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Cardinality of the intersection of the given sets (SINTERCARD).
Source§

fn sintercard_limit<'life0, 'life1, 'async_trait, K>( &'life0 self, keys: &'life1 [K], limit: i64, ) -> Pin<Box<dyn Future<Output = ValkeyResult<i64>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send + Sync, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Cardinality of the intersection of the given sets with a LIMIT (SINTERCARD numkeys key [key ...] LIMIT limit). A limit of 0 means no limit.
Source§

impl<T> SortedSetCommands for T
where T: CommandExecutor + ?Sized,

Source§

fn zadd_incr<'life0, 'async_trait, K, M>( &'life0 self, key: K, member: M, increment: f64, ) -> Pin<Box<dyn Future<Output = ValkeyResult<Option<f64>>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, M: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Increment the score of member by increment (ZADD ... INCR). Read more
Source§

fn zrank_withscore<'life0, 'async_trait, K, M>( &'life0 self, key: K, member: M, ) -> Pin<Box<dyn Future<Output = ValkeyResult<Option<(i64, f64)>>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, M: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Get the rank of member with its score, low to high (ZRANK ... WITHSCORE).
Source§

fn zrevrank_withscore<'life0, 'async_trait, K, M>( &'life0 self, key: K, member: M, ) -> Pin<Box<dyn Future<Output = ValkeyResult<Option<(i64, f64)>>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, M: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Get the rank of member with its score, high to low (ZREVRANK ... WITHSCORE).
Source§

fn zrangestore_by_index<'life0, 'async_trait, D, S>( &'life0 self, destination: D, source: S, start: i64, stop: i64, rev: bool, ) -> Pin<Box<dyn Future<Output = ValkeyResult<i64>> + Send + 'async_trait>>
where D: 'async_trait + ToValkeyArgs + Send, S: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Store a range of a sorted set into destination (ZRANGESTORE by index). Returns the number of elements stored.
Source§

fn zrangestore_by_score<'life0, 'async_trait, D, S>( &'life0 self, destination: D, source: S, min: ScoreBound, max: ScoreBound, rev: bool, limit: Option<Limit>, ) -> Pin<Box<dyn Future<Output = ValkeyResult<i64>> + Send + 'async_trait>>
where D: 'async_trait + ToValkeyArgs + Send, S: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Store into destination the members of the sorted set source whose scores are within [min, max] (ZRANGESTORE ... BYSCORE), returning the number of elements stored. Read more
Source§

fn zrangestore_by_lex<'life0, 'life1, 'life2, 'async_trait, D, S>( &'life0 self, destination: D, source: S, min: &'life1 LexBound, max: &'life2 LexBound, rev: bool, limit: Option<Limit>, ) -> Pin<Box<dyn Future<Output = ValkeyResult<i64>> + Send + 'async_trait>>
where D: 'async_trait + ToValkeyArgs + Send, S: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Store into destination the members of the sorted set source whose lexicographical values are within [min, max] (ZRANGESTORE ... BYLEX), returning the number of elements stored. Read more
Source§

fn zdiff<'life0, 'life1, 'async_trait, K>( &'life0 self, keys: &'life1 [K], ) -> Pin<Box<dyn Future<Output = ValkeyResult<Vec<Bytes>>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send + Sync, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Compute the difference of the given sorted sets (ZDIFF).
Source§

fn zdiff_withscores<'life0, 'life1, 'async_trait, K>( &'life0 self, keys: &'life1 [K], ) -> Pin<Box<dyn Future<Output = ValkeyResult<Vec<(Bytes, f64)>>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send + Sync, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Compute the difference of the given sorted sets with scores (ZDIFF ... WITHSCORES).
Source§

fn zdiffstore<'life0, 'life1, 'async_trait, D, K>( &'life0 self, destination: D, keys: &'life1 [K], ) -> Pin<Box<dyn Future<Output = ValkeyResult<i64>> + Send + 'async_trait>>
where D: 'async_trait + ToValkeyArgs + Send, K: 'async_trait + ToValkeyArgs + Send + Sync, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Store the difference of the given sorted sets into destination (ZDIFFSTORE).
Source§

fn zunion<'life0, 'life1, 'async_trait, K>( &'life0 self, keys: &'life1 [K], aggregate: Option<AggregationType>, ) -> Pin<Box<dyn Future<Output = ValkeyResult<Vec<Bytes>>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send + Sync, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Compute the union of the given sorted sets (ZUNION).
Source§

fn zunion_withscores<'life0, 'life1, 'async_trait, K>( &'life0 self, keys: &'life1 [K], aggregate: Option<AggregationType>, ) -> Pin<Box<dyn Future<Output = ValkeyResult<Vec<(Bytes, f64)>>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send + Sync, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Compute the union of the given sorted sets with scores (ZUNION ... WITHSCORES).
Source§

fn zinter<'life0, 'life1, 'async_trait, K>( &'life0 self, keys: &'life1 [K], aggregate: Option<AggregationType>, ) -> Pin<Box<dyn Future<Output = ValkeyResult<Vec<Bytes>>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send + Sync, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Compute the intersection of the given sorted sets (ZINTER).
Source§

fn zinter_withscores<'life0, 'life1, 'async_trait, K>( &'life0 self, keys: &'life1 [K], aggregate: Option<AggregationType>, ) -> Pin<Box<dyn Future<Output = ValkeyResult<Vec<(Bytes, f64)>>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send + Sync, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Compute the intersection of the given sorted sets with scores (ZINTER ... WITHSCORES).
Source§

fn zintercard<'life0, 'life1, 'async_trait, K>( &'life0 self, keys: &'life1 [K], limit: Option<i64>, ) -> Pin<Box<dyn Future<Output = ValkeyResult<i64>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send + Sync, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Cardinality of the intersection of the given sorted sets (ZINTERCARD), with an optional LIMIT.
Source§

impl<T> StreamCommands for T
where T: CommandExecutor + ?Sized,

Source§

fn xreadgroup<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait, K>( &'life0 self, group: &'life1 str, consumer: &'life2 str, keys_ids: &'life3 [(K, &'life4 str)], options: Option<StreamReadGroupOptions>, ) -> Pin<Box<dyn Future<Output = ValkeyResult<Vec<(Bytes, Vec<StreamEntry>)>>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send + Sync, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Read from streams as part of a consumer group (XREADGROUP).
Source§

fn xpending_range<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait, K>( &'life0 self, key: K, group: &'life1 str, start: &'life2 str, end: &'life3 str, count: i64, min_idle_time_ms: Option<i64>, consumer: Option<&'life4 str>, ) -> Pin<Box<dyn Future<Output = ValkeyResult<Vec<XPendingEntry>>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Extended (range) form of XPENDING (XPENDING key group [IDLE ms] start end count [consumer]).
Source§

fn xinfo_stream_full<'life0, 'async_trait, K>( &'life0 self, key: K, count: Option<i64>, ) -> Pin<Box<dyn Future<Output = ValkeyResult<Vec<(Bytes, ValkeyValue)>>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Get the full state of a stream including entries and PEL (XINFO STREAM ... FULL). Returns the raw structured reply as (field, value) pairs. Pass count to limit returned entries/PEL.
Source§

fn xsetid<'life0, 'life1, 'life2, 'async_trait, K>( &'life0 self, key: K, last_id: &'life1 str, entries_added: Option<i64>, max_deleted_id: Option<&'life2 str>, ) -> Pin<Box<dyn Future<Output = ValkeyResult<()>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Set the last-delivered ID of a stream (XSETID).
Source§

fn xgroup_create_options<'life0, 'life1, 'life2, 'life3, 'async_trait, K>( &'life0 self, key: K, group: &'life1 str, id: &'life2 str, options: &'life3 StreamGroupCreateOptions, ) -> Pin<Box<dyn Future<Output = ValkeyResult<()>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Create a consumer group with options (XGROUP CREATE with MKSTREAM / ENTRIESREAD).
Source§

fn xgroup_set_id<'life0, 'life1, 'life2, 'async_trait, K>( &'life0 self, key: K, group: &'life1 str, id: &'life2 str, entries_read: Option<i64>, ) -> Pin<Box<dyn Future<Output = ValkeyResult<()>> + Send + 'async_trait>>
where K: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Set the last-delivered ID for a consumer group (XGROUP SETID).
Source§

impl<T> StringCommands for T
where T: CommandExecutor + ?Sized,

Source§

fn lcs_len<'life0, 'async_trait, K1, K2>( &'life0 self, key1: K1, key2: K2, ) -> Pin<Box<dyn Future<Output = ValkeyResult<i64>> + Send + 'async_trait>>
where K1: 'async_trait + ToValkeyArgs + Send, K2: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Longest common subsequence length between two keys (LCS ... LEN).
Source§

fn lcs<'life0, 'async_trait, K1, K2>( &'life0 self, key1: K1, key2: K2, ) -> Pin<Box<dyn Future<Output = ValkeyResult<Bytes>> + Send + 'async_trait>>
where K1: 'async_trait + ToValkeyArgs + Send, K2: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Get the longest common subsequence of two keys (LCS).
Source§

fn lcs_idx<'life0, 'async_trait, K1, K2>( &'life0 self, key1: K1, key2: K2, min_match_len: Option<i64>, with_match_len: bool, ) -> Pin<Box<dyn Future<Output = ValkeyResult<ValkeyValue>> + Send + 'async_trait>>
where K1: 'async_trait + ToValkeyArgs + Send, K2: 'async_trait + ToValkeyArgs + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Get the LCS match positions between two keys (LCS ... IDX). Returns the raw structured reply (a map of matches/len). Pass min_match_len to filter short matches, and with_match_len to include per-match lengths.
Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = !

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, !>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V

Source§

impl<T> WithSubscriber for T

Source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> ⓘ
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

fn with_current_subscriber(self) -> WithDispatch<Self> ⓘ

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more