pub struct Connection { /* private fields */ }
Expand description
Represents a stateful redis TCP connection.
Implementations§
Source§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.
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.
Sourcepub fn set_push_sender(&mut self, sender: Sender<PushInfo>)
pub fn set_push_sender(&mut self, sender: Sender<PushInfo>)
Sets sender channel for push values.
Trait Implementations§
Source§impl ConnectionLike for Connection
impl ConnectionLike for Connection
Source§fn req_command(&mut self, cmd: &Cmd) -> RedisResult<Value>
fn req_command(&mut self, cmd: &Cmd) -> RedisResult<Value>
Sends a Cmd into the TCP socket and reads a single response from it.
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§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 expire_time<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
) -> RedisResult<RV>
fn expire_time<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ) -> RedisResult<RV>
Source§fn pexpire_time<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
) -> RedisResult<RV>
fn pexpire_time<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ) -> 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 httl<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
fields: F,
) -> RedisResult<RV>
fn httl<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, fields: F, ) -> RedisResult<RV>
Source§fn hpttl<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
fields: F,
) -> RedisResult<RV>
fn hpttl<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, fields: F, ) -> RedisResult<RV>
Source§fn hexpire<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
seconds: i64,
opt: ExpireOption,
fields: F,
) -> RedisResult<RV>
fn hexpire<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, seconds: i64, opt: ExpireOption, fields: F, ) -> RedisResult<RV>
Source§fn hexpire_at<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
ts: i64,
opt: ExpireOption,
fields: F,
) -> RedisResult<RV>
fn hexpire_at<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ts: i64, opt: ExpireOption, fields: F, ) -> RedisResult<RV>
Source§fn hexpire_time<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
fields: F,
) -> RedisResult<RV>
fn hexpire_time<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, fields: F, ) -> RedisResult<RV>
Source§fn hpersist<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
fields: F,
) -> RedisResult<RV>
fn hpersist<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, fields: F, ) -> RedisResult<RV>
Source§fn hpexpire<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
milliseconds: i64,
opt: ExpireOption,
fields: F,
) -> RedisResult<RV>
fn hpexpire<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, milliseconds: i64, opt: ExpireOption, fields: F, ) -> RedisResult<RV>
Source§fn hpexpire_at<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
ts: i64,
opt: ExpireOption,
fields: F,
) -> RedisResult<RV>
fn hpexpire_at<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ts: i64, opt: ExpireOption, fields: F, ) -> RedisResult<RV>
Source§fn hpexpire_time<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
fields: F,
) -> RedisResult<RV>
fn hpexpire_time<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, fields: 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 ping<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn ping<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
Source§fn ping_message<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
message: K,
) -> RedisResult<RV>
fn ping_message<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, message: K, ) -> 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: K,
) -> RedisResult<RV>
fn zinterstore<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: K, ) -> RedisResult<RV>
Source§fn zinterstore_min<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: K,
) -> RedisResult<RV>
fn zinterstore_min<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: K, ) -> RedisResult<RV>
Source§fn zinterstore_max<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: K,
) -> RedisResult<RV>
fn zinterstore_max<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: 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: K,
count: isize,
) -> RedisResult<RV>
fn bzmpop_max<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, timeout: f64, keys: K, count: isize, ) -> RedisResult<RV>
Source§fn zmpop_max<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
keys: K,
count: isize,
) -> RedisResult<RV>
fn zmpop_max<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, keys: K, count: isize, ) -> RedisResult<RV>
Source§fn bzmpop_min<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
timeout: f64,
keys: K,
count: isize,
) -> RedisResult<RV>
fn bzmpop_min<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, timeout: f64, keys: K, count: isize, ) -> RedisResult<RV>
Source§fn zmpop_min<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
keys: K,
count: isize,
) -> RedisResult<RV>
fn zmpop_min<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, keys: 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: K,
) -> RedisResult<RV>
fn zunionstore<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: K, ) -> RedisResult<RV>
Source§fn zunionstore_min<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: K,
) -> RedisResult<RV>
fn zunionstore_min<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: K, ) -> RedisResult<RV>
Source§fn zunionstore_max<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: K,
) -> RedisResult<RV>
fn zunionstore_max<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: 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 spublish<'a, K: ToRedisArgs, E: ToRedisArgs, RV: FromRedisValue>(
&mut self,
channel: K,
message: E,
) -> RedisResult<RV>
fn spublish<'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 client_getname<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn client_getname<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
Source§fn client_id<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn client_id<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
Source§fn client_setname<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
connection_name: K,
) -> RedisResult<RV>
fn client_setname<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, connection_name: K, ) -> RedisResult<RV>
Source§fn acl_load<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_load<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
Source§fn acl_save<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_save<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
Source§fn acl_list<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_list<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
Source§fn acl_users<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_users<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
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>
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>
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>
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>
Source§fn acl_dryrun<'a, K: ToRedisArgs, C: ToRedisArgs, A: ToRedisArgs, RV: FromRedisValue>(
&mut self,
username: K,
command: C,
args: A,
) -> RedisResult<RV>
fn acl_dryrun<'a, K: ToRedisArgs, C: ToRedisArgs, A: ToRedisArgs, RV: FromRedisValue>( &mut self, username: K, command: C, args: A, ) -> RedisResult<RV>
Source§fn acl_cat<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_cat<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
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>
Source§fn acl_genpass<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_genpass<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
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>
Source§fn acl_whoami<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_whoami<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
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>
Source§fn acl_log_reset<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_log_reset<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
Source§fn acl_help<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_help<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
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>
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>
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>
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>
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>
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>
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>
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>
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>
key
.
Use *
as the id
for the current timestamp. Read moreSource§fn xadd_options<'a, K: ToRedisArgs, ID: ToRedisArgs, I: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
id: ID,
items: I,
options: &'a StreamAddOptions,
) -> RedisResult<RV>
fn xadd_options<'a, K: ToRedisArgs, ID: ToRedisArgs, I: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, id: ID, items: I, options: &'a StreamAddOptions, ) -> RedisResult<RV>
Source§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>
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>
Source§fn xautoclaim_options<'a, K: ToRedisArgs, G: ToRedisArgs, C: ToRedisArgs, MIT: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G,
consumer: C,
min_idle_time: MIT,
start: S,
options: StreamAutoClaimOptions,
) -> RedisResult<RV>
fn xautoclaim_options<'a, K: ToRedisArgs, G: ToRedisArgs, C: ToRedisArgs, MIT: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G, consumer: C, min_idle_time: MIT, start: S, options: StreamAutoClaimOptions, ) -> RedisResult<RV>
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>
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>
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>
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>
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_createconsumer<'a, K: ToRedisArgs, G: ToRedisArgs, C: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G,
consumer: C,
) -> RedisResult<RV>
fn xgroup_createconsumer<'a, K: ToRedisArgs, G: ToRedisArgs, C: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G, consumer: C, ) -> RedisResult<RV>
consumer
explicitly (vs implicit via XREADGROUP)
for given stream `key. 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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
key
to a MAXLEN count. Read moreSource§fn xtrim_options<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
options: &'a StreamTrimOptions,
) -> RedisResult<RV>
fn xtrim_options<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, options: &'a StreamTrimOptions, ) -> RedisResult<RV>
key
with full options Read more