Skip to main content

SyncGlideClient

Struct SyncGlideClient 

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

A blocking client for a standalone deployment.

Implementations§

Source§

impl SyncGlideClient

Source

pub fn connect(config: GlideClientConfiguration) -> ValkeyResult<Self>

Connect using the given standalone configuration (blocking).

Source

pub fn async_client(&self) -> &GlideClient

The underlying async client.

Source

pub fn run<F, Fut, T>(&self, f: F) -> T
where F: FnOnce(GlideClient) -> Fut, Fut: Future<Output = T>,

Run an arbitrary async operation against the client, blocking until it completes. This unlocks the entire async command surface from sync code:

let value: Option<String> = client.run(|c| async move { c.get("key").await })?;
Source

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

Update the connection password (blocking). See GlideClient::update_connection_password.

Source

pub fn custom_command<A: ToValkeyArgs + Sync>( &self, args: &[A], ) -> ValkeyResult<ValkeyValue>

Run an arbitrary command (blocking escape hatch).

Source

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

Execute a crate::Pipeline with GLIDE execution options (blocking). See crate::GlideClient::exec; for plain typed execution prefer PipelineExt::query.

Source

pub fn ping(&self) -> ValkeyResult<String>

Blocking PING.

Trait Implementations§

Source§

impl Clone for SyncGlideClient

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

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> 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> Commands for T
where T: SyncCommandDispatch,

Source§

fn glide_send_command(&self, cmd: Cmd) -> ValkeyResult<ValkeyValue>

Send an already-built command by value (no clone). Read more
Source§

fn glide_send_command_as<RV: FromValkeyValue>( &self, cmd: Cmd, ) -> ValkeyResult<RV>

Typed escape hatch (blocking counterpart of the async glide_send_command_as): send an already-built Cmd by value and decode the reply into RV. Read more
Source§

fn get<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, ) -> ValkeyResult<RV>

GET.
Source§

fn mget<'a, K: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, ) -> ValkeyResult<RV>

MGET.
Source§

fn set<'a, K: ToSingleValkeyArg, V: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, value: V, ) -> ValkeyResult<RV>

SET.
Source§

fn set_options<'a, K: ToSingleValkeyArg, V: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, value: V, options: SetOptions, ) -> ValkeyResult<RV>

SET.
Source§

fn mset<'a, K: ToValkeyArgs, V: ToValkeyArgs, RV: FromValkeyValue>( &self, items: &'a [(K, V)], ) -> ValkeyResult<RV>

MSET.
Source§

fn set_ex<'a, K: ToSingleValkeyArg, V: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, value: V, seconds: u64, ) -> ValkeyResult<RV>

SETEX.
Source§

fn pset_ex<'a, K: ToSingleValkeyArg, V: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, value: V, milliseconds: u64, ) -> ValkeyResult<RV>

PSETEX.
Source§

fn set_nx<'a, K: ToSingleValkeyArg, V: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, value: V, ) -> ValkeyResult<RV>

SETNX.
Source§

fn mset_nx<'a, K: ToValkeyArgs, V: ToValkeyArgs, RV: FromValkeyValue>( &self, items: &'a [(K, V)], ) -> ValkeyResult<RV>

MSETNX.
Source§

fn getset<'a, K: ToSingleValkeyArg, V: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, value: V, ) -> ValkeyResult<RV>

GETSET.
Source§

fn getrange<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, from: isize, to: isize, ) -> ValkeyResult<RV>

GETRANGE.
Source§

fn setrange<'a, K: ToSingleValkeyArg, V: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, offset: isize, value: V, ) -> ValkeyResult<RV>

SETRANGE.
Source§

fn get_ex<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, expire_at: Expiry, ) -> ValkeyResult<RV>

GETEX.
Source§

fn get_del<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, ) -> ValkeyResult<RV>

GETDEL.
Source§

fn append<'a, K: ToSingleValkeyArg, V: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, value: V, ) -> ValkeyResult<RV>

APPEND.
Source§

fn incr<'a, K: ToSingleValkeyArg, V: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, delta: V, ) -> ValkeyResult<RV>

INCRBY/INCRBYFLOAT
Source§

fn decr<'a, K: ToSingleValkeyArg, V: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, delta: V, ) -> ValkeyResult<RV>

DECRBY.
Source§

fn strlen<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, ) -> ValkeyResult<RV>

STRLEN.
Source§

fn keys<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, ) -> ValkeyResult<RV>

KEYS.
Source§

fn del<'a, K: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, ) -> ValkeyResult<RV>

DEL.
Source§

fn exists<'a, K: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, ) -> ValkeyResult<RV>

EXISTS.
Source§

fn key_type<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, ) -> ValkeyResult<RV>

TYPE.
Source§

fn expire<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, seconds: i64, ) -> ValkeyResult<RV>

EXPIRE.
Source§

fn expire_at<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, ts: i64, ) -> ValkeyResult<RV>

EXPIREAT.
Source§

fn expire_time<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, ) -> ValkeyResult<RV>

EXPIRETIME.
Source§

fn pexpire<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, ms: i64, ) -> ValkeyResult<RV>

PEXPIRE.
Source§

fn pexpire_at<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, ts: i64, ) -> ValkeyResult<RV>

PEXPIREAT.
Source§

fn pexpire_time<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, ) -> ValkeyResult<RV>

PEXPIRETIME.
Source§

fn persist<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, ) -> ValkeyResult<RV>

PERSIST.
Source§

fn ttl<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, ) -> ValkeyResult<RV>

TTL.
Source§

fn pttl<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, ) -> ValkeyResult<RV>

PTTL.
Source§

fn rename<'a, K: ToSingleValkeyArg, N: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, new_key: N, ) -> ValkeyResult<RV>

RENAME.
Source§

fn rename_nx<'a, K: ToSingleValkeyArg, N: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, new_key: N, ) -> ValkeyResult<RV>

RENAMENX.
UNLINK.
Source§

fn object_encoding<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, ) -> ValkeyResult<RV>

OBJECT ENCODING.
Source§

fn object_idletime<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, ) -> ValkeyResult<RV>

OBJECT IDLETIME.
Source§

fn object_freq<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, ) -> ValkeyResult<RV>

OBJECT FREQ.
Source§

fn object_refcount<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, ) -> ValkeyResult<RV>

OBJECT REFCOUNT.
Source§

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

COPY.
Source§

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

BLMOVE.
Source§

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

BLMPOP.
Source§

fn blpop<'a, K: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, timeout: f64, ) -> ValkeyResult<RV>

BLPOP.
Source§

fn brpop<'a, K: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, timeout: f64, ) -> ValkeyResult<RV>

BRPOP.
Source§

fn brpoplpush<'a, S: ToSingleValkeyArg, D: ToSingleValkeyArg, RV: FromValkeyValue>( &self, srckey: S, dstkey: D, timeout: f64, ) -> ValkeyResult<RV>

BRPOPLPUSH.
Source§

fn lindex<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, index: isize, ) -> ValkeyResult<RV>

LINDEX.
Source§

fn linsert_before<'a, K: ToSingleValkeyArg, P: ToSingleValkeyArg, V: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, pivot: P, value: V, ) -> ValkeyResult<RV>

LINSERT.
Source§

fn linsert_after<'a, K: ToSingleValkeyArg, P: ToSingleValkeyArg, V: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, pivot: P, value: V, ) -> ValkeyResult<RV>

LINSERT.
Source§

fn llen<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, ) -> ValkeyResult<RV>

LLEN.
Source§

fn lmove<'a, S: ToSingleValkeyArg, D: ToSingleValkeyArg, RV: FromValkeyValue>( &self, srckey: S, dstkey: D, src_dir: Direction, dst_dir: Direction, ) -> ValkeyResult<RV>

LMOVE.
Source§

fn lmpop<'a, K: ToValkeyArgs, RV: FromValkeyValue>( &self, numkeys: usize, key: K, dir: Direction, count: usize, ) -> ValkeyResult<RV>

LMPOP.
Source§

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

LPOP.
Source§

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

LPOS.
Source§

fn lpush<'a, K: ToSingleValkeyArg, V: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, value: V, ) -> ValkeyResult<RV>

LPUSH.
Source§

fn lpush_exists<'a, K: ToSingleValkeyArg, V: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, value: V, ) -> ValkeyResult<RV>

LPUSHX.
Source§

fn lrange<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, start: isize, stop: isize, ) -> ValkeyResult<RV>

LRANGE.
Source§

fn lrem<'a, K: ToSingleValkeyArg, V: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, count: isize, value: V, ) -> ValkeyResult<RV>

LREM.
Source§

fn ltrim<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, start: isize, stop: isize, ) -> ValkeyResult<RV>

LTRIM.
Source§

fn lset<'a, K: ToSingleValkeyArg, V: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, index: isize, value: V, ) -> ValkeyResult<RV>

LSET.
Source§

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

RPOP.
Source§

fn rpoplpush<'a, K: ToSingleValkeyArg, D: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, dstkey: D, ) -> ValkeyResult<RV>

RPOPLPUSH.
Source§

fn rpush<'a, K: ToSingleValkeyArg, V: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, value: V, ) -> ValkeyResult<RV>

RPUSH.
Source§

fn rpush_exists<'a, K: ToSingleValkeyArg, V: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, value: V, ) -> ValkeyResult<RV>

RPUSHX.
Source§

fn hget<'a, K: ToSingleValkeyArg, F: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, field: F, ) -> ValkeyResult<RV>

HGET.
Source§

fn hmget<'a, K: ToSingleValkeyArg, F: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, fields: F, ) -> ValkeyResult<RV>

HMGET.
Source§

fn hdel<'a, K: ToSingleValkeyArg, F: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, field: F, ) -> ValkeyResult<RV>

HDEL.
Source§

fn hset<'a, K: ToSingleValkeyArg, F: ToSingleValkeyArg, V: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, field: F, value: V, ) -> ValkeyResult<RV>

HSET.
Source§

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

HSET.
Source§

fn hset_nx<'a, K: ToSingleValkeyArg, F: ToSingleValkeyArg, V: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, field: F, value: V, ) -> ValkeyResult<RV>

HSETNX.
Source§

fn hincr<'a, K: ToSingleValkeyArg, F: ToSingleValkeyArg, D: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, field: F, delta: D, ) -> ValkeyResult<RV>

HINCRBY/HINCRBYFLOAT.
Source§

fn hexists<'a, K: ToSingleValkeyArg, F: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, field: F, ) -> ValkeyResult<RV>

HEXISTS.
Source§

fn hkeys<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, ) -> ValkeyResult<RV>

HKEYS.
Source§

fn hvals<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, ) -> ValkeyResult<RV>

HVALS.
Source§

fn hgetall<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, ) -> ValkeyResult<RV>

HGETALL.
Source§

fn hlen<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, ) -> ValkeyResult<RV>

HLEN.
Source§

fn hget_ex<'a, K: ToSingleValkeyArg, F: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, fields: F, expire_at: Expiry, ) -> ValkeyResult<RV>

HGETEX.
Source§

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

HSETEX.
Source§

fn httl<'a, K: ToSingleValkeyArg, F: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, fields: F, ) -> ValkeyResult<RV>

HTTL.
Source§

fn hpttl<'a, K: ToSingleValkeyArg, F: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, fields: F, ) -> ValkeyResult<RV>

HPTTL.
Source§

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

HEXPIRE.
Source§

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

HEXPIREAT.
Source§

fn hexpire_time<'a, K: ToSingleValkeyArg, F: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, fields: F, ) -> ValkeyResult<RV>

HEXPIRETIME.
Source§

fn hpersist<'a, K: ToSingleValkeyArg, F: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, fields: F, ) -> ValkeyResult<RV>

HPERSIST.
Source§

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

HPEXPIRE.
Source§

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

HPEXPIREAT.
Source§

fn hpexpire_time<'a, K: ToSingleValkeyArg, F: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, fields: F, ) -> ValkeyResult<RV>

HPEXPIRETIME.
Source§

fn sadd<'a, K: ToSingleValkeyArg, M: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, member: M, ) -> ValkeyResult<RV>

SADD.
Source§

fn scard<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, ) -> ValkeyResult<RV>

SCARD.
Source§

fn sdiff<'a, K: ToValkeyArgs, RV: FromValkeyValue>( &self, keys: K, ) -> ValkeyResult<RV>

SDIFF.
Source§

fn sdiffstore<'a, D: ToSingleValkeyArg, K: ToValkeyArgs, RV: FromValkeyValue>( &self, dstkey: D, keys: K, ) -> ValkeyResult<RV>

SDIFFSTORE.
Source§

fn sinter<'a, K: ToValkeyArgs, RV: FromValkeyValue>( &self, keys: K, ) -> ValkeyResult<RV>

SINTER.
Source§

fn sinterstore<'a, D: ToSingleValkeyArg, K: ToValkeyArgs, RV: FromValkeyValue>( &self, dstkey: D, keys: K, ) -> ValkeyResult<RV>

SINTERSTORE.
Source§

fn sismember<'a, K: ToSingleValkeyArg, M: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, member: M, ) -> ValkeyResult<RV>

SISMEMBER.
Source§

fn smismember<'a, K: ToSingleValkeyArg, M: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, members: M, ) -> ValkeyResult<RV>

SMISMEMBER.
Source§

fn smembers<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, ) -> ValkeyResult<RV>

SMEMBERS.
Source§

fn smove<'a, S: ToSingleValkeyArg, D: ToSingleValkeyArg, M: ToSingleValkeyArg, RV: FromValkeyValue>( &self, srckey: S, dstkey: D, member: M, ) -> ValkeyResult<RV>

SMOVE.
Source§

fn spop<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, ) -> ValkeyResult<RV>

SPOP.
Source§

fn srandmember<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, ) -> ValkeyResult<RV>

SRANDMEMBER.
Source§

fn srandmember_multiple<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, count: isize, ) -> ValkeyResult<RV>

SRANDMEMBER.
Source§

fn srem<'a, K: ToSingleValkeyArg, M: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, member: M, ) -> ValkeyResult<RV>

SREM.
Source§

fn sunion<'a, K: ToValkeyArgs, RV: FromValkeyValue>( &self, keys: K, ) -> ValkeyResult<RV>

SUNION.
Source§

fn sunionstore<'a, D: ToSingleValkeyArg, K: ToValkeyArgs, RV: FromValkeyValue>( &self, dstkey: D, keys: K, ) -> ValkeyResult<RV>

SUNIONSTORE.
Source§

fn zadd<'a, K: ToSingleValkeyArg, S: ToSingleValkeyArg, M: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, member: M, score: S, ) -> ValkeyResult<RV>

ZADD.
Source§

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

ZADD.
Source§

fn zcard<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, ) -> ValkeyResult<RV>

ZCARD.
Source§

fn zcount<'a, K: ToSingleValkeyArg, M: ToSingleValkeyArg, MM: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, min: M, max: MM, ) -> ValkeyResult<RV>

ZCOUNT.
Source§

fn zincr<'a, K: ToSingleValkeyArg, M: ToSingleValkeyArg, D: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, member: M, delta: D, ) -> ValkeyResult<RV>

ZINCRBY.
Source§

fn zinterstore<'a, D: ToSingleValkeyArg, K: ToValkeyArgs, RV: FromValkeyValue>( &self, dstkey: D, keys: K, ) -> ValkeyResult<RV>

ZINTERSTORE.
Source§

fn zinterstore_min<'a, D: ToSingleValkeyArg, K: ToValkeyArgs, RV: FromValkeyValue>( &self, dstkey: D, keys: K, ) -> ValkeyResult<RV>

ZINTERSTORE.
Source§

fn zinterstore_max<'a, D: ToSingleValkeyArg, K: ToValkeyArgs, RV: FromValkeyValue>( &self, dstkey: D, keys: K, ) -> ValkeyResult<RV>

ZINTERSTORE.
Source§

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

ZINTERSTORE.
Source§

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

ZINTERSTORE.
Source§

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

ZINTERSTORE.
Source§

fn zlexcount<'a, K: ToSingleValkeyArg, M: ToSingleValkeyArg, MM: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, min: M, max: MM, ) -> ValkeyResult<RV>

ZLEXCOUNT.
Source§

fn bzpopmax<'a, K: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, timeout: f64, ) -> ValkeyResult<RV>

BZPOPMAX.
Source§

fn zpopmax<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, count: isize, ) -> ValkeyResult<RV>

ZPOPMAX.
Source§

fn bzpopmin<'a, K: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, timeout: f64, ) -> ValkeyResult<RV>

BZPOPMIN.
Source§

fn zpopmin<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, count: isize, ) -> ValkeyResult<RV>

ZPOPMIN.
Source§

fn bzmpop_max<'a, K: ToValkeyArgs, RV: FromValkeyValue>( &self, timeout: f64, keys: K, count: isize, ) -> ValkeyResult<RV>

BZMPOP.
Source§

fn zmpop_max<'a, K: ToValkeyArgs, RV: FromValkeyValue>( &self, keys: K, count: isize, ) -> ValkeyResult<RV>

ZMPOP.
Source§

fn bzmpop_min<'a, K: ToValkeyArgs, RV: FromValkeyValue>( &self, timeout: f64, keys: K, count: isize, ) -> ValkeyResult<RV>

BZMPOP.
Source§

fn zmpop_min<'a, K: ToValkeyArgs, RV: FromValkeyValue>( &self, keys: K, count: isize, ) -> ValkeyResult<RV>

ZMPOP.
Source§

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

ZRANDMEMBER.
Source§

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

ZRANDMEMBER WITHSCORES.
Source§

fn zrange<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, start: isize, stop: isize, ) -> ValkeyResult<RV>

ZRANGE.
Source§

fn zrange_withscores<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, start: isize, stop: isize, ) -> ValkeyResult<RV>

ZRANGE WITHSCORES.
Source§

fn zrangebylex<'a, K: ToSingleValkeyArg, M: ToSingleValkeyArg, MM: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, min: M, max: MM, ) -> ValkeyResult<RV>

ZRANGEBYLEX.
Source§

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

ZRANGEBYLEX LIMIT.
Source§

fn zrevrangebylex<'a, K: ToSingleValkeyArg, MM: ToSingleValkeyArg, M: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, max: MM, min: M, ) -> ValkeyResult<RV>

ZREVRANGEBYLEX.
Source§

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

ZREVRANGEBYLEX LIMIT.
Source§

fn zrangebyscore<'a, K: ToSingleValkeyArg, M: ToSingleValkeyArg, MM: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, min: M, max: MM, ) -> ValkeyResult<RV>

ZRANGEBYSCORE.
Source§

fn zrangebyscore_withscores<'a, K: ToSingleValkeyArg, M: ToSingleValkeyArg, MM: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, min: M, max: MM, ) -> ValkeyResult<RV>

ZRANGEBYSCORE WITHSCORES.
Source§

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

ZRANGEBYSCORE LIMIT.
Source§

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

ZRANGEBYSCORE WITHSCORES LIMIT.
Source§

fn zrank<'a, K: ToSingleValkeyArg, M: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, member: M, ) -> ValkeyResult<RV>

ZRANK.
Source§

fn zrem<'a, K: ToSingleValkeyArg, M: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, members: M, ) -> ValkeyResult<RV>

ZREM.
Source§

fn zrembylex<'a, K: ToSingleValkeyArg, M: ToSingleValkeyArg, MM: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, min: M, max: MM, ) -> ValkeyResult<RV>

ZREMRANGEBYLEX.
Source§

fn zremrangebyrank<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, start: isize, stop: isize, ) -> ValkeyResult<RV>

ZREMRANGEBYRANK.
Source§

fn zrembyscore<'a, K: ToSingleValkeyArg, M: ToSingleValkeyArg, MM: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, min: M, max: MM, ) -> ValkeyResult<RV>

ZREMRANGEBYSCORE.
Source§

fn zrevrange<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, start: isize, stop: isize, ) -> ValkeyResult<RV>

ZREVRANGE.
Source§

fn zrevrange_withscores<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, start: isize, stop: isize, ) -> ValkeyResult<RV>

ZREVRANGE WITHSCORES.
Source§

fn zrevrangebyscore<'a, K: ToSingleValkeyArg, MM: ToSingleValkeyArg, M: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, max: MM, min: M, ) -> ValkeyResult<RV>

ZREVRANGEBYSCORE.
Source§

fn zrevrangebyscore_withscores<'a, K: ToSingleValkeyArg, MM: ToSingleValkeyArg, M: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, max: MM, min: M, ) -> ValkeyResult<RV>

ZREVRANGEBYSCORE WITHSCORES.
Source§

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

ZREVRANGEBYSCORE LIMIT.
Source§

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

ZREVRANGEBYSCORE WITHSCORES LIMIT.
Source§

fn zrevrank<'a, K: ToSingleValkeyArg, M: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, member: M, ) -> ValkeyResult<RV>

ZREVRANK.
Source§

fn zscore<'a, K: ToSingleValkeyArg, M: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, member: M, ) -> ValkeyResult<RV>

ZSCORE.
Source§

fn zscore_multiple<'a, K: ToSingleValkeyArg, M: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, members: &'a [M], ) -> ValkeyResult<RV>

ZMSCORE.
Source§

fn zunionstore<'a, D: ToSingleValkeyArg, K: ToValkeyArgs, RV: FromValkeyValue>( &self, dstkey: D, keys: K, ) -> ValkeyResult<RV>

ZUNIONSTORE.
Source§

fn zunionstore_min<'a, D: ToSingleValkeyArg, K: ToValkeyArgs, RV: FromValkeyValue>( &self, dstkey: D, keys: K, ) -> ValkeyResult<RV>

ZUNIONSTORE AGGREGATE MIN.
Source§

fn zunionstore_max<'a, D: ToSingleValkeyArg, K: ToValkeyArgs, RV: FromValkeyValue>( &self, dstkey: D, keys: K, ) -> ValkeyResult<RV>

ZUNIONSTORE AGGREGATE MAX.
Source§

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

ZUNIONSTORE WEIGHTS.
Source§

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

ZUNIONSTORE AGGREGATE MIN WEIGHTS.
Source§

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

ZUNIONSTORE AGGREGATE MAX WEIGHTS.
Source§

fn pfadd<'a, K: ToSingleValkeyArg, E: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, element: E, ) -> ValkeyResult<RV>

PFADD.
Source§

fn pfcount<'a, K: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, ) -> ValkeyResult<RV>

PFCOUNT.
Source§

fn pfmerge<'a, D: ToSingleValkeyArg, S: ToValkeyArgs, RV: FromValkeyValue>( &self, dstkey: D, srckeys: S, ) -> ValkeyResult<RV>

PFMERGE.
Source§

fn setbit<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, offset: usize, value: bool, ) -> ValkeyResult<RV>

SETBIT.
Source§

fn getbit<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, offset: usize, ) -> ValkeyResult<RV>

GETBIT.
Source§

fn bitcount<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, ) -> ValkeyResult<RV>

BITCOUNT.
Source§

fn bitcount_range<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, start: usize, end: usize, ) -> ValkeyResult<RV>

BITCOUNT.
Source§

fn bit_and<'a, D: ToSingleValkeyArg, S: ToValkeyArgs, RV: FromValkeyValue>( &self, dstkey: D, srckeys: S, ) -> ValkeyResult<RV>

BITOP AND.
Source§

fn bit_or<'a, D: ToSingleValkeyArg, S: ToValkeyArgs, RV: FromValkeyValue>( &self, dstkey: D, srckeys: S, ) -> ValkeyResult<RV>

BITOP OR.
Source§

fn bit_xor<'a, D: ToSingleValkeyArg, S: ToValkeyArgs, RV: FromValkeyValue>( &self, dstkey: D, srckeys: S, ) -> ValkeyResult<RV>

BITOP XOR.
Source§

fn bit_not<'a, D: ToSingleValkeyArg, S: ToSingleValkeyArg, RV: FromValkeyValue>( &self, dstkey: D, srckey: S, ) -> ValkeyResult<RV>

BITOP NOT.
Source§

fn geo_add<'a, K: ToSingleValkeyArg, M: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, members: M, ) -> ValkeyResult<RV>

GEOADD.
Source§

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

GEODIST.
Source§

fn geo_hash<'a, K: ToSingleValkeyArg, M: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, members: M, ) -> ValkeyResult<RV>

GEOHASH.
Source§

fn geo_pos<'a, K: ToSingleValkeyArg, M: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, members: M, ) -> ValkeyResult<RV>

GEOPOS.
Source§

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

XACK.
Source§

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

XADD.
Source§

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

XADD with options.
Source§

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

XAUTOCLAIM.
Source§

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

XCLAIM.
Source§

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

XCLAIM.
Source§

fn xdel<'a, K: ToSingleValkeyArg, ID: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, ids: &'a [ID], ) -> ValkeyResult<RV>

XDEL.
Source§

fn xgroup_create<'a, K: ToValkeyArgs, G: ToValkeyArgs, ID: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, group: G, id: ID, ) -> ValkeyResult<RV>

XGROUP CREATE.
Source§

fn xgroup_create_mkstream<'a, K: ToValkeyArgs, G: ToValkeyArgs, ID: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, group: G, id: ID, ) -> ValkeyResult<RV>

XGROUP CREATE ... MKSTREAM.
Source§

fn xgroup_createconsumer<'a, K: ToValkeyArgs, G: ToValkeyArgs, C: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, group: G, consumer: C, ) -> ValkeyResult<RV>

XGROUP CREATECONSUMER.
Source§

fn xgroup_delconsumer<'a, K: ToValkeyArgs, G: ToValkeyArgs, C: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, group: G, consumer: C, ) -> ValkeyResult<RV>

XGROUP DELCONSUMER.
Source§

fn xgroup_destroy<'a, K: ToValkeyArgs, G: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, group: G, ) -> ValkeyResult<RV>

XGROUP DESTROY.
Source§

fn xgroup_setid<'a, K: ToValkeyArgs, G: ToValkeyArgs, ID: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, group: G, id: ID, ) -> ValkeyResult<RV>

XGROUP SETID.
Source§

fn xinfo_consumers<'a, K: ToValkeyArgs, G: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, group: G, ) -> ValkeyResult<RV>

XINFO CONSUMERS.
Source§

fn xinfo_groups<'a, K: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, ) -> ValkeyResult<RV>

XINFO GROUPS.
Source§

fn xinfo_stream<'a, K: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, ) -> ValkeyResult<RV>

XINFO STREAM.
Source§

fn xlen<'a, K: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, ) -> ValkeyResult<RV>

XLEN.
Source§

fn xpending<'a, K: ToValkeyArgs, G: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, group: G, ) -> ValkeyResult<RV>

XPENDING.
Source§

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

XPENDING (extended form).
Source§

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

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

fn xrange<'a, K: ToValkeyArgs, S: ToValkeyArgs, E: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, start: S, end: E, ) -> ValkeyResult<RV>

XRANGE.
Source§

fn xread<'a, K: ToValkeyArgs, ID: ToValkeyArgs, RV: FromValkeyValue>( &self, keys: &'a [K], ids: &'a [ID], ) -> ValkeyResult<RV>

XREAD.
Source§

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

XREAD.
Source§

fn xrevrange<'a, K: ToValkeyArgs, E: ToValkeyArgs, S: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, end: E, start: S, ) -> ValkeyResult<RV>

XREVRANGE.
Source§

fn xtrim<'a, K: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, maxlen: StreamMaxlen, ) -> ValkeyResult<RV>

XTRIM ... MAXLEN.
Source§

fn xtrim_options<'a, K: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, options: &'a StreamTrimOptions, ) -> ValkeyResult<RV>

XTRIM.
Source§

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

PING.
Source§

fn ping_message<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, message: K, ) -> ValkeyResult<RV>

PING with a message.
Source§

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

CLIENT GETNAME.
Source§

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

CLIENT ID.
Source§

fn client_setname<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>( &self, connection_name: K, ) -> ValkeyResult<RV>

CLIENT SETNAME.
Source§

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

FLUSHALL.
Source§

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

FLUSHALL.
Source§

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

FLUSHDB.
Source§

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

FLUSHDB.
Source§

fn publish<'a, K: ToSingleValkeyArg, E: ToSingleValkeyArg, RV: FromValkeyValue>( &self, channel: K, message: E, ) -> ValkeyResult<RV>

PUBLISH.
Source§

fn spublish<'a, K: ToSingleValkeyArg, E: ToSingleValkeyArg, RV: FromValkeyValue>( &self, channel: K, message: E, ) -> ValkeyResult<RV>

SPUBLISH.
Source§

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

Cursor-driven SCAN over the whole keyspace.
Source§

fn scan_match<'s, P: ToSingleValkeyArg, RV: FromValkeyValue + 's>( &'s self, pattern: P, ) -> ValkeyResult<SyncScanIter<'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, ) -> ValkeyResult<SyncScanIter<'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, ) -> ValkeyResult<SyncScanIter<'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, ) -> ValkeyResult<SyncScanIter<'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, ) -> ValkeyResult<SyncScanIter<'s, Self, RV>>

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

fn zscan<'s, K: ToSingleValkeyArg, RV: FromValkeyValue + 's>( &'s self, key: K, ) -> ValkeyResult<SyncScanIter<'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, ) -> ValkeyResult<SyncScanIter<'s, Self, RV>>

Cursor-driven ZSCAN, filtered by a MATCH pattern.
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> 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<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> 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> 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<T> TypedCommands for T
where T: SyncCommandDispatch,

Source§

fn get<'a, K: ToSingleValkeyArg>(&self, key: K) -> ValkeyResult<Option<String>>

GET.
Source§

fn mget<'a, K: ToValkeyArgs>(&self, key: K) -> ValkeyResult<Vec<Option<String>>>

MGET.
Source§

fn set<'a, K: ToSingleValkeyArg, V: ToSingleValkeyArg>( &self, key: K, value: V, ) -> ValkeyResult<()>

SET.
Source§

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

SET.
Source§

fn mset<'a, K: ToValkeyArgs, V: ToValkeyArgs>( &self, items: &'a [(K, V)], ) -> ValkeyResult<()>

MSET.
Source§

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

SETEX.
Source§

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

PSETEX.
Source§

fn set_nx<'a, K: ToSingleValkeyArg, V: ToSingleValkeyArg>( &self, key: K, value: V, ) -> ValkeyResult<bool>

SETNX.
Source§

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

MSETNX.
Source§

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

GETSET.
Source§

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

GETRANGE.
Source§

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

SETRANGE.
Source§

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

GETEX.
Source§

fn get_del<'a, K: ToSingleValkeyArg>( &self, key: K, ) -> ValkeyResult<Option<String>>

GETDEL.
Source§

fn append<'a, K: ToSingleValkeyArg, V: ToSingleValkeyArg>( &self, key: K, value: V, ) -> ValkeyResult<usize>

APPEND.
Source§

fn incr<'a, K: ToSingleValkeyArg, V: ToSingleValkeyArg>( &self, key: K, delta: V, ) -> ValkeyResult<isize>

INCRBY/INCRBYFLOAT
Source§

fn decr<'a, K: ToSingleValkeyArg, V: ToSingleValkeyArg>( &self, key: K, delta: V, ) -> ValkeyResult<isize>

DECRBY.
Source§

fn strlen<'a, K: ToSingleValkeyArg>(&self, key: K) -> ValkeyResult<usize>

STRLEN.
Source§

fn keys<'a, K: ToSingleValkeyArg>(&self, key: K) -> ValkeyResult<Vec<String>>

KEYS.
Source§

fn del<'a, K: ToValkeyArgs>(&self, key: K) -> ValkeyResult<usize>

DEL.
Source§

fn exists<'a, K: ToValkeyArgs>(&self, key: K) -> ValkeyResult<bool>

EXISTS.
Source§

fn key_type<'a, K: ToSingleValkeyArg>(&self, key: K) -> ValkeyResult<ValueType>

TYPE.
Source§

fn expire<'a, K: ToSingleValkeyArg>( &self, key: K, seconds: i64, ) -> ValkeyResult<bool>

EXPIRE.
Source§

fn expire_at<'a, K: ToSingleValkeyArg>( &self, key: K, ts: i64, ) -> ValkeyResult<bool>

EXPIREAT.
Source§

fn expire_time<'a, K: ToSingleValkeyArg>( &self, key: K, ) -> ValkeyResult<IntegerReplyOrNoOp>

EXPIRETIME.
Source§

fn pexpire<'a, K: ToSingleValkeyArg>( &self, key: K, ms: i64, ) -> ValkeyResult<bool>

PEXPIRE.
Source§

fn pexpire_at<'a, K: ToSingleValkeyArg>( &self, key: K, ts: i64, ) -> ValkeyResult<bool>

PEXPIREAT.
Source§

fn pexpire_time<'a, K: ToSingleValkeyArg>( &self, key: K, ) -> ValkeyResult<IntegerReplyOrNoOp>

PEXPIRETIME.
Source§

fn persist<'a, K: ToSingleValkeyArg>(&self, key: K) -> ValkeyResult<bool>

PERSIST.
Source§

fn ttl<'a, K: ToSingleValkeyArg>( &self, key: K, ) -> ValkeyResult<IntegerReplyOrNoOp>

TTL.
Source§

fn pttl<'a, K: ToSingleValkeyArg>( &self, key: K, ) -> ValkeyResult<IntegerReplyOrNoOp>

PTTL.
Source§

fn rename<'a, K: ToSingleValkeyArg, N: ToSingleValkeyArg>( &self, key: K, new_key: N, ) -> ValkeyResult<()>

RENAME.
Source§

fn rename_nx<'a, K: ToSingleValkeyArg, N: ToSingleValkeyArg>( &self, key: K, new_key: N, ) -> ValkeyResult<bool>

RENAMENX.
UNLINK.
Source§

fn object_encoding<'a, K: ToSingleValkeyArg>( &self, key: K, ) -> ValkeyResult<Option<String>>

OBJECT ENCODING.
Source§

fn object_idletime<'a, K: ToSingleValkeyArg>( &self, key: K, ) -> ValkeyResult<Option<usize>>

OBJECT IDLETIME.
Source§

fn object_freq<'a, K: ToSingleValkeyArg>( &self, key: K, ) -> ValkeyResult<Option<usize>>

OBJECT FREQ.
Source§

fn object_refcount<'a, K: ToSingleValkeyArg>( &self, key: K, ) -> ValkeyResult<Option<usize>>

OBJECT REFCOUNT.
Source§

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

COPY.
Source§

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

BLMOVE.
Source§

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

BLMPOP.
Source§

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

BLPOP.
Source§

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

BRPOP.
Source§

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

BRPOPLPUSH.
Source§

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

LINDEX.
Source§

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

LINSERT.
Source§

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

LINSERT.
Source§

fn llen<'a, K: ToSingleValkeyArg>(&self, key: K) -> ValkeyResult<usize>

LLEN.
Source§

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

LMOVE.
Source§

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

LMPOP.
Source§

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

LPOP.
Source§

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

LPOS.
Source§

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

LPUSH.
Source§

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

LPUSHX.
Source§

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

LRANGE.
Source§

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

LREM.
Source§

fn ltrim<'a, K: ToSingleValkeyArg>( &self, key: K, start: isize, stop: isize, ) -> ValkeyResult<()>

LTRIM.
Source§

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

LSET.
Source§

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

RPOP.
Source§

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

RPOPLPUSH.
Source§

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

RPUSH.
Source§

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

RPUSHX.
Source§

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

HGET.
Source§

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

HMGET.
Source§

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

HDEL.
Source§

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

HSET.
Source§

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

HSET.
Source§

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

HSETNX.
Source§

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

HINCRBY/HINCRBYFLOAT.
Source§

fn hexists<'a, K: ToSingleValkeyArg, F: ToSingleValkeyArg>( &self, key: K, field: F, ) -> ValkeyResult<bool>

HEXISTS.
Source§

fn hkeys<'a, K: ToSingleValkeyArg>(&self, key: K) -> ValkeyResult<Vec<String>>

HKEYS.
Source§

fn hvals<'a, K: ToSingleValkeyArg>(&self, key: K) -> ValkeyResult<Vec<String>>

HVALS.
Source§

fn hgetall<'a, K: ToSingleValkeyArg>( &self, key: K, ) -> ValkeyResult<HashMap<String, String>>

HGETALL.
Source§

fn hlen<'a, K: ToSingleValkeyArg>(&self, key: K) -> ValkeyResult<usize>

HLEN.
Source§

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

HGETEX.
Source§

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

HSETEX.
Source§

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

HTTL.
Source§

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

HPTTL.
Source§

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

HEXPIRE.
Source§

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

HEXPIREAT.
Source§

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

HEXPIRETIME.
Source§

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

HPERSIST.
Source§

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

HPEXPIRE.
Source§

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

HPEXPIREAT.
Source§

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

HPEXPIRETIME.
Source§

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

SADD.
Source§

fn scard<'a, K: ToSingleValkeyArg>(&self, key: K) -> ValkeyResult<usize>

SCARD.
Source§

fn sdiff<'a, K: ToValkeyArgs>(&self, keys: K) -> ValkeyResult<HashSet<String>>

SDIFF.
Source§

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

SDIFFSTORE.
Source§

fn sinter<'a, K: ToValkeyArgs>(&self, keys: K) -> ValkeyResult<HashSet<String>>

SINTER.
Source§

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

SINTERSTORE.
Source§

fn sismember<'a, K: ToSingleValkeyArg, M: ToSingleValkeyArg>( &self, key: K, member: M, ) -> ValkeyResult<bool>

SISMEMBER.
Source§

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

SMISMEMBER.
Source§

fn smembers<'a, K: ToSingleValkeyArg>( &self, key: K, ) -> ValkeyResult<HashSet<String>>

SMEMBERS.
Source§

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

SMOVE.
Source§

fn spop<'a, RV: FromValkeyValue, K: ToSingleValkeyArg>( &self, key: K, ) -> ValkeyResult<RV>

SPOP.
Source§

fn srandmember<'a, K: ToSingleValkeyArg>( &self, key: K, ) -> ValkeyResult<Option<String>>

SRANDMEMBER.
Source§

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

SRANDMEMBER.
Source§

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

SREM.
Source§

fn sunion<'a, K: ToValkeyArgs>(&self, keys: K) -> ValkeyResult<HashSet<String>>

SUNION.
Source§

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

SUNIONSTORE.
Source§

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

ZADD.
Source§

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

ZADD.
Source§

fn zcard<'a, K: ToSingleValkeyArg>(&self, key: K) -> ValkeyResult<usize>

ZCARD.
Source§

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

ZCOUNT.
Source§

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

ZINCRBY.
Source§

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

ZINTERSTORE.
Source§

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

ZINTERSTORE.
Source§

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

ZINTERSTORE.
Source§

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

ZINTERSTORE.
Source§

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

ZINTERSTORE.
Source§

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

ZINTERSTORE.
Source§

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

ZLEXCOUNT.
Source§

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

BZPOPMAX.
Source§

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

ZPOPMAX.
Source§

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

BZPOPMIN.
Source§

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

ZPOPMIN.
Source§

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

BZMPOP.
Source§

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

ZMPOP.
Source§

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

BZMPOP.
Source§

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

ZMPOP.
Source§

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

ZRANDMEMBER.
Source§

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

ZRANDMEMBER WITHSCORES.
Source§

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

ZRANGE.
Source§

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

ZRANGE WITHSCORES.
Source§

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

ZRANGEBYLEX.
Source§

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

ZRANGEBYLEX LIMIT.
Source§

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

ZREVRANGEBYLEX.
Source§

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

ZREVRANGEBYLEX LIMIT.
Source§

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

ZRANGEBYSCORE.
Source§

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

ZRANGEBYSCORE WITHSCORES.
Source§

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

ZRANGEBYSCORE LIMIT.
Source§

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

ZRANGEBYSCORE WITHSCORES LIMIT.
Source§

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

ZRANK.
Source§

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

ZREM.
Source§

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

ZREMRANGEBYLEX.
Source§

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

ZREMRANGEBYRANK.
Source§

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

ZREMRANGEBYSCORE.
Source§

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

ZREVRANGE.
Source§

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

ZREVRANGE WITHSCORES.
Source§

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

ZREVRANGEBYSCORE.
Source§

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

ZREVRANGEBYSCORE WITHSCORES.
Source§

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

ZREVRANGEBYSCORE LIMIT.
Source§

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

ZREVRANGEBYSCORE WITHSCORES LIMIT.
Source§

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

ZREVRANK.
Source§

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

ZSCORE.
Source§

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

ZMSCORE.
Source§

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

ZUNIONSTORE.
Source§

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

ZUNIONSTORE AGGREGATE MIN.
Source§

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

ZUNIONSTORE AGGREGATE MAX.
Source§

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

ZUNIONSTORE WEIGHTS.
Source§

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

ZUNIONSTORE AGGREGATE MIN WEIGHTS.
Source§

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

ZUNIONSTORE AGGREGATE MAX WEIGHTS.
Source§

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

PFADD.
Source§

fn pfcount<'a, K: ToValkeyArgs>(&self, key: K) -> ValkeyResult<usize>

PFCOUNT.
Source§

fn pfmerge<'a, D: ToSingleValkeyArg, S: ToValkeyArgs>( &self, dstkey: D, srckeys: S, ) -> ValkeyResult<()>

PFMERGE.
Source§

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

SETBIT.
Source§

fn getbit<'a, K: ToSingleValkeyArg>( &self, key: K, offset: usize, ) -> ValkeyResult<bool>

GETBIT.
Source§

fn bitcount<'a, K: ToSingleValkeyArg>(&self, key: K) -> ValkeyResult<usize>

BITCOUNT.
Source§

fn bitcount_range<'a, K: ToSingleValkeyArg>( &self, key: K, start: usize, end: usize, ) -> ValkeyResult<usize>

BITCOUNT.
Source§

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

BITOP AND.
Source§

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

BITOP OR.
Source§

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

BITOP XOR.
Source§

fn bit_not<'a, D: ToSingleValkeyArg, S: ToSingleValkeyArg>( &self, dstkey: D, srckey: S, ) -> ValkeyResult<usize>

BITOP NOT.
Source§

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

GEOADD.
Source§

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

GEODIST.
Source§

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

GEOHASH.
Source§

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

GEOPOS.
Source§

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

XACK.
Source§

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

XADD.
Source§

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

XADD with options.
Source§

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

XAUTOCLAIM.
Source§

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

XCLAIM.
Source§

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

XCLAIM.
Source§

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

XDEL.
Source§

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

XGROUP CREATE.
Source§

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

XGROUP CREATE ... MKSTREAM.
Source§

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

XGROUP CREATECONSUMER.
Source§

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

XGROUP DELCONSUMER.
Source§

fn xgroup_destroy<'a, K: ToValkeyArgs, G: ToValkeyArgs>( &self, key: K, group: G, ) -> ValkeyResult<bool>

XGROUP DESTROY.
Source§

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

XGROUP SETID.
Source§

fn xinfo_consumers<'a, K: ToValkeyArgs, G: ToValkeyArgs>( &self, key: K, group: G, ) -> ValkeyResult<StreamInfoConsumersReply>

XINFO CONSUMERS.
Source§

fn xinfo_groups<'a, K: ToValkeyArgs>( &self, key: K, ) -> ValkeyResult<StreamInfoGroupsReply>

XINFO GROUPS.
Source§

fn xinfo_stream<'a, K: ToValkeyArgs>( &self, key: K, ) -> ValkeyResult<StreamInfoStreamReply>

XINFO STREAM.
Source§

fn xlen<'a, K: ToValkeyArgs>(&self, key: K) -> ValkeyResult<usize>

XLEN.
Source§

fn xpending<'a, K: ToValkeyArgs, G: ToValkeyArgs>( &self, key: K, group: G, ) -> ValkeyResult<StreamPendingReply>

XPENDING.
Source§

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

XPENDING (extended form).
Source§

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

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

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

XRANGE.
Source§

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

XREAD.
Source§

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

XREAD.
Source§

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

XREVRANGE.
Source§

fn xtrim<'a, K: ToValkeyArgs>( &self, key: K, maxlen: StreamMaxlen, ) -> ValkeyResult<usize>

XTRIM ... MAXLEN.
Source§

fn xtrim_options<'a, K: ToValkeyArgs>( &self, key: K, options: &'a StreamTrimOptions, ) -> ValkeyResult<usize>

XTRIM.
Source§

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

PING.
Source§

fn ping_message<'a, K: ToSingleValkeyArg>( &self, message: K, ) -> ValkeyResult<String>

PING with a message.
Source§

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

CLIENT GETNAME.
Source§

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

CLIENT ID.
Source§

fn client_setname<'a, K: ToSingleValkeyArg>( &self, connection_name: K, ) -> ValkeyResult<()>

CLIENT SETNAME.
Source§

fn flushall<'a>(&self) -> ValkeyResult<()>

FLUSHALL.
Source§

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

FLUSHALL.
Source§

fn flushdb<'a>(&self) -> ValkeyResult<()>

FLUSHDB.
Source§

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

FLUSHDB.
Source§

fn publish<'a, K: ToSingleValkeyArg, E: ToSingleValkeyArg>( &self, channel: K, message: E, ) -> ValkeyResult<usize>

PUBLISH.
Source§

fn spublish<'a, K: ToSingleValkeyArg, E: ToSingleValkeyArg>( &self, channel: K, message: E, ) -> ValkeyResult<usize>

SPUBLISH.
Source§

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

Cursor-driven SCAN over the whole keyspace.
Source§

fn scan_match<'s, P: ToSingleValkeyArg, RV: FromValkeyValue + 's>( &'s self, pattern: P, ) -> ValkeyResult<SyncScanIter<'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, ) -> ValkeyResult<SyncScanIter<'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, ) -> ValkeyResult<SyncScanIter<'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, ) -> ValkeyResult<SyncScanIter<'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, ) -> ValkeyResult<SyncScanIter<'s, Self, RV>>

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

fn zscan<'s, K: ToSingleValkeyArg, RV: FromValkeyValue + 's>( &'s self, key: K, ) -> ValkeyResult<SyncScanIter<'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, ) -> ValkeyResult<SyncScanIter<'s, Self, RV>>

Cursor-driven ZSCAN, filtered by a MATCH pattern.
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