Struct sessions_redis::Client [−][src]
The client type.
Implementations
impl Client
[src]
The client acts as connector to the redis server. By itself it does not do much other than providing a convenient way to fetch a connection from it. In the future the plan is to provide a connection pool in the client.
When opening a client a URL in the following format should be used:
redis://host:port/db
Example usage::
let client = redis::Client::open("redis://127.0.0.1/").unwrap(); let con = client.get_connection().unwrap();
pub fn open<T>(params: T) -> Result<Client, RedisError> where
T: IntoConnectionInfo,
[src]
T: IntoConnectionInfo,
Connects to a redis server and returns a client. This does not actually open a connection yet but it does perform some basic checks on the URL that might make the operation fail.
pub fn get_connection(&self) -> Result<Connection, RedisError>
[src]
Instructs the client to actually connect to redis and returns a connection object. The connection object can be used to send commands to the server. This can fail with a variety of errors (like unreachable host) so it's important that you handle those errors.
pub fn get_connection_with_timeout(
&self,
timeout: Duration
) -> Result<Connection, RedisError>
[src]
&self,
timeout: Duration
) -> Result<Connection, RedisError>
Instructs the client to actually connect to redis with specified timeout and returns a connection object. The connection object can be used to send commands to the server. This can fail with a variety of errors (like unreachable host) so it's important that you handle those errors.
impl Client
[src]
To enable async support you need to chose one of the supported runtimes and active its
corresponding feature: tokio-comp
or async-std-comp
pub async fn get_async_connection(
&'_ self
) -> Result<Connection<Pin<Box<dyn AsyncStream + 'static + Send + Sync, Global>>>, RedisError>
[src]
&'_ self
) -> Result<Connection<Pin<Box<dyn AsyncStream + 'static + Send + Sync, Global>>>, RedisError>
Returns an async connection from the client.
pub async fn get_tokio_connection(
&'_ self
) -> Result<Connection<Pin<Box<dyn AsyncStream + 'static + Send + Sync, Global>>>, RedisError>
[src]
&'_ self
) -> Result<Connection<Pin<Box<dyn AsyncStream + 'static + Send + Sync, Global>>>, RedisError>
Returns an async connection from the client.
pub async fn get_multiplexed_async_connection(
&'_ self
) -> Result<MultiplexedConnection, RedisError>
[src]
&'_ self
) -> Result<MultiplexedConnection, RedisError>
Returns an async connection from the client.
pub async fn get_multiplexed_tokio_connection(
&'_ self
) -> Result<MultiplexedConnection, RedisError>
[src]
&'_ self
) -> Result<MultiplexedConnection, RedisError>
Returns an async multiplexed connection from the client.
A multiplexed connection can be cloned, allowing requests to be be sent concurrently on the same underlying connection (tcp/unix socket).
pub async fn create_multiplexed_tokio_connection(
&'_ self
) -> Result<(MultiplexedConnection, impl Future<Output = ()>), RedisError>
[src]
&'_ self
) -> Result<(MultiplexedConnection, impl Future<Output = ()>), RedisError>
Returns an async multiplexed connection from the client and a future which must be polled
to drive any requests submitted to it (see get_multiplexed_tokio_connection
).
A multiplexed connection can be cloned, allowing requests to be be sent concurrently on the same underlying connection (tcp/unix socket).
Trait Implementations
impl Clone for Client
[src]
impl ConnectionLike for Client
[src]
pub fn req_packed_command(&mut self, cmd: &[u8]) -> Result<Value, RedisError>
[src]
pub fn req_packed_commands(
&mut self,
cmd: &[u8],
offset: usize,
count: usize
) -> Result<Vec<Value, Global>, RedisError>
[src]
&mut self,
cmd: &[u8],
offset: usize,
count: usize
) -> Result<Vec<Value, Global>, RedisError>
pub fn get_db(&self) -> i64
[src]
pub fn check_connection(&mut self) -> bool
[src]
pub fn is_open(&self) -> bool
[src]
impl Debug for Client
[src]
Auto Trait Implementations
impl RefUnwindSafe for Client
[src]
impl Send for Client
[src]
impl Sync for Client
[src]
impl Unpin for Client
[src]
impl UnwindSafe for Client
[src]
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> Commands for T where
T: ConnectionLike,
[src]
T: ConnectionLike,
pub fn get<K, RV>(&mut self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn keys<K, RV>(&mut self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn set<K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
pub fn set_multiple<K, V, RV>(
&mut self,
items: &'a [(K, V)]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
items: &'a [(K, V)]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
pub fn set_ex<K, V, RV>(
&mut self,
key: K,
value: V,
seconds: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
value: V,
seconds: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
pub fn pset_ex<K, V, RV>(
&mut self,
key: K,
value: V,
milliseconds: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
value: V,
milliseconds: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
pub fn set_nx<K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
pub fn mset_nx<K, V, RV>(
&mut self,
items: &'a [(K, V)]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
items: &'a [(K, V)]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
pub fn getset<K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
pub fn getrange<K, RV>(
&mut self,
key: K,
from: isize,
to: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
from: isize,
to: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
pub fn setrange<K, V, RV>(
&mut self,
key: K,
offset: isize,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
offset: isize,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
pub fn del<K, RV>(&mut self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn exists<K, RV>(&mut self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn expire<K, RV>(
&mut self,
key: K,
seconds: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
seconds: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
pub fn expire_at<K, RV>(&mut self, key: K, ts: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn pexpire<K, RV>(&mut self, key: K, ms: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn pexpire_at<K, RV>(&mut self, key: K, ts: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn persist<K, RV>(&mut self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn ttl<K, RV>(&mut self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn pttl<K, RV>(&mut self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn rename<K, RV>(&mut self, key: K, new_key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn rename_nx<K, RV>(&mut self, key: K, new_key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn unlink<K, RV>(&mut self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn append<K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
pub fn incr<K, V, RV>(&mut self, key: K, delta: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
pub fn decr<K, V, RV>(&mut self, key: K, delta: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
pub fn setbit<K, RV>(
&mut self,
key: K,
offset: usize,
value: bool
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
offset: usize,
value: bool
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
pub fn getbit<K, RV>(&mut self, key: K, offset: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn bitcount<K, RV>(&mut self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn bitcount_range<K, RV>(
&mut self,
key: K,
start: usize,
end: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
start: usize,
end: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
pub fn bit_and<K, RV>(
&mut self,
dstkey: K,
srckeys: K
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
dstkey: K,
srckeys: K
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
pub fn bit_or<K, RV>(&mut self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn bit_xor<K, RV>(
&mut self,
dstkey: K,
srckeys: K
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
dstkey: K,
srckeys: K
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
pub fn bit_not<K, RV>(&mut self, dstkey: K, srckey: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn strlen<K, RV>(&mut self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn hget<K, F, RV>(&mut self, key: K, field: F) -> Result<RV, RedisError> where
K: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
pub fn hdel<K, F, RV>(&mut self, key: K, field: F) -> Result<RV, RedisError> where
K: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
pub fn hset<K, F, V, RV>(
&mut self,
key: K,
field: F,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
field: F,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
pub fn hset_nx<K, F, V, RV>(
&mut self,
key: K,
field: F,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
field: F,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
pub fn hset_multiple<K, F, V, RV>(
&mut self,
key: K,
items: &'a [(F, V)]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
items: &'a [(F, V)]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
pub fn hincr<K, F, D, RV>(
&mut self,
key: K,
field: F,
delta: D
) -> Result<RV, RedisError> where
K: ToRedisArgs,
F: ToRedisArgs,
D: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
field: F,
delta: D
) -> Result<RV, RedisError> where
K: ToRedisArgs,
F: ToRedisArgs,
D: ToRedisArgs,
RV: FromRedisValue,
pub fn hexists<K, F, RV>(&mut self, key: K, field: F) -> Result<RV, RedisError> where
K: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
pub fn hkeys<K, RV>(&mut self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn hvals<K, RV>(&mut self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn hgetall<K, RV>(&mut self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn hlen<K, RV>(&mut self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn blpop<K, RV>(&mut self, key: K, timeout: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn brpop<K, RV>(&mut self, key: K, timeout: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn brpoplpush<K, RV>(
&mut self,
srckey: K,
dstkey: K,
timeout: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
srckey: K,
dstkey: K,
timeout: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
pub fn lindex<K, RV>(&mut self, key: K, index: isize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn linsert_before<K, P, V, RV>(
&mut self,
key: K,
pivot: P,
value: V
) -> Result<RV, RedisError> where
P: ToRedisArgs,
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
pivot: P,
value: V
) -> Result<RV, RedisError> where
P: ToRedisArgs,
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
pub fn linsert_after<K, P, V, RV>(
&mut self,
key: K,
pivot: P,
value: V
) -> Result<RV, RedisError> where
P: ToRedisArgs,
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
pivot: P,
value: V
) -> Result<RV, RedisError> where
P: ToRedisArgs,
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
pub fn llen<K, RV>(&mut self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn lpop<K, RV>(&mut self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn lpos<K, V, RV>(
&mut self,
key: K,
value: V,
options: LposOptions
) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
value: V,
options: LposOptions
) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
pub fn lpush<K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
pub fn lpush_exists<K, V, RV>(
&mut self,
key: K,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
pub fn lrange<K, RV>(
&mut self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
pub fn lrem<K, V, RV>(
&mut self,
key: K,
count: isize,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
count: isize,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
pub fn ltrim<K, RV>(
&mut self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
pub fn lset<K, V, RV>(
&mut self,
key: K,
index: isize,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
index: isize,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
pub fn rpop<K, RV>(&mut self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn rpoplpush<K, RV>(&mut self, key: K, dstkey: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn rpush<K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
pub fn rpush_exists<K, V, RV>(
&mut self,
key: K,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
pub fn sadd<K, M, RV>(&mut self, key: K, member: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
pub fn scard<K, RV>(&mut self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn sdiff<K, RV>(&mut self, keys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn sdiffstore<K, RV>(
&mut self,
dstkey: K,
keys: K
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
dstkey: K,
keys: K
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
pub fn sinter<K, RV>(&mut self, keys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn sinterstore<K, RV>(
&mut self,
dstkey: K,
keys: K
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
dstkey: K,
keys: K
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
pub fn sismember<K, M, RV>(
&mut self,
key: K,
member: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
member: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
pub fn smembers<K, RV>(&mut self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn smove<K, M, RV>(
&mut self,
srckey: K,
dstkey: K,
member: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
srckey: K,
dstkey: K,
member: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
pub fn spop<K, RV>(&mut self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn srandmember<K, RV>(&mut self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn srandmember_multiple<K, RV>(
&mut self,
key: K,
count: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
count: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
pub fn srem<K, M, RV>(&mut self, key: K, member: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
pub fn sunion<K, RV>(&mut self, keys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn sunionstore<K, RV>(
&mut self,
dstkey: K,
keys: K
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
dstkey: K,
keys: K
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
pub fn zadd<K, S, M, RV>(
&mut self,
key: K,
member: M,
score: S
) -> Result<RV, RedisError> where
S: ToRedisArgs,
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
member: M,
score: S
) -> Result<RV, RedisError> where
S: ToRedisArgs,
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
pub fn zadd_multiple<K, S, M, RV>(
&mut self,
key: K,
items: &'a [(S, M)]
) -> Result<RV, RedisError> where
S: ToRedisArgs,
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
items: &'a [(S, M)]
) -> Result<RV, RedisError> where
S: ToRedisArgs,
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
pub fn zcard<K, RV>(&mut self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn zcount<K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
MM: ToRedisArgs,
[src]
&mut self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
MM: ToRedisArgs,
pub fn zincr<K, M, D, RV>(
&mut self,
key: K,
member: M,
delta: D
) -> Result<RV, RedisError> where
K: ToRedisArgs,
D: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
member: M,
delta: D
) -> Result<RV, RedisError> where
K: ToRedisArgs,
D: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
pub fn zinterstore<K, RV>(
&mut self,
dstkey: K,
keys: &'a [K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
dstkey: K,
keys: &'a [K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
pub fn zinterstore_min<K, RV>(
&mut self,
dstkey: K,
keys: &'a [K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
dstkey: K,
keys: &'a [K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
pub fn zinterstore_max<K, RV>(
&mut self,
dstkey: K,
keys: &'a [K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
dstkey: K,
keys: &'a [K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
pub fn zlexcount<K, L, RV>(
&mut self,
key: K,
min: L,
max: L
) -> Result<RV, RedisError> where
K: ToRedisArgs,
L: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
min: L,
max: L
) -> Result<RV, RedisError> where
K: ToRedisArgs,
L: ToRedisArgs,
RV: FromRedisValue,
pub fn zpopmax<K, RV>(&mut self, key: K, count: isize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn zpopmin<K, RV>(&mut self, key: K, count: isize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn zrange<K, RV>(
&mut self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
pub fn zrange_withscores<K, RV>(
&mut self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
pub fn zrangebylex<K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
MM: ToRedisArgs,
[src]
&mut self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
MM: ToRedisArgs,
pub fn zrangebylex_limit<K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
MM: ToRedisArgs,
[src]
&mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
MM: ToRedisArgs,
pub fn zrevrangebylex<K, MM, M, RV>(
&mut self,
key: K,
max: MM,
min: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
MM: ToRedisArgs,
[src]
&mut self,
key: K,
max: MM,
min: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
MM: ToRedisArgs,
pub fn zrevrangebylex_limit<K, MM, M, RV>(
&mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
MM: ToRedisArgs,
[src]
&mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
MM: ToRedisArgs,
pub fn zrangebyscore<K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
MM: ToRedisArgs,
[src]
&mut self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
MM: ToRedisArgs,
pub fn zrangebyscore_withscores<K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
MM: ToRedisArgs,
[src]
&mut self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
MM: ToRedisArgs,
pub fn zrangebyscore_limit<K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
MM: ToRedisArgs,
[src]
&mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
MM: ToRedisArgs,
pub fn zrangebyscore_limit_withscores<K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
MM: ToRedisArgs,
[src]
&mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
MM: ToRedisArgs,
pub fn zrank<K, M, RV>(&mut self, key: K, member: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
pub fn zrem<K, M, RV>(&mut self, key: K, members: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
pub fn zrembylex<K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
MM: ToRedisArgs,
[src]
&mut self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
MM: ToRedisArgs,
pub fn zremrangebyrank<K, RV>(
&mut self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
pub fn zrembyscore<K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
MM: ToRedisArgs,
[src]
&mut self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
MM: ToRedisArgs,
pub fn zrevrange<K, RV>(
&mut self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
pub fn zrevrange_withscores<K, RV>(
&mut self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
pub fn zrevrangebyscore<K, MM, M, RV>(
&mut self,
key: K,
max: MM,
min: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
MM: ToRedisArgs,
[src]
&mut self,
key: K,
max: MM,
min: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
MM: ToRedisArgs,
pub fn zrevrangebyscore_withscores<K, MM, M, RV>(
&mut self,
key: K,
max: MM,
min: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
MM: ToRedisArgs,
[src]
&mut self,
key: K,
max: MM,
min: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
MM: ToRedisArgs,
pub fn zrevrangebyscore_limit<K, MM, M, RV>(
&mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
MM: ToRedisArgs,
[src]
&mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
MM: ToRedisArgs,
pub fn zrevrangebyscore_limit_withscores<K, MM, M, RV>(
&mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
MM: ToRedisArgs,
[src]
&mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
MM: ToRedisArgs,
pub fn zrevrank<K, M, RV>(
&mut self,
key: K,
member: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
member: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
pub fn zscore<K, M, RV>(&mut self, key: K, member: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
pub fn zunionstore<K, RV>(
&mut self,
dstkey: K,
keys: &'a [K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
dstkey: K,
keys: &'a [K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
pub fn zunionstore_min<K, RV>(
&mut self,
dstkey: K,
keys: &'a [K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
dstkey: K,
keys: &'a [K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
pub fn zunionstore_max<K, RV>(
&mut self,
dstkey: K,
keys: &'a [K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
dstkey: K,
keys: &'a [K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
pub fn pfadd<K, E, RV>(&mut self, key: K, element: E) -> Result<RV, RedisError> where
E: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
[src]
E: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
pub fn pfcount<K, RV>(&mut self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn pfmerge<K, RV>(
&mut self,
dstkey: K,
srckeys: K
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
dstkey: K,
srckeys: K
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
pub fn publish<K, E, RV>(
&mut self,
channel: K,
message: E
) -> Result<RV, RedisError> where
E: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
channel: K,
message: E
) -> Result<RV, RedisError> where
E: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
pub fn acl_load<RV>(&mut self) -> Result<RV, RedisError> where
RV: FromRedisValue,
[src]
RV: FromRedisValue,
pub fn acl_save<RV>(&mut self) -> Result<RV, RedisError> where
RV: FromRedisValue,
[src]
RV: FromRedisValue,
pub fn acl_list<RV>(&mut self) -> Result<RV, RedisError> where
RV: FromRedisValue,
[src]
RV: FromRedisValue,
pub fn acl_users<RV>(&mut self) -> Result<RV, RedisError> where
RV: FromRedisValue,
[src]
RV: FromRedisValue,
pub fn acl_getuser<K, RV>(&mut self, username: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn acl_setuser<K, RV>(&mut self, username: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn acl_setuser_rules<K, RV>(
&mut self,
username: K,
rules: &'a [Rule]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
username: K,
rules: &'a [Rule]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
pub fn acl_deluser<K, RV>(
&mut self,
usernames: &'a [K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
usernames: &'a [K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
pub fn acl_cat<RV>(&mut self) -> Result<RV, RedisError> where
RV: FromRedisValue,
[src]
RV: FromRedisValue,
pub fn acl_cat_categoryname<K, RV>(
&mut self,
categoryname: K
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
categoryname: K
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
pub fn acl_genpass<RV>(&mut self) -> Result<RV, RedisError> where
RV: FromRedisValue,
[src]
RV: FromRedisValue,
pub fn acl_genpass_bits<RV>(&mut self, bits: isize) -> Result<RV, RedisError> where
RV: FromRedisValue,
[src]
RV: FromRedisValue,
pub fn acl_whoami<RV>(&mut self) -> Result<RV, RedisError> where
RV: FromRedisValue,
[src]
RV: FromRedisValue,
pub fn acl_log<RV>(&mut self, count: isize) -> Result<RV, RedisError> where
RV: FromRedisValue,
[src]
RV: FromRedisValue,
pub fn acl_log_reset<RV>(&mut self) -> Result<RV, RedisError> where
RV: FromRedisValue,
[src]
RV: FromRedisValue,
pub fn acl_help<RV>(&mut self) -> Result<RV, RedisError> where
RV: FromRedisValue,
[src]
RV: FromRedisValue,
pub fn geo_add<K, M, RV>(
&mut self,
key: K,
members: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
members: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
pub fn geo_dist<K, M1, M2, RV>(
&mut self,
key: K,
member1: M1,
member2: M2,
unit: Unit
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
M1: ToRedisArgs,
M2: ToRedisArgs,
[src]
&mut self,
key: K,
member1: M1,
member2: M2,
unit: Unit
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
M1: ToRedisArgs,
M2: ToRedisArgs,
pub fn geo_hash<K, M, RV>(
&mut self,
key: K,
members: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
members: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
pub fn geo_pos<K, M, RV>(
&mut self,
key: K,
members: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
members: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
pub fn geo_radius<K, RV>(
&mut self,
key: K,
longitude: f64,
latitude: f64,
radius: f64,
unit: Unit,
options: RadiusOptions
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
longitude: f64,
latitude: f64,
radius: f64,
unit: Unit,
options: RadiusOptions
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
pub fn geo_radius_by_member<K, M, RV>(
&mut self,
key: K,
member: M,
radius: f64,
unit: Unit,
options: RadiusOptions
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
member: M,
radius: f64,
unit: Unit,
options: RadiusOptions
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
pub fn xack<K, G, I, RV>(
&mut self,
key: K,
group: G,
ids: &'a [I]
) -> Result<RV, RedisError> where
I: ToRedisArgs,
K: ToRedisArgs,
G: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
group: G,
ids: &'a [I]
) -> Result<RV, RedisError> where
I: ToRedisArgs,
K: ToRedisArgs,
G: ToRedisArgs,
RV: FromRedisValue,
pub fn xadd<K, ID, F, V, RV>(
&mut self,
key: K,
id: ID,
items: &'a [(F, V)]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
ID: ToRedisArgs,
[src]
&mut self,
key: K,
id: ID,
items: &'a [(F, V)]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
ID: ToRedisArgs,
pub fn xadd_map<K, ID, BTM, RV>(
&mut self,
key: K,
id: ID,
map: BTM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
ID: ToRedisArgs,
BTM: ToRedisArgs,
[src]
&mut self,
key: K,
id: ID,
map: BTM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
ID: ToRedisArgs,
BTM: ToRedisArgs,
pub fn xadd_maxlen<K, ID, F, V, RV>(
&mut self,
key: K,
maxlen: StreamMaxlen,
id: ID,
items: &'a [(F, V)]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
ID: ToRedisArgs,
[src]
&mut self,
key: K,
maxlen: StreamMaxlen,
id: ID,
items: &'a [(F, V)]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
V: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
ID: ToRedisArgs,
pub fn xadd_maxlen_map<K, ID, BTM, RV>(
&mut self,
key: K,
maxlen: StreamMaxlen,
id: ID,
map: BTM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
ID: ToRedisArgs,
BTM: ToRedisArgs,
[src]
&mut self,
key: K,
maxlen: StreamMaxlen,
id: ID,
map: BTM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
ID: ToRedisArgs,
BTM: ToRedisArgs,
pub fn xclaim<K, G, C, MIT, ID, RV>(
&mut self,
key: K,
group: G,
consumer: C,
min_idle_time: MIT,
ids: &'a [ID]
) -> Result<RV, RedisError> where
C: ToRedisArgs,
K: ToRedisArgs,
G: ToRedisArgs,
RV: FromRedisValue,
ID: ToRedisArgs,
MIT: ToRedisArgs,
[src]
&mut self,
key: K,
group: G,
consumer: C,
min_idle_time: MIT,
ids: &'a [ID]
) -> Result<RV, RedisError> where
C: ToRedisArgs,
K: ToRedisArgs,
G: ToRedisArgs,
RV: FromRedisValue,
ID: ToRedisArgs,
MIT: ToRedisArgs,
pub fn xclaim_options<K, G, C, MIT, ID, RV>(
&mut self,
key: K,
group: G,
consumer: C,
min_idle_time: MIT,
ids: &'a [ID],
options: StreamClaimOptions
) -> Result<RV, RedisError> where
C: ToRedisArgs,
K: ToRedisArgs,
G: ToRedisArgs,
RV: FromRedisValue,
ID: ToRedisArgs,
MIT: ToRedisArgs,
[src]
&mut self,
key: K,
group: G,
consumer: C,
min_idle_time: MIT,
ids: &'a [ID],
options: StreamClaimOptions
) -> Result<RV, RedisError> where
C: ToRedisArgs,
K: ToRedisArgs,
G: ToRedisArgs,
RV: FromRedisValue,
ID: ToRedisArgs,
MIT: ToRedisArgs,
pub fn xdel<K, ID, RV>(
&mut self,
key: K,
ids: &'a [ID]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
ID: ToRedisArgs,
[src]
&mut self,
key: K,
ids: &'a [ID]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
ID: ToRedisArgs,
pub fn xgroup_create<K, G, ID, RV>(
&mut self,
key: K,
group: G,
id: ID
) -> Result<RV, RedisError> where
K: ToRedisArgs,
G: ToRedisArgs,
RV: FromRedisValue,
ID: ToRedisArgs,
[src]
&mut self,
key: K,
group: G,
id: ID
) -> Result<RV, RedisError> where
K: ToRedisArgs,
G: ToRedisArgs,
RV: FromRedisValue,
ID: ToRedisArgs,
pub fn xgroup_create_mkstream<K, G, ID, RV>(
&mut self,
key: K,
group: G,
id: ID
) -> Result<RV, RedisError> where
K: ToRedisArgs,
G: ToRedisArgs,
RV: FromRedisValue,
ID: ToRedisArgs,
[src]
&mut self,
key: K,
group: G,
id: ID
) -> Result<RV, RedisError> where
K: ToRedisArgs,
G: ToRedisArgs,
RV: FromRedisValue,
ID: ToRedisArgs,
pub fn xgroup_setid<K, G, ID, RV>(
&mut self,
key: K,
group: G,
id: ID
) -> Result<RV, RedisError> where
K: ToRedisArgs,
G: ToRedisArgs,
RV: FromRedisValue,
ID: ToRedisArgs,
[src]
&mut self,
key: K,
group: G,
id: ID
) -> Result<RV, RedisError> where
K: ToRedisArgs,
G: ToRedisArgs,
RV: FromRedisValue,
ID: ToRedisArgs,
pub fn xgroup_destroy<K, G, RV>(
&mut self,
key: K,
group: G
) -> Result<RV, RedisError> where
K: ToRedisArgs,
G: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
group: G
) -> Result<RV, RedisError> where
K: ToRedisArgs,
G: ToRedisArgs,
RV: FromRedisValue,
pub fn xgroup_delconsumer<K, G, C, RV>(
&mut self,
key: K,
group: G,
consumer: C
) -> Result<RV, RedisError> where
C: ToRedisArgs,
K: ToRedisArgs,
G: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
group: G,
consumer: C
) -> Result<RV, RedisError> where
C: ToRedisArgs,
K: ToRedisArgs,
G: ToRedisArgs,
RV: FromRedisValue,
pub fn xinfo_consumers<K, G, RV>(
&mut self,
key: K,
group: G
) -> Result<RV, RedisError> where
K: ToRedisArgs,
G: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
group: G
) -> Result<RV, RedisError> where
K: ToRedisArgs,
G: ToRedisArgs,
RV: FromRedisValue,
pub fn xinfo_groups<K, RV>(&mut self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn xinfo_stream<K, RV>(&mut self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn xlen<K, RV>(&mut self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn xpending<K, G, RV>(&mut self, key: K, group: G) -> Result<RV, RedisError> where
K: ToRedisArgs,
G: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
G: ToRedisArgs,
RV: FromRedisValue,
pub fn xpending_count<K, G, S, E, C, RV>(
&mut self,
key: K,
group: G,
start: S,
end: E,
count: C
) -> Result<RV, RedisError> where
C: ToRedisArgs,
E: ToRedisArgs,
S: ToRedisArgs,
K: ToRedisArgs,
G: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
group: G,
start: S,
end: E,
count: C
) -> Result<RV, RedisError> where
C: ToRedisArgs,
E: ToRedisArgs,
S: ToRedisArgs,
K: ToRedisArgs,
G: ToRedisArgs,
RV: FromRedisValue,
pub fn xpending_consumer_count<K, G, S, E, C, CN, RV>(
&mut self,
key: K,
group: G,
start: S,
end: E,
count: C,
consumer: CN
) -> Result<RV, RedisError> where
C: ToRedisArgs,
E: ToRedisArgs,
S: ToRedisArgs,
K: ToRedisArgs,
G: ToRedisArgs,
RV: FromRedisValue,
CN: ToRedisArgs,
[src]
&mut self,
key: K,
group: G,
start: S,
end: E,
count: C,
consumer: CN
) -> Result<RV, RedisError> where
C: ToRedisArgs,
E: ToRedisArgs,
S: ToRedisArgs,
K: ToRedisArgs,
G: ToRedisArgs,
RV: FromRedisValue,
CN: ToRedisArgs,
pub fn xrange<K, S, E, RV>(
&mut self,
key: K,
start: S,
end: E
) -> Result<RV, RedisError> where
E: ToRedisArgs,
S: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
start: S,
end: E
) -> Result<RV, RedisError> where
E: ToRedisArgs,
S: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
pub fn xrange_all<K, RV>(&mut self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn xrange_count<K, S, E, C, RV>(
&mut self,
key: K,
start: S,
end: E,
count: C
) -> Result<RV, RedisError> where
C: ToRedisArgs,
E: ToRedisArgs,
S: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
start: S,
end: E,
count: C
) -> Result<RV, RedisError> where
C: ToRedisArgs,
E: ToRedisArgs,
S: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
pub fn xread<K, ID, RV>(
&mut self,
keys: &'a [K],
ids: &'a [ID]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
ID: ToRedisArgs,
[src]
&mut self,
keys: &'a [K],
ids: &'a [ID]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
ID: ToRedisArgs,
pub fn xread_options<K, ID, RV>(
&mut self,
keys: &'a [K],
ids: &'a [ID],
options: StreamReadOptions
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
ID: ToRedisArgs,
[src]
&mut self,
keys: &'a [K],
ids: &'a [ID],
options: StreamReadOptions
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
ID: ToRedisArgs,
pub fn xrevrange<K, E, S, RV>(
&mut self,
key: K,
end: E,
start: S
) -> Result<RV, RedisError> where
E: ToRedisArgs,
S: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
end: E,
start: S
) -> Result<RV, RedisError> where
E: ToRedisArgs,
S: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
pub fn xrevrange_all<K, RV>(&mut self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn xrevrange_count<K, E, S, C, RV>(
&mut self,
key: K,
end: E,
start: S,
count: C
) -> Result<RV, RedisError> where
C: ToRedisArgs,
E: ToRedisArgs,
S: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
end: E,
start: S,
count: C
) -> Result<RV, RedisError> where
C: ToRedisArgs,
E: ToRedisArgs,
S: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
pub fn xtrim<K, RV>(
&mut self,
key: K,
maxlen: StreamMaxlen
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
maxlen: StreamMaxlen
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
pub fn scan<RV>(&mut self) -> Result<Iter<'_, RV>, RedisError> where
RV: FromRedisValue,
[src]
RV: FromRedisValue,
pub fn scan_match<P, RV>(
&mut self,
pattern: P
) -> Result<Iter<'_, RV>, RedisError> where
P: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
pattern: P
) -> Result<Iter<'_, RV>, RedisError> where
P: ToRedisArgs,
RV: FromRedisValue,
pub fn hscan<K, RV>(&mut self, key: K) -> Result<Iter<'_, RV>, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn hscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P
) -> Result<Iter<'_, RV>, RedisError> where
P: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
pattern: P
) -> Result<Iter<'_, RV>, RedisError> where
P: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
pub fn sscan<K, RV>(&mut self, key: K) -> Result<Iter<'_, RV>, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn sscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P
) -> Result<Iter<'_, RV>, RedisError> where
P: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
pattern: P
) -> Result<Iter<'_, RV>, RedisError> where
P: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
pub fn zscan<K, RV>(&mut self, key: K) -> Result<Iter<'_, RV>, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
K: ToRedisArgs,
RV: FromRedisValue,
pub fn zscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P
) -> Result<Iter<'_, RV>, RedisError> where
P: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
pattern: P
) -> Result<Iter<'_, RV>, RedisError> where
P: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,