pub struct SyncGlideClusterClient { /* private fields */ }Expand description
A blocking client for a cluster deployment.
Implementations§
Source§impl SyncGlideClusterClient
impl SyncGlideClusterClient
Sourcepub fn connect(config: GlideClusterClientConfiguration) -> ValkeyResult<Self>
pub fn connect(config: GlideClusterClientConfiguration) -> ValkeyResult<Self>
Connect using the given cluster configuration (blocking).
Sourcepub fn async_client(&self) -> &GlideClusterClient
pub fn async_client(&self) -> &GlideClusterClient
The underlying async client.
Sourcepub fn run<F, Fut, T>(&self, f: F) -> T
pub fn run<F, Fut, T>(&self, f: F) -> T
Run an arbitrary async operation against the client (blocking).
Sourcepub fn custom_command<A: ToValkeyArgs + Sync>(
&self,
args: &[A],
) -> ValkeyResult<ValkeyValue>
pub fn custom_command<A: ToValkeyArgs + Sync>( &self, args: &[A], ) -> ValkeyResult<ValkeyValue>
Run an arbitrary command (blocking escape hatch).
Sourcepub fn custom_command_with_route<A: ToValkeyArgs + Sync>(
&self,
args: &[A],
route: Route,
) -> ValkeyResult<ValkeyValue>
pub fn custom_command_with_route<A: ToValkeyArgs + Sync>( &self, args: &[A], route: Route, ) -> ValkeyResult<ValkeyValue>
Run an arbitrary command with an explicit route (blocking).
Sourcepub fn update_connection_password(
&self,
password: Option<String>,
immediate_auth: bool,
) -> ValkeyResult<()>
pub fn update_connection_password( &self, password: Option<String>, immediate_auth: bool, ) -> ValkeyResult<()>
Update the connection password (blocking). See
GlideClusterClient::update_connection_password.
Sourcepub fn exec(
&self,
pipeline: &Pipeline,
raise_on_error: bool,
route: Option<Route>,
options: &PipelineOptions,
) -> ValkeyResult<Vec<ValkeyValue>>
pub fn exec( &self, pipeline: &Pipeline, raise_on_error: bool, route: Option<Route>, options: &PipelineOptions, ) -> ValkeyResult<Vec<ValkeyValue>>
Execute a crate::pipeline::Pipeline with GLIDE execution options,
optionally routed (blocking). See
crate::GlideClusterClient::exec.
Sourcepub fn ping(&self) -> ValkeyResult<String>
pub fn ping(&self) -> ValkeyResult<String>
Blocking PING.
Trait Implementations§
Auto Trait Implementations§
impl !RefUnwindSafe for SyncGlideClusterClient
impl !UnwindSafe for SyncGlideClusterClient
impl Freeze for SyncGlideClusterClient
impl Send for SyncGlideClusterClient
impl Sync for SyncGlideClusterClient
impl Unpin for SyncGlideClusterClient
impl UnsafeUnpin for SyncGlideClusterClient
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
Source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
Source§impl<T> Commands for Twhere
T: SyncCommandDispatch,
impl<T> Commands for Twhere
T: SyncCommandDispatch,
Source§fn glide_send_command(&self, cmd: Cmd) -> ValkeyResult<ValkeyValue>
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>
fn glide_send_command_as<RV: FromValkeyValue>( &self, cmd: Cmd, ) -> ValkeyResult<RV>
Source§fn get<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>(
&self,
key: K,
) -> ValkeyResult<RV>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
fn incr<'a, K: ToSingleValkeyArg, V: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, delta: V, ) -> ValkeyResult<RV>
INCRBY/INCRBYFLOATSource§fn decr<'a, K: ToSingleValkeyArg, V: ToSingleValkeyArg, RV: FromValkeyValue>(
&self,
key: K,
delta: V,
) -> ValkeyResult<RV>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
fn rename_nx<'a, K: ToSingleValkeyArg, N: ToSingleValkeyArg, RV: FromValkeyValue>( &self, key: K, new_key: N, ) -> ValkeyResult<RV>
RENAMENX.Source§fn unlink<'a, K: ToValkeyArgs, RV: FromValkeyValue>(
&self,
key: K,
) -> ValkeyResult<RV>
fn unlink<'a, K: ToValkeyArgs, RV: FromValkeyValue>( &self, key: K, ) -> ValkeyResult<RV>
UNLINK.Source§fn object_encoding<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>(
&self,
key: K,
) -> ValkeyResult<RV>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
fn ping<'a, RV: FromValkeyValue>(&self) -> ValkeyResult<RV>
PING.Source§fn ping_message<'a, K: ToSingleValkeyArg, RV: FromValkeyValue>(
&self,
message: K,
) -> ValkeyResult<RV>
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>
fn client_getname<'a, RV: FromValkeyValue>(&self) -> ValkeyResult<RV>
CLIENT GETNAME.Source§fn client_id<'a, RV: FromValkeyValue>(&self) -> ValkeyResult<RV>
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>
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>
fn flushall<'a, RV: FromValkeyValue>(&self) -> ValkeyResult<RV>
FLUSHALL.Source§fn flushall_options<'a, RV: FromValkeyValue>(
&self,
options: &'a FlushAllOptions,
) -> ValkeyResult<RV>
fn flushall_options<'a, RV: FromValkeyValue>( &self, options: &'a FlushAllOptions, ) -> ValkeyResult<RV>
FLUSHALL.Source§fn flushdb<'a, RV: FromValkeyValue>(&self) -> ValkeyResult<RV>
fn flushdb<'a, RV: FromValkeyValue>(&self) -> ValkeyResult<RV>
FLUSHDB.Source§fn flushdb_options<'a, RV: FromValkeyValue>(
&self,
options: &'a FlushDbOptions,
) -> ValkeyResult<RV>
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>
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>
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>>
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>>
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>>
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>>
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>>
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>>
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>>
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>>
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> FutureExt for T
impl<T> FutureExt for T
Source§fn with_context(self, otel_cx: Context) -> WithContext<Self> ⓘ
fn with_context(self, otel_cx: Context) -> WithContext<Self> ⓘ
Source§fn with_current_context(self) -> WithContext<Self> ⓘ
fn with_current_context(self) -> WithContext<Self> ⓘ
Source§impl<T> Instrument for T
impl<T> Instrument for T
Source§fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
Source§fn in_current_span(self) -> Instrumented<Self> ⓘ
fn in_current_span(self) -> Instrumented<Self> ⓘ
Source§impl<T> IntoEither for T
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
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 moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
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 moreSource§impl<T> IntoRequest<T> for T
impl<T> IntoRequest<T> for T
Source§fn into_request(self) -> Request<T>
fn into_request(self) -> Request<T>
Wrap the input message
T in a tonic::RequestCreates a shared type from an unshared type.
Source§impl<T> PolicyExt for Twhere
T: ?Sized,
impl<T> PolicyExt for Twhere
T: ?Sized,
impl<T> Read<Exclusive, BecauseExclusive> for Twhere
T: ?Sized,
Source§impl<T> TypedCommands for Twhere
T: SyncCommandDispatch,
impl<T> TypedCommands for Twhere
T: SyncCommandDispatch,
Source§fn get<'a, K: ToSingleValkeyArg>(&self, key: K) -> ValkeyResult<Option<String>>
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>>>
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<()>
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>>
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<()>
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<()>
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<()>
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>
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>
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>>
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>
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>
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>>
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>>
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>
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>
fn incr<'a, K: ToSingleValkeyArg, V: ToSingleValkeyArg>( &self, key: K, delta: V, ) -> ValkeyResult<isize>
INCRBY/INCRBYFLOATSource§fn decr<'a, K: ToSingleValkeyArg, V: ToSingleValkeyArg>(
&self,
key: K,
delta: V,
) -> ValkeyResult<isize>
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>
fn strlen<'a, K: ToSingleValkeyArg>(&self, key: K) -> ValkeyResult<usize>
STRLEN.Source§fn keys<'a, K: ToSingleValkeyArg>(&self, key: K) -> ValkeyResult<Vec<String>>
fn keys<'a, K: ToSingleValkeyArg>(&self, key: K) -> ValkeyResult<Vec<String>>
KEYS.Source§fn del<'a, K: ToValkeyArgs>(&self, key: K) -> ValkeyResult<usize>
fn del<'a, K: ToValkeyArgs>(&self, key: K) -> ValkeyResult<usize>
DEL.Source§fn exists<'a, K: ToValkeyArgs>(&self, key: K) -> ValkeyResult<bool>
fn exists<'a, K: ToValkeyArgs>(&self, key: K) -> ValkeyResult<bool>
EXISTS.Source§fn key_type<'a, K: ToSingleValkeyArg>(&self, key: K) -> ValkeyResult<ValueType>
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>
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>
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>
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>
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>
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>
fn pexpire_time<'a, K: ToSingleValkeyArg>( &self, key: K, ) -> ValkeyResult<IntegerReplyOrNoOp>
PEXPIRETIME.Source§fn persist<'a, K: ToSingleValkeyArg>(&self, key: K) -> ValkeyResult<bool>
fn persist<'a, K: ToSingleValkeyArg>(&self, key: K) -> ValkeyResult<bool>
PERSIST.Source§fn ttl<'a, K: ToSingleValkeyArg>(
&self,
key: K,
) -> ValkeyResult<IntegerReplyOrNoOp>
fn ttl<'a, K: ToSingleValkeyArg>( &self, key: K, ) -> ValkeyResult<IntegerReplyOrNoOp>
TTL.Source§fn pttl<'a, K: ToSingleValkeyArg>(
&self,
key: K,
) -> ValkeyResult<IntegerReplyOrNoOp>
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<()>
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>
fn rename_nx<'a, K: ToSingleValkeyArg, N: ToSingleValkeyArg>( &self, key: K, new_key: N, ) -> ValkeyResult<bool>
RENAMENX.Source§fn unlink<'a, K: ToValkeyArgs>(&self, key: K) -> ValkeyResult<usize>
fn unlink<'a, K: ToValkeyArgs>(&self, key: K) -> ValkeyResult<usize>
UNLINK.Source§fn object_encoding<'a, K: ToSingleValkeyArg>(
&self,
key: K,
) -> ValkeyResult<Option<String>>
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>>
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>>
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>>
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>
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>>
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>)>>
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]>>
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]>>
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>>
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>>
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>
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>
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>
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>
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>)>>
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>
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>
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>
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>
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>>
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>
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<()>
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<()>
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>
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>>
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>
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>
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>>
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>>
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>
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>
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>
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>
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>
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>
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>>
fn hkeys<'a, K: ToSingleValkeyArg>(&self, key: K) -> ValkeyResult<Vec<String>>
HKEYS.Source§fn hvals<'a, K: ToSingleValkeyArg>(&self, key: K) -> ValkeyResult<Vec<String>>
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>>
fn hgetall<'a, K: ToSingleValkeyArg>( &self, key: K, ) -> ValkeyResult<HashMap<String, String>>
HGETALL.Source§fn hlen<'a, K: ToSingleValkeyArg>(&self, key: K) -> ValkeyResult<usize>
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>>
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>
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>>
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>>
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>>
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>>
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>>
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>>
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>>
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>>
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>>
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>
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>
fn scard<'a, K: ToSingleValkeyArg>(&self, key: K) -> ValkeyResult<usize>
SCARD.Source§fn sdiff<'a, K: ToValkeyArgs>(&self, keys: K) -> ValkeyResult<HashSet<String>>
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>
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>>
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>
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>
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>>
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>>
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>
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>
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>>
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>>
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>
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>>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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)>>
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)>>
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)>>
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)>>
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)>)>>
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)>)>>
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)>)>>
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)>)>>
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>
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>
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>>
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)>>
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>>
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>>
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>>
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>>
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>>
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)>>
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>>
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)>>
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>>
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>
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>
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>
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>
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>>
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)>>
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>>
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)>>
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>>
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)>>
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>>
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>>
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>>>
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>
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>
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>
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>
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>
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>
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>
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>
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<()>
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>
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>
fn getbit<'a, K: ToSingleValkeyArg>( &self, key: K, offset: usize, ) -> ValkeyResult<bool>
GETBIT.Source§fn bitcount<'a, K: ToSingleValkeyArg>(&self, key: K) -> ValkeyResult<usize>
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>
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>
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>
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>
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>
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>
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>>
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>>
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>>>>
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>
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>>
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>>
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>
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>
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>
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>
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<()>
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<()>
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>
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>
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>
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<()>
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>
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>
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>
fn xinfo_stream<'a, K: ToValkeyArgs>( &self, key: K, ) -> ValkeyResult<StreamInfoStreamReply>
XINFO STREAM.Source§fn xlen<'a, K: ToValkeyArgs>(&self, key: K) -> ValkeyResult<usize>
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>
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>
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>
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>
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>>
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>>
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>
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>
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>
fn xtrim_options<'a, K: ToValkeyArgs>( &self, key: K, options: &'a StreamTrimOptions, ) -> ValkeyResult<usize>
XTRIM.Source§fn ping<'a>(&self) -> ValkeyResult<String>
fn ping<'a>(&self) -> ValkeyResult<String>
PING.Source§fn ping_message<'a, K: ToSingleValkeyArg>(
&self,
message: K,
) -> ValkeyResult<String>
fn ping_message<'a, K: ToSingleValkeyArg>( &self, message: K, ) -> ValkeyResult<String>
PING with a message.Source§fn client_getname<'a>(&self) -> ValkeyResult<Option<String>>
fn client_getname<'a>(&self) -> ValkeyResult<Option<String>>
CLIENT GETNAME.Source§fn client_id<'a>(&self) -> ValkeyResult<isize>
fn client_id<'a>(&self) -> ValkeyResult<isize>
CLIENT ID.Source§fn client_setname<'a, K: ToSingleValkeyArg>(
&self,
connection_name: K,
) -> ValkeyResult<()>
fn client_setname<'a, K: ToSingleValkeyArg>( &self, connection_name: K, ) -> ValkeyResult<()>
CLIENT SETNAME.Source§fn flushall<'a>(&self) -> ValkeyResult<()>
fn flushall<'a>(&self) -> ValkeyResult<()>
FLUSHALL.Source§fn flushall_options<'a>(&self, options: &'a FlushAllOptions) -> ValkeyResult<()>
fn flushall_options<'a>(&self, options: &'a FlushAllOptions) -> ValkeyResult<()>
FLUSHALL.Source§fn flushdb<'a>(&self) -> ValkeyResult<()>
fn flushdb<'a>(&self) -> ValkeyResult<()>
FLUSHDB.Source§fn flushdb_options<'a>(&self, options: &'a FlushDbOptions) -> ValkeyResult<()>
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>
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>
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>>
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>>
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>>
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>>
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>>
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>>
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>>
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>>
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.