Struct redis::Connection
source · pub struct Connection { /* private fields */ }
Expand description
Represents a stateful redis TCP connection.
Implementations§
source§impl Connection
impl Connection
A connection is an object that represents a single redis connection. It provides basic support for sending encoded commands into a redis connection and to read a response from it. It’s bound to a single database and can only be created from the client.
You generally do not much with this object other than passing it to
Cmd
objects.
sourcepub fn send_packed_command(&mut self, cmd: &[u8]) -> RedisResult<()>
pub fn send_packed_command(&mut self, cmd: &[u8]) -> RedisResult<()>
Sends an already encoded (packed) command into the TCP socket and
does not read a response. This is useful for commands like
MONITOR
which yield multiple items. This needs to be used with
care because it changes the state of the connection.
sourcepub fn recv_response(&mut self) -> RedisResult<Value>
pub fn recv_response(&mut self) -> RedisResult<Value>
Fetches a single response from the connection. This is useful
if used in combination with send_packed_command
.
sourcepub fn set_write_timeout(&self, dur: Option<Duration>) -> RedisResult<()>
pub fn set_write_timeout(&self, dur: Option<Duration>) -> RedisResult<()>
Sets the write timeout for the connection.
If the provided value is None
, then send_packed_command
call will
block indefinitely. It is an error to pass the zero Duration
to this
method.
sourcepub fn set_read_timeout(&self, dur: Option<Duration>) -> RedisResult<()>
pub fn set_read_timeout(&self, dur: Option<Duration>) -> RedisResult<()>
Sets the read timeout for the connection.
If the provided value is None
, then recv_response
call will
block indefinitely. It is an error to pass the zero Duration
to this
method.
Trait Implementations§
source§impl Connect for Connection
Available on crate feature cluster
only.
impl Connect for Connection
cluster
only.source§fn connect<T>(info: T, timeout: Option<Duration>) -> RedisResult<Self>where
T: IntoConnectionInfo,
fn connect<T>(info: T, timeout: Option<Duration>) -> RedisResult<Self>where
T: IntoConnectionInfo,
source§fn send_packed_command(&mut self, cmd: &[u8]) -> RedisResult<()>
fn send_packed_command(&mut self, cmd: &[u8]) -> RedisResult<()>
MONITOR
which yield multiple items. This needs to be used with
care because it changes the state of the connection.source§fn set_write_timeout(&self, dur: Option<Duration>) -> RedisResult<()>
fn set_write_timeout(&self, dur: Option<Duration>) -> RedisResult<()>
source§fn set_read_timeout(&self, dur: Option<Duration>) -> RedisResult<()>
fn set_read_timeout(&self, dur: Option<Duration>) -> RedisResult<()>
source§fn recv_response(&mut self) -> RedisResult<Value>
fn recv_response(&mut self) -> RedisResult<Value>
send_packed_command
.source§impl ConnectionLike for Connection
impl ConnectionLike for Connection
source§fn req_packed_command(&mut self, cmd: &[u8]) -> RedisResult<Value>
fn req_packed_command(&mut self, cmd: &[u8]) -> RedisResult<Value>
source§fn get_db(&self) -> i64
fn get_db(&self) -> i64
source§fn check_connection(&mut self) -> bool
fn check_connection(&mut self) -> bool
PING
internally).source§fn req_command(&mut self, cmd: &Cmd) -> RedisResult<Value>
fn req_command(&mut self, cmd: &Cmd) -> RedisResult<Value>
source§impl PubSubCommands for Connection
impl PubSubCommands for Connection
source§fn subscribe<C, F, U>(&mut self, channels: C, func: F) -> RedisResult<U>
fn subscribe<C, F, U>(&mut self, channels: C, func: F) -> RedisResult<U>
source§fn psubscribe<P, F, U>(&mut self, patterns: P, func: F) -> RedisResult<U>
fn psubscribe<P, F, U>(&mut self, patterns: P, func: F) -> RedisResult<U>
Auto Trait Implementations§
impl Freeze for Connection
impl !RefUnwindSafe for Connection
impl Send for Connection
impl Sync for Connection
impl Unpin for Connection
impl !UnwindSafe for Connection
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
source§impl<T> Commands for Twhere
T: ConnectionLike,
impl<T> Commands for Twhere
T: ConnectionLike,
source§fn get<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn get<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
MGET
.source§fn mget<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn mget<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn keys<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn keys<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn set<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V
) -> RedisResult<RV>
fn set<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V ) -> RedisResult<RV>
source§fn set_options<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V,
options: SetOptions
) -> RedisResult<RV>
fn set_options<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V, options: SetOptions ) -> RedisResult<RV>
source§fn set_multiple<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
items: &'a [(K, V)]
) -> RedisResult<RV>
fn set_multiple<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, items: &'a [(K, V)] ) -> RedisResult<RV>
source§fn mset<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
items: &'a [(K, V)]
) -> RedisResult<RV>
fn mset<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, items: &'a [(K, V)] ) -> RedisResult<RV>
source§fn set_ex<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V,
seconds: u64
) -> RedisResult<RV>
fn set_ex<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V, seconds: u64 ) -> RedisResult<RV>
source§fn pset_ex<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V,
milliseconds: u64
) -> RedisResult<RV>
fn pset_ex<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V, milliseconds: u64 ) -> RedisResult<RV>
source§fn set_nx<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V
) -> RedisResult<RV>
fn set_nx<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V ) -> RedisResult<RV>
source§fn mset_nx<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
items: &'a [(K, V)]
) -> RedisResult<RV>
fn mset_nx<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, items: &'a [(K, V)] ) -> RedisResult<RV>
source§fn getset<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V
) -> RedisResult<RV>
fn getset<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V ) -> RedisResult<RV>
source§fn getrange<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
from: isize,
to: isize
) -> RedisResult<RV>
fn getrange<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, from: isize, to: isize ) -> RedisResult<RV>
source§fn setrange<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
offset: isize,
value: V
) -> RedisResult<RV>
fn setrange<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, offset: isize, value: V ) -> RedisResult<RV>
source§fn del<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn del<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn exists<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn exists<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn key_type<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn key_type<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn expire<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
seconds: i64
) -> RedisResult<RV>
fn expire<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, seconds: i64 ) -> RedisResult<RV>
source§fn expire_at<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
ts: i64
) -> RedisResult<RV>
fn expire_at<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ts: i64 ) -> RedisResult<RV>
source§fn pexpire<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
ms: i64
) -> RedisResult<RV>
fn pexpire<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ms: i64 ) -> RedisResult<RV>
source§fn pexpire_at<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
ts: i64
) -> RedisResult<RV>
fn pexpire_at<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ts: i64 ) -> RedisResult<RV>
source§fn persist<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn persist<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn ttl<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn ttl<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn pttl<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn pttl<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn get_ex<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
expire_at: Expiry
) -> RedisResult<RV>
fn get_ex<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, expire_at: Expiry ) -> RedisResult<RV>
source§fn get_del<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn get_del<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn rename<'a, K: ToRedisArgs, N: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
new_key: N
) -> RedisResult<RV>
fn rename<'a, K: ToRedisArgs, N: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, new_key: N ) -> RedisResult<RV>
source§fn rename_nx<'a, K: ToRedisArgs, N: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
new_key: N
) -> RedisResult<RV>
fn rename_nx<'a, K: ToRedisArgs, N: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, new_key: N ) -> RedisResult<RV>
source§fn unlink<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn unlink<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn append<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V
) -> RedisResult<RV>
fn append<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V ) -> RedisResult<RV>
source§fn incr<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
delta: V
) -> RedisResult<RV>
fn incr<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, delta: V ) -> RedisResult<RV>
INCRBY
or INCRBYFLOAT
depending on the type.source§fn decr<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
delta: V
) -> RedisResult<RV>
fn decr<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, delta: V ) -> RedisResult<RV>
source§fn setbit<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
offset: usize,
value: bool
) -> RedisResult<RV>
fn setbit<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, offset: usize, value: bool ) -> RedisResult<RV>
source§fn getbit<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
offset: usize
) -> RedisResult<RV>
fn getbit<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, offset: usize ) -> RedisResult<RV>
source§fn bitcount<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn bitcount<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn bitcount_range<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
start: usize,
end: usize
) -> RedisResult<RV>
fn bitcount_range<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, start: usize, end: usize ) -> RedisResult<RV>
source§fn bit_and<'a, D: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
srckeys: S
) -> RedisResult<RV>
fn bit_and<'a, D: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, srckeys: S ) -> RedisResult<RV>
source§fn bit_or<'a, D: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
srckeys: S
) -> RedisResult<RV>
fn bit_or<'a, D: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, srckeys: S ) -> RedisResult<RV>
source§fn bit_xor<'a, D: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
srckeys: S
) -> RedisResult<RV>
fn bit_xor<'a, D: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, srckeys: S ) -> RedisResult<RV>
source§fn bit_not<'a, D: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
srckey: S
) -> RedisResult<RV>
fn bit_not<'a, D: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, srckey: S ) -> RedisResult<RV>
source§fn strlen<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn strlen<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn hget<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
field: F
) -> RedisResult<RV>
fn hget<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, field: F ) -> RedisResult<RV>
source§fn hdel<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
field: F
) -> RedisResult<RV>
fn hdel<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, field: F ) -> RedisResult<RV>
source§fn hset<'a, K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
field: F,
value: V
) -> RedisResult<RV>
fn hset<'a, K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, field: F, value: V ) -> RedisResult<RV>
source§fn hset_nx<'a, K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
field: F,
value: V
) -> RedisResult<RV>
fn hset_nx<'a, K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, field: F, value: V ) -> RedisResult<RV>
source§fn hset_multiple<'a, K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
items: &'a [(F, V)]
) -> RedisResult<RV>
fn hset_multiple<'a, K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, items: &'a [(F, V)] ) -> RedisResult<RV>
source§fn hincr<'a, K: ToRedisArgs, F: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
field: F,
delta: D
) -> RedisResult<RV>
fn hincr<'a, K: ToRedisArgs, F: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, field: F, delta: D ) -> RedisResult<RV>
source§fn hexists<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
field: F
) -> RedisResult<RV>
fn hexists<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, field: F ) -> RedisResult<RV>
source§fn hkeys<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn hkeys<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn hvals<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn hvals<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn hgetall<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn hgetall<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn hlen<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn hlen<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn blmove<'a, S: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>(
&mut self,
srckey: S,
dstkey: D,
src_dir: Direction,
dst_dir: Direction,
timeout: f64
) -> RedisResult<RV>
fn blmove<'a, S: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>( &mut self, srckey: S, dstkey: D, src_dir: Direction, dst_dir: Direction, timeout: f64 ) -> RedisResult<RV>
source§fn blmpop<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
timeout: f64,
numkeys: usize,
key: K,
dir: Direction,
count: usize
) -> RedisResult<RV>
fn blmpop<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, timeout: f64, numkeys: usize, key: K, dir: Direction, count: usize ) -> RedisResult<RV>
count
elements from the first non-empty list key from the list of
provided key names; or blocks until one is available.source§fn blpop<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
timeout: f64
) -> RedisResult<RV>
fn blpop<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, timeout: f64 ) -> RedisResult<RV>
source§fn brpop<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
timeout: f64
) -> RedisResult<RV>
fn brpop<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, timeout: f64 ) -> RedisResult<RV>
source§fn brpoplpush<'a, S: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>(
&mut self,
srckey: S,
dstkey: D,
timeout: f64
) -> RedisResult<RV>
fn brpoplpush<'a, S: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>( &mut self, srckey: S, dstkey: D, timeout: f64 ) -> RedisResult<RV>
source§fn lindex<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
index: isize
) -> RedisResult<RV>
fn lindex<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, index: isize ) -> RedisResult<RV>
source§fn linsert_before<'a, K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
pivot: P,
value: V
) -> RedisResult<RV>
fn linsert_before<'a, K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, pivot: P, value: V ) -> RedisResult<RV>
source§fn linsert_after<'a, K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
pivot: P,
value: V
) -> RedisResult<RV>
fn linsert_after<'a, K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, pivot: P, value: V ) -> RedisResult<RV>
source§fn llen<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn llen<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn lmove<'a, S: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>(
&mut self,
srckey: S,
dstkey: D,
src_dir: Direction,
dst_dir: Direction
) -> RedisResult<RV>
fn lmove<'a, S: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>( &mut self, srckey: S, dstkey: D, src_dir: Direction, dst_dir: Direction ) -> RedisResult<RV>
source§fn lmpop<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
numkeys: usize,
key: K,
dir: Direction,
count: usize
) -> RedisResult<RV>
fn lmpop<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, numkeys: usize, key: K, dir: Direction, count: usize ) -> RedisResult<RV>
count
elements from the first non-empty list key from the list of
provided key names.source§fn lpop<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
count: Option<NonZeroUsize>
) -> RedisResult<RV>
fn lpop<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, count: Option<NonZeroUsize> ) -> RedisResult<RV>
count
first elements of the list stored at key. Read moresource§fn lpos<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V,
options: LposOptions
) -> RedisResult<RV>
fn lpos<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V, options: LposOptions ) -> RedisResult<RV>
source§fn lpush<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V
) -> RedisResult<RV>
fn lpush<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V ) -> RedisResult<RV>
source§fn lpush_exists<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V
) -> RedisResult<RV>
fn lpush_exists<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V ) -> RedisResult<RV>
source§fn lrange<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
start: isize,
stop: isize
) -> RedisResult<RV>
fn lrange<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, start: isize, stop: isize ) -> RedisResult<RV>
source§fn lrem<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
count: isize,
value: V
) -> RedisResult<RV>
fn lrem<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, count: isize, value: V ) -> RedisResult<RV>
source§fn ltrim<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
start: isize,
stop: isize
) -> RedisResult<RV>
fn ltrim<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, start: isize, stop: isize ) -> RedisResult<RV>
source§fn lset<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
index: isize,
value: V
) -> RedisResult<RV>
fn lset<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, index: isize, value: V ) -> RedisResult<RV>
source§fn rpop<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
count: Option<NonZeroUsize>
) -> RedisResult<RV>
fn rpop<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, count: Option<NonZeroUsize> ) -> RedisResult<RV>
count
last elements of the list stored at key Read moresource§fn rpoplpush<'a, K: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
dstkey: D
) -> RedisResult<RV>
fn rpoplpush<'a, K: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, dstkey: D ) -> RedisResult<RV>
source§fn rpush<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V
) -> RedisResult<RV>
fn rpush<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V ) -> RedisResult<RV>
source§fn rpush_exists<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V
) -> RedisResult<RV>
fn rpush_exists<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V ) -> RedisResult<RV>
source§fn sadd<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
member: M
) -> RedisResult<RV>
fn sadd<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, member: M ) -> RedisResult<RV>
source§fn scard<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn scard<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn sdiff<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
keys: K
) -> RedisResult<RV>
fn sdiff<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, keys: K ) -> RedisResult<RV>
source§fn sdiffstore<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: K
) -> RedisResult<RV>
fn sdiffstore<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: K ) -> RedisResult<RV>
source§fn sinter<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
keys: K
) -> RedisResult<RV>
fn sinter<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, keys: K ) -> RedisResult<RV>
source§fn sinterstore<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: K
) -> RedisResult<RV>
fn sinterstore<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: K ) -> RedisResult<RV>
source§fn sismember<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
member: M
) -> RedisResult<RV>
fn sismember<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, member: M ) -> RedisResult<RV>
source§fn smismember<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
members: M
) -> RedisResult<RV>
fn smismember<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, members: M ) -> RedisResult<RV>
source§fn smembers<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn smembers<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn smove<'a, S: ToRedisArgs, D: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
srckey: S,
dstkey: D,
member: M
) -> RedisResult<RV>
fn smove<'a, S: ToRedisArgs, D: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, srckey: S, dstkey: D, member: M ) -> RedisResult<RV>
source§fn spop<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn spop<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn srandmember<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn srandmember<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn srandmember_multiple<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
count: usize
) -> RedisResult<RV>
fn srandmember_multiple<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, count: usize ) -> RedisResult<RV>
source§fn srem<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
member: M
) -> RedisResult<RV>
fn srem<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, member: M ) -> RedisResult<RV>
source§fn sunion<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
keys: K
) -> RedisResult<RV>
fn sunion<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, keys: K ) -> RedisResult<RV>
source§fn sunionstore<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: K
) -> RedisResult<RV>
fn sunionstore<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: K ) -> RedisResult<RV>
source§fn zadd<'a, K: ToRedisArgs, S: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
member: M,
score: S
) -> RedisResult<RV>
fn zadd<'a, K: ToRedisArgs, S: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, member: M, score: S ) -> RedisResult<RV>
source§fn zadd_multiple<'a, K: ToRedisArgs, S: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
items: &'a [(S, M)]
) -> RedisResult<RV>
fn zadd_multiple<'a, K: ToRedisArgs, S: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, items: &'a [(S, M)] ) -> RedisResult<RV>
source§fn zcard<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn zcard<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn zcount<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
min: M,
max: MM
) -> RedisResult<RV>
fn zcount<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, min: M, max: MM ) -> RedisResult<RV>
source§fn zincr<'a, K: ToRedisArgs, M: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
member: M,
delta: D
) -> RedisResult<RV>
fn zincr<'a, K: ToRedisArgs, M: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, member: M, delta: D ) -> RedisResult<RV>
source§fn zinterstore<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [K]
) -> RedisResult<RV>
fn zinterstore<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [K] ) -> RedisResult<RV>
source§fn zinterstore_min<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [K]
) -> RedisResult<RV>
fn zinterstore_min<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [K] ) -> RedisResult<RV>
source§fn zinterstore_max<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [K]
) -> RedisResult<RV>
fn zinterstore_max<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [K] ) -> RedisResult<RV>
source§fn zinterstore_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [(K, W)]
) -> RedisResult<RV>
fn zinterstore_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [(K, W)] ) -> RedisResult<RV>
Commands::zinterstore
, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.source§fn zinterstore_min_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [(K, W)]
) -> RedisResult<RV>
fn zinterstore_min_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [(K, W)] ) -> RedisResult<RV>
Commands::zinterstore_min
, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.source§fn zinterstore_max_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [(K, W)]
) -> RedisResult<RV>
fn zinterstore_max_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [(K, W)] ) -> RedisResult<RV>
Commands::zinterstore_max
, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.source§fn zlexcount<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
min: M,
max: MM
) -> RedisResult<RV>
fn zlexcount<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, min: M, max: MM ) -> RedisResult<RV>
source§fn bzpopmax<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
timeout: f64
) -> RedisResult<RV>
fn bzpopmax<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, timeout: f64 ) -> RedisResult<RV>
source§fn zpopmax<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
count: isize
) -> RedisResult<RV>
fn zpopmax<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, count: isize ) -> RedisResult<RV>
source§fn bzpopmin<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
timeout: f64
) -> RedisResult<RV>
fn bzpopmin<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, timeout: f64 ) -> RedisResult<RV>
source§fn zpopmin<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
count: isize
) -> RedisResult<RV>
fn zpopmin<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, count: isize ) -> RedisResult<RV>
source§fn bzmpop_max<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
timeout: f64,
keys: &'a [K],
count: isize
) -> RedisResult<RV>
fn bzmpop_max<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, timeout: f64, keys: &'a [K], count: isize ) -> RedisResult<RV>
source§fn zmpop_max<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
keys: &'a [K],
count: isize
) -> RedisResult<RV>
fn zmpop_max<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, keys: &'a [K], count: isize ) -> RedisResult<RV>
source§fn bzmpop_min<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
timeout: f64,
keys: &'a [K],
count: isize
) -> RedisResult<RV>
fn bzmpop_min<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, timeout: f64, keys: &'a [K], count: isize ) -> RedisResult<RV>
source§fn zmpop_min<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
keys: &'a [K],
count: isize
) -> RedisResult<RV>
fn zmpop_min<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, keys: &'a [K], count: isize ) -> RedisResult<RV>
source§fn zrandmember<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
count: Option<isize>
) -> RedisResult<RV>
fn zrandmember<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, count: Option<isize> ) -> RedisResult<RV>
count == None
)source§fn zrandmember_withscores<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
count: isize
) -> RedisResult<RV>
fn zrandmember_withscores<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, count: isize ) -> RedisResult<RV>
source§fn zrange<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
start: isize,
stop: isize
) -> RedisResult<RV>
fn zrange<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, start: isize, stop: isize ) -> RedisResult<RV>
source§fn zrange_withscores<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
start: isize,
stop: isize
) -> RedisResult<RV>
fn zrange_withscores<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, start: isize, stop: isize ) -> RedisResult<RV>
source§fn zrangebylex<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
min: M,
max: MM
) -> RedisResult<RV>
fn zrangebylex<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, min: M, max: MM ) -> RedisResult<RV>
source§fn zrangebylex_limit<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> RedisResult<RV>
fn zrangebylex_limit<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, min: M, max: MM, offset: isize, count: isize ) -> RedisResult<RV>
source§fn zrevrangebylex<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
max: MM,
min: M
) -> RedisResult<RV>
fn zrevrangebylex<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, max: MM, min: M ) -> RedisResult<RV>
source§fn zrevrangebylex_limit<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> RedisResult<RV>
fn zrevrangebylex_limit<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, max: MM, min: M, offset: isize, count: isize ) -> RedisResult<RV>
source§fn zrangebyscore<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
min: M,
max: MM
) -> RedisResult<RV>
fn zrangebyscore<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, min: M, max: MM ) -> RedisResult<RV>
source§fn zrangebyscore_withscores<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
min: M,
max: MM
) -> RedisResult<RV>
fn zrangebyscore_withscores<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, min: M, max: MM ) -> RedisResult<RV>
source§fn zrangebyscore_limit<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> RedisResult<RV>
fn zrangebyscore_limit<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, min: M, max: MM, offset: isize, count: isize ) -> RedisResult<RV>
source§fn zrangebyscore_limit_withscores<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> RedisResult<RV>
fn zrangebyscore_limit_withscores<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, min: M, max: MM, offset: isize, count: isize ) -> RedisResult<RV>
source§fn zrank<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
member: M
) -> RedisResult<RV>
fn zrank<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, member: M ) -> RedisResult<RV>
source§fn zrem<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
members: M
) -> RedisResult<RV>
fn zrem<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, members: M ) -> RedisResult<RV>
source§fn zrembylex<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
min: M,
max: MM
) -> RedisResult<RV>
fn zrembylex<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, min: M, max: MM ) -> RedisResult<RV>
source§fn zremrangebyrank<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
start: isize,
stop: isize
) -> RedisResult<RV>
fn zremrangebyrank<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, start: isize, stop: isize ) -> RedisResult<RV>
source§fn zrembyscore<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
min: M,
max: MM
) -> RedisResult<RV>
fn zrembyscore<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, min: M, max: MM ) -> RedisResult<RV>
source§fn zrevrange<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
start: isize,
stop: isize
) -> RedisResult<RV>
fn zrevrange<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, start: isize, stop: isize ) -> RedisResult<RV>
source§fn zrevrange_withscores<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
start: isize,
stop: isize
) -> RedisResult<RV>
fn zrevrange_withscores<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, start: isize, stop: isize ) -> RedisResult<RV>
source§fn zrevrangebyscore<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
max: MM,
min: M
) -> RedisResult<RV>
fn zrevrangebyscore<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, max: MM, min: M ) -> RedisResult<RV>
source§fn zrevrangebyscore_withscores<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
max: MM,
min: M
) -> RedisResult<RV>
fn zrevrangebyscore_withscores<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, max: MM, min: M ) -> RedisResult<RV>
source§fn zrevrangebyscore_limit<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> RedisResult<RV>
fn zrevrangebyscore_limit<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, max: MM, min: M, offset: isize, count: isize ) -> RedisResult<RV>
source§fn zrevrangebyscore_limit_withscores<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> RedisResult<RV>
fn zrevrangebyscore_limit_withscores<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, max: MM, min: M, offset: isize, count: isize ) -> RedisResult<RV>
source§fn zrevrank<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
member: M
) -> RedisResult<RV>
fn zrevrank<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, member: M ) -> RedisResult<RV>
source§fn zscore<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
member: M
) -> RedisResult<RV>
fn zscore<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, member: M ) -> RedisResult<RV>
source§fn zscore_multiple<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
members: &'a [M]
) -> RedisResult<RV>
fn zscore_multiple<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, members: &'a [M] ) -> RedisResult<RV>
source§fn zunionstore<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [K]
) -> RedisResult<RV>
fn zunionstore<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [K] ) -> RedisResult<RV>
source§fn zunionstore_min<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [K]
) -> RedisResult<RV>
fn zunionstore_min<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [K] ) -> RedisResult<RV>
source§fn zunionstore_max<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [K]
) -> RedisResult<RV>
fn zunionstore_max<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [K] ) -> RedisResult<RV>
source§fn zunionstore_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [(K, W)]
) -> RedisResult<RV>
fn zunionstore_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [(K, W)] ) -> RedisResult<RV>
Commands::zunionstore
, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.source§fn zunionstore_min_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [(K, W)]
) -> RedisResult<RV>
fn zunionstore_min_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [(K, W)] ) -> RedisResult<RV>
Commands::zunionstore_min
, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.source§fn zunionstore_max_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [(K, W)]
) -> RedisResult<RV>
fn zunionstore_max_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [(K, W)] ) -> RedisResult<RV>
Commands::zunionstore_max
, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.source§fn pfadd<'a, K: ToRedisArgs, E: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
element: E
) -> RedisResult<RV>
fn pfadd<'a, K: ToRedisArgs, E: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, element: E ) -> RedisResult<RV>
source§fn pfcount<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn pfcount<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn pfmerge<'a, D: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
srckeys: S
) -> RedisResult<RV>
fn pfmerge<'a, D: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, srckeys: S ) -> RedisResult<RV>
source§fn publish<'a, K: ToRedisArgs, E: ToRedisArgs, RV: FromRedisValue>(
&mut self,
channel: K,
message: E
) -> RedisResult<RV>
fn publish<'a, K: ToRedisArgs, E: ToRedisArgs, RV: FromRedisValue>( &mut self, channel: K, message: E ) -> RedisResult<RV>
source§fn object_encoding<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn object_encoding<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn object_idletime<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn object_idletime<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn object_freq<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn object_freq<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn object_refcount<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn object_refcount<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn acl_load<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_load<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
acl
only.source§fn acl_save<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_save<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
acl
only.source§fn acl_list<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_list<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
acl
only.source§fn acl_users<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_users<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
acl
only.source§fn acl_getuser<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
username: K
) -> RedisResult<RV>
fn acl_getuser<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, username: K ) -> RedisResult<RV>
acl
only.source§fn acl_setuser<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
username: K
) -> RedisResult<RV>
fn acl_setuser<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, username: K ) -> RedisResult<RV>
acl
only.source§fn acl_setuser_rules<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
username: K,
rules: &'a [Rule]
) -> RedisResult<RV>
fn acl_setuser_rules<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, username: K, rules: &'a [Rule] ) -> RedisResult<RV>
acl
only.source§fn acl_deluser<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
usernames: &'a [K]
) -> RedisResult<RV>
fn acl_deluser<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, usernames: &'a [K] ) -> RedisResult<RV>
acl
only.source§fn acl_cat<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_cat<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
acl
only.source§fn acl_cat_categoryname<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
categoryname: K
) -> RedisResult<RV>
fn acl_cat_categoryname<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, categoryname: K ) -> RedisResult<RV>
acl
only.source§fn acl_genpass<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_genpass<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
acl
only.source§fn acl_genpass_bits<'a, RV: FromRedisValue>(
&mut self,
bits: isize
) -> RedisResult<RV>
fn acl_genpass_bits<'a, RV: FromRedisValue>( &mut self, bits: isize ) -> RedisResult<RV>
acl
only.source§fn acl_whoami<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_whoami<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
acl
only.source§fn acl_log<'a, RV: FromRedisValue>(&mut self, count: isize) -> RedisResult<RV>
fn acl_log<'a, RV: FromRedisValue>(&mut self, count: isize) -> RedisResult<RV>
acl
only.source§fn acl_log_reset<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_log_reset<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
acl
only.source§fn acl_help<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_help<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
acl
only.source§fn geo_add<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
members: M
) -> RedisResult<RV>
fn geo_add<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, members: M ) -> RedisResult<RV>
geospatial
only.source§fn geo_dist<'a, K: ToRedisArgs, M1: ToRedisArgs, M2: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
member1: M1,
member2: M2,
unit: Unit
) -> RedisResult<RV>
fn geo_dist<'a, K: ToRedisArgs, M1: ToRedisArgs, M2: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, member1: M1, member2: M2, unit: Unit ) -> RedisResult<RV>
geospatial
only.source§fn geo_hash<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
members: M
) -> RedisResult<RV>
fn geo_hash<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, members: M ) -> RedisResult<RV>
geospatial
only.source§fn geo_pos<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
members: M
) -> RedisResult<RV>
fn geo_pos<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, members: M ) -> RedisResult<RV>
geospatial
only.source§fn geo_radius<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
longitude: f64,
latitude: f64,
radius: f64,
unit: Unit,
options: RadiusOptions
) -> RedisResult<RV>
fn geo_radius<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, longitude: f64, latitude: f64, radius: f64, unit: Unit, options: RadiusOptions ) -> RedisResult<RV>
geospatial
only.source§fn geo_radius_by_member<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
member: M,
radius: f64,
unit: Unit,
options: RadiusOptions
) -> RedisResult<RV>
fn geo_radius_by_member<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, member: M, radius: f64, unit: Unit, options: RadiusOptions ) -> RedisResult<RV>
geospatial
only.member
. The
member itself is always contained in the results.source§fn xack<'a, K: ToRedisArgs, G: ToRedisArgs, I: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G,
ids: &'a [I]
) -> RedisResult<RV>
fn xack<'a, K: ToRedisArgs, G: ToRedisArgs, I: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G, ids: &'a [I] ) -> RedisResult<RV>
streams
only.source§fn xadd<'a, K: ToRedisArgs, ID: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
id: ID,
items: &'a [(F, V)]
) -> RedisResult<RV>
fn xadd<'a, K: ToRedisArgs, ID: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, id: ID, items: &'a [(F, V)] ) -> RedisResult<RV>
streams
only.source§fn xadd_map<'a, K: ToRedisArgs, ID: ToRedisArgs, BTM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
id: ID,
map: BTM
) -> RedisResult<RV>
fn xadd_map<'a, K: ToRedisArgs, ID: ToRedisArgs, BTM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, id: ID, map: BTM ) -> RedisResult<RV>
streams
only.key
.
Use *
as the id
for the current timestamp. Read moresource§fn xadd_maxlen<'a, K: ToRedisArgs, ID: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
maxlen: StreamMaxlen,
id: ID,
items: &'a [(F, V)]
) -> RedisResult<RV>
fn xadd_maxlen<'a, K: ToRedisArgs, ID: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, maxlen: StreamMaxlen, id: ID, items: &'a [(F, V)] ) -> RedisResult<RV>
streams
only.source§fn xadd_maxlen_map<'a, K: ToRedisArgs, ID: ToRedisArgs, BTM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
maxlen: StreamMaxlen,
id: ID,
map: BTM
) -> RedisResult<RV>
fn xadd_maxlen_map<'a, K: ToRedisArgs, ID: ToRedisArgs, BTM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, maxlen: StreamMaxlen, id: ID, map: BTM ) -> RedisResult<RV>
streams
only.source§fn xclaim<'a, K: ToRedisArgs, G: ToRedisArgs, C: ToRedisArgs, MIT: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G,
consumer: C,
min_idle_time: MIT,
ids: &'a [ID]
) -> RedisResult<RV>
fn xclaim<'a, K: ToRedisArgs, G: ToRedisArgs, C: ToRedisArgs, MIT: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G, consumer: C, min_idle_time: MIT, ids: &'a [ID] ) -> RedisResult<RV>
streams
only.source§fn xclaim_options<'a, K: ToRedisArgs, G: ToRedisArgs, C: ToRedisArgs, MIT: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G,
consumer: C,
min_idle_time: MIT,
ids: &'a [ID],
options: StreamClaimOptions
) -> RedisResult<RV>
fn xclaim_options<'a, K: ToRedisArgs, G: ToRedisArgs, C: ToRedisArgs, MIT: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G, consumer: C, min_idle_time: MIT, ids: &'a [ID], options: StreamClaimOptions ) -> RedisResult<RV>
streams
only.source§fn xdel<'a, K: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
ids: &'a [ID]
) -> RedisResult<RV>
fn xdel<'a, K: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ids: &'a [ID] ) -> RedisResult<RV>
streams
only.source§fn xgroup_create<'a, K: ToRedisArgs, G: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G,
id: ID
) -> RedisResult<RV>
fn xgroup_create<'a, K: ToRedisArgs, G: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G, id: ID ) -> RedisResult<RV>
streams
only.group
. It expects the stream key
to already exist. Otherwise, use xgroup_create_mkstream
if it doesn’t.
The id
is the starting message id all consumers should read from. Use $
If you want
all consumers to read from the last message added to stream. Read moresource§fn xgroup_create_mkstream<'a, K: ToRedisArgs, G: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G,
id: ID
) -> RedisResult<RV>
fn xgroup_create_mkstream<'a, K: ToRedisArgs, G: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G, id: ID ) -> RedisResult<RV>
streams
only.group
which makes the stream if it doesn’t exist. Read moresource§fn xgroup_setid<'a, K: ToRedisArgs, G: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G,
id: ID
) -> RedisResult<RV>
fn xgroup_setid<'a, K: ToRedisArgs, G: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G, id: ID ) -> RedisResult<RV>
streams
only.source§fn xgroup_destroy<'a, K: ToRedisArgs, G: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G
) -> RedisResult<RV>
fn xgroup_destroy<'a, K: ToRedisArgs, G: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G ) -> RedisResult<RV>
streams
only.source§fn xgroup_delconsumer<'a, K: ToRedisArgs, G: ToRedisArgs, C: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G,
consumer: C
) -> RedisResult<RV>
fn xgroup_delconsumer<'a, K: ToRedisArgs, G: ToRedisArgs, C: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G, consumer: C ) -> RedisResult<RV>
streams
only.source§fn xinfo_consumers<'a, K: ToRedisArgs, G: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G
) -> RedisResult<RV>
fn xinfo_consumers<'a, K: ToRedisArgs, G: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G ) -> RedisResult<RV>
streams
only.group
.
Take note of the StreamInfoConsumersReply return type. Read moresource§fn xinfo_groups<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn xinfo_groups<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
streams
only.group
s created for a given stream key
.
Take note of the StreamInfoGroupsReply return type. Read moresource§fn xinfo_stream<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn xinfo_stream<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
streams
only.id
, length, number of groups, etc.)
Take note of the StreamInfoStreamReply return type. Read moresource§fn xlen<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn xlen<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
streams
only.key
. Read moresource§fn xpending<'a, K: ToRedisArgs, G: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G
) -> RedisResult<RV>
fn xpending<'a, K: ToRedisArgs, G: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G ) -> RedisResult<RV>
streams
only.key
and consumer group
and it
returns details about which consumers have pending messages
that haven’t been acked. Read moresource§fn xpending_count<'a, K: ToRedisArgs, G: ToRedisArgs, S: ToRedisArgs, E: ToRedisArgs, C: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G,
start: S,
end: E,
count: C
) -> RedisResult<RV>
fn xpending_count<'a, K: ToRedisArgs, G: ToRedisArgs, S: ToRedisArgs, E: ToRedisArgs, C: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G, start: S, end: E, count: C ) -> RedisResult<RV>
streams
only.source§fn xpending_consumer_count<'a, K: ToRedisArgs, G: ToRedisArgs, S: ToRedisArgs, E: ToRedisArgs, C: ToRedisArgs, CN: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G,
start: S,
end: E,
count: C,
consumer: CN
) -> RedisResult<RV>
fn xpending_consumer_count<'a, K: ToRedisArgs, G: ToRedisArgs, S: ToRedisArgs, E: ToRedisArgs, C: ToRedisArgs, CN: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G, start: S, end: E, count: C, consumer: CN ) -> RedisResult<RV>
streams
only.source§fn xrange<'a, K: ToRedisArgs, S: ToRedisArgs, E: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
start: S,
end: E
) -> RedisResult<RV>
fn xrange<'a, K: ToRedisArgs, S: ToRedisArgs, E: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, start: S, end: E ) -> RedisResult<RV>
streams
only.key
. Read moresource§fn xrange_all<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn xrange_all<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
streams
only.key
.
Use with caution! Read moresource§fn xrange_count<'a, K: ToRedisArgs, S: ToRedisArgs, E: ToRedisArgs, C: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
start: S,
end: E,
count: C
) -> RedisResult<RV>
fn xrange_count<'a, K: ToRedisArgs, S: ToRedisArgs, E: ToRedisArgs, C: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, start: S, end: E, count: C ) -> RedisResult<RV>
streams
only.key
. Read moresource§fn xread<'a, K: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>(
&mut self,
keys: &'a [K],
ids: &'a [ID]
) -> RedisResult<RV>
fn xread<'a, K: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>( &mut self, keys: &'a [K], ids: &'a [ID] ) -> RedisResult<RV>
streams
only.id
s for each stream key
.
This is the basic form of reading streams.
For more advanced control, like blocking, limiting, or reading by consumer group
,
see xread_options
. Read moresource§fn xread_options<'a, K: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>(
&mut self,
keys: &'a [K],
ids: &'a [ID],
options: &'a StreamReadOptions
) -> RedisResult<RV>
fn xread_options<'a, K: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>( &mut self, keys: &'a [K], ids: &'a [ID], options: &'a StreamReadOptions ) -> RedisResult<RV>
streams
only.source§fn xrevrange<'a, K: ToRedisArgs, E: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
end: E,
start: S
) -> RedisResult<RV>
fn xrevrange<'a, K: ToRedisArgs, E: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, end: E, start: S ) -> RedisResult<RV>
streams
only.source§fn xrevrange_all<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn xrevrange_all<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn xrevrange_count<'a, K: ToRedisArgs, E: ToRedisArgs, S: ToRedisArgs, C: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
end: E,
start: S,
count: C
) -> RedisResult<RV>
fn xrevrange_count<'a, K: ToRedisArgs, E: ToRedisArgs, S: ToRedisArgs, C: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, end: E, start: S, count: C ) -> RedisResult<RV>
streams
only.source§fn xtrim<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
maxlen: StreamMaxlen
) -> RedisResult<RV>
fn xtrim<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, maxlen: StreamMaxlen ) -> RedisResult<RV>
streams
only.key
to a MAXLEN count. Read moresource§fn scan<RV: FromRedisValue>(&mut self) -> RedisResult<Iter<'_, RV>>
fn scan<RV: FromRedisValue>(&mut self) -> RedisResult<Iter<'_, RV>>
source§fn scan_match<P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
pattern: P
) -> RedisResult<Iter<'_, RV>>
fn scan_match<P: ToRedisArgs, RV: FromRedisValue>( &mut self, pattern: P ) -> RedisResult<Iter<'_, RV>>
source§fn hscan<K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<Iter<'_, RV>>
fn hscan<K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<Iter<'_, RV>>
source§fn hscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
pattern: P
) -> RedisResult<Iter<'_, RV>>
fn hscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, pattern: P ) -> RedisResult<Iter<'_, RV>>
source§fn sscan<K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<Iter<'_, RV>>
fn sscan<K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<Iter<'_, RV>>
source§fn sscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
pattern: P
) -> RedisResult<Iter<'_, RV>>
fn sscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, pattern: P ) -> RedisResult<Iter<'_, RV>>
source§fn zscan<K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<Iter<'_, RV>>
fn zscan<K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<Iter<'_, RV>>
source§fn zscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
pattern: P
) -> RedisResult<Iter<'_, RV>>
fn zscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, pattern: P ) -> RedisResult<Iter<'_, RV>>
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> JsonCommands for Twhere
T: ConnectionLike,
impl<T> JsonCommands for Twhere
T: ConnectionLike,
source§fn json_arr_append<'a, K: ToRedisArgs, P: ToRedisArgs, V: Serialize, RV: FromRedisValue>(
&mut self,
key: K,
path: P,
value: &'a V
) -> RedisResult<RV>
fn json_arr_append<'a, K: ToRedisArgs, P: ToRedisArgs, V: Serialize, RV: FromRedisValue>( &mut self, key: K, path: P, value: &'a V ) -> RedisResult<RV>
json
only.value
to the array at path
after the last element in it.source§fn json_arr_index<'a, K: ToRedisArgs, P: ToRedisArgs, V: Serialize, RV: FromRedisValue>(
&mut self,
key: K,
path: P,
value: &'a V
) -> RedisResult<RV>
fn json_arr_index<'a, K: ToRedisArgs, P: ToRedisArgs, V: Serialize, RV: FromRedisValue>( &mut self, key: K, path: P, value: &'a V ) -> RedisResult<RV>
json
only.path
, returns first occurance of value
source§fn json_arr_index_ss<'a, K: ToRedisArgs, P: ToRedisArgs, V: Serialize, RV: FromRedisValue>(
&mut self,
key: K,
path: P,
value: &'a V,
start: &'a isize,
stop: &'a isize
) -> RedisResult<RV>
fn json_arr_index_ss<'a, K: ToRedisArgs, P: ToRedisArgs, V: Serialize, RV: FromRedisValue>( &mut self, key: K, path: P, value: &'a V, start: &'a isize, stop: &'a isize ) -> RedisResult<RV>
json
only.json_arr_index
except takes a start
and a stop
value, setting these to 0
will mean
they make no effect on the query Read moresource§fn json_arr_insert<'a, K: ToRedisArgs, P: ToRedisArgs, V: Serialize, RV: FromRedisValue>(
&mut self,
key: K,
path: P,
index: i64,
value: &'a V
) -> RedisResult<RV>
fn json_arr_insert<'a, K: ToRedisArgs, P: ToRedisArgs, V: Serialize, RV: FromRedisValue>( &mut self, key: K, path: P, index: i64, value: &'a V ) -> RedisResult<RV>
json
only.source§fn json_arr_len<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
path: P
) -> RedisResult<RV>
fn json_arr_len<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, path: P ) -> RedisResult<RV>
json
only.path
in key
.source§fn json_arr_pop<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
path: P,
index: i64
) -> RedisResult<RV>
fn json_arr_pop<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, path: P, index: i64 ) -> RedisResult<RV>
json
only.index
in the array. Read moresource§fn json_arr_trim<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
path: P,
start: i64,
stop: i64
) -> RedisResult<RV>
fn json_arr_trim<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, path: P, start: i64, stop: i64 ) -> RedisResult<RV>
json
only.source§fn json_clear<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
path: P
) -> RedisResult<RV>
fn json_clear<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, path: P ) -> RedisResult<RV>
json
only.source§fn json_del<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
path: P
) -> RedisResult<RV>
fn json_del<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, path: P ) -> RedisResult<RV>
json
only.path
.source§fn json_get<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
path: P
) -> RedisResult<RV>
fn json_get<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, path: P ) -> RedisResult<RV>
json
only.path
. Read moresource§fn json_num_incr_by<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
path: P,
value: i64
) -> RedisResult<RV>
fn json_num_incr_by<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, path: P, value: i64 ) -> RedisResult<RV>
json
only.path
by number
.source§fn json_obj_keys<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
path: P
) -> RedisResult<RV>
fn json_obj_keys<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, path: P ) -> RedisResult<RV>
json
only.path
.source§fn json_obj_len<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
path: P
) -> RedisResult<RV>
fn json_obj_len<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, path: P ) -> RedisResult<RV>
json
only.path
in key
.source§fn json_set<'a, K: ToRedisArgs, P: ToRedisArgs, V: Serialize, RV: FromRedisValue>(
&mut self,
key: K,
path: P,
value: &'a V
) -> RedisResult<RV>
fn json_set<'a, K: ToRedisArgs, P: ToRedisArgs, V: Serialize, RV: FromRedisValue>( &mut self, key: K, path: P, value: &'a V ) -> RedisResult<RV>
json
only.path
in key
.source§fn json_str_append<'a, K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
path: P,
value: V
) -> RedisResult<RV>
fn json_str_append<'a, K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, path: P, value: V ) -> RedisResult<RV>
json
only.json-string
values to the string at path
.source§fn json_str_len<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
path: P
) -> RedisResult<RV>
fn json_str_len<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, path: P ) -> RedisResult<RV>
json
only.path
in key
.source§fn json_toggle<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
path: P
) -> RedisResult<RV>
fn json_toggle<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, path: P ) -> RedisResult<RV>
json
only.boolean
value stored at path
.source§fn json_type<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
path: P
) -> RedisResult<RV>
fn json_type<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, path: P ) -> RedisResult<RV>
json
only.path
.