Trait redis_cluster_rs::Commands [−][src]
pub trait Commands: ConnectionLike { fn get<K, RV>(&self, key: K) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn keys<K, RV>(&self, key: K) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn set<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs, { ... } fn set_multiple<K, V, RV>(&self, items: &[(K, V)]) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs, { ... } fn set_ex<K, V, RV>(
&self,
key: K,
value: V,
seconds: usize
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs, { ... } fn set_nx<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs, { ... } fn mset_nx<K, V, RV>(&self, items: &[(K, V)]) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs, { ... } fn getset<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs, { ... } fn del<K, RV>(&self, key: K) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn exists<K, RV>(&self, key: K) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn expire<K, RV>(&self, key: K, seconds: usize) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn expire_at<K, RV>(&self, key: K, ts: usize) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn pexpire<K, RV>(&self, key: K, ms: usize) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn pexpire_at<K, RV>(&self, key: K, ts: usize) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn persist<K, RV>(&self, key: K) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn ttl<K, RV>(&self, key: K) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn rename<K, RV>(&self, key: K, new_key: K) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn rename_nx<K, RV>(&self, key: K, new_key: K) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn append<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs, { ... } fn incr<K, V, RV>(&self, key: K, delta: V) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs, { ... } fn setbit<K, RV>(
&self,
key: K,
offset: usize,
value: bool
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn getbit<K, RV>(&self, key: K, offset: usize) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn bitcount<K, RV>(&self, key: K) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn bitcount_range<K, RV>(
&self,
key: K,
start: usize,
end: usize
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn bit_and<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn bit_or<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn bit_xor<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn bit_not<K, RV>(&self, dstkey: K, srckey: K) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn strlen<K, RV>(&self, key: K) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn hget<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError>
where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn hdel<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError>
where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn hset<K, F, V, RV>(
&self,
key: K,
field: F,
value: V
) -> Result<RV, RedisError>
where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs, { ... } fn hset_nx<K, F, V, RV>(
&self,
key: K,
field: F,
value: V
) -> Result<RV, RedisError>
where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs, { ... } fn hset_multiple<K, F, V, RV>(
&self,
key: K,
items: &[(F, V)]
) -> Result<RV, RedisError>
where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs, { ... } fn hincr<K, F, D, RV>(
&self,
key: K,
field: F,
delta: D
) -> Result<RV, RedisError>
where
D: ToRedisArgs,
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn hexists<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError>
where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn hkeys<K, RV>(&self, key: K) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn hvals<K, RV>(&self, key: K) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn hgetall<K, RV>(&self, key: K) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn hlen<K, RV>(&self, key: K) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn blpop<K, RV>(&self, key: K, timeout: usize) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn brpop<K, RV>(&self, key: K, timeout: usize) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn brpoplpush<K, RV>(
&self,
srckey: K,
dstkey: K,
timeout: usize
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn lindex<K, RV>(&self, key: K, index: isize) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn linsert_before<K, P, V, RV>(
&self,
key: K,
pivot: P,
value: V
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs, { ... } fn linsert_after<K, P, V, RV>(
&self,
key: K,
pivot: P,
value: V
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs, { ... } fn llen<K, RV>(&self, key: K) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn lpop<K, RV>(&self, key: K) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn lpush<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs, { ... } fn lpush_exists<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs, { ... } fn lrange<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn lrem<K, V, RV>(
&self,
key: K,
count: isize,
value: V
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs, { ... } fn ltrim<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn lset<K, V, RV>(
&self,
key: K,
index: isize,
value: V
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs, { ... } fn rpop<K, RV>(&self, key: K) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn rpoplpush<K, RV>(&self, key: K, dstkey: K) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn rpush<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs, { ... } fn rpush_exists<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs, { ... } fn sadd<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError>
where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue, { ... } fn scard<K, RV>(&self, key: K) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn sdiff<K, RV>(&self, keys: K) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn sdiffstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn sinter<K, RV>(&self, keys: K) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn sdinterstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn sismember<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError>
where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue, { ... } fn smembers<K, RV>(&self, key: K) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn smove<K, M, RV>(
&self,
srckey: K,
dstkey: K,
member: M
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue, { ... } fn spop<K, RV>(&self, key: K) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn srandmember<K, RV>(&self, key: K) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn srandmember_multiple<K, RV>(
&self,
key: K,
count: usize
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn srem<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError>
where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue, { ... } fn sunion<K, RV>(&self, keys: K) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn sunionstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn zadd<K, S, M, RV>(
&self,
key: K,
member: M,
score: S
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
S: ToRedisArgs, { ... } fn zadd_multiple<K, S, M, RV>(
&self,
key: K,
items: &[(S, M)]
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
S: ToRedisArgs, { ... } fn zcard<K, RV>(&self, key: K) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn zcount<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue, { ... } fn zincr<K, M, D, RV>(
&self,
key: K,
member: M,
delta: D
) -> Result<RV, RedisError>
where
D: ToRedisArgs,
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue, { ... } fn zinterstore<K, RV>(
&self,
dstkey: K,
keys: &[K]
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn zinterstore_min<K, RV>(
&self,
dstkey: K,
keys: &[K]
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn zinterstore_max<K, RV>(
&self,
dstkey: K,
keys: &[K]
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn zlexcount<K, L, RV>(
&self,
key: K,
min: L,
max: L
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
L: ToRedisArgs,
RV: FromRedisValue, { ... } fn zrange<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn zrange_withscores<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn zrangebylex<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue, { ... } fn zrangebylex_limit<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue, { ... } fn zrevrangebylex<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue, { ... } fn zrevrangebylex_limit<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue, { ... } fn zrangebyscore<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue, { ... } fn zrangebyscore_withscores<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue, { ... } fn zrangebyscore_limit<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue, { ... } fn zrangebyscore_limit_withscores<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue, { ... } fn zrank<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError>
where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue, { ... } fn zrem<K, M, RV>(&self, key: K, members: M) -> Result<RV, RedisError>
where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue, { ... } fn zrembylex<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue, { ... } fn zrembyrank<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn zrembyscore<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue, { ... } fn zrevrange<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn zrevrange_withscores<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn zrevrangebyscore<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue, { ... } fn zrevrangebyscore_withscores<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue, { ... } fn zrevrangebyscore_limit<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue, { ... } fn zrevrangebyscore_limit_withscores<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue, { ... } fn zrevrank<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError>
where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue, { ... } fn zscore<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError>
where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue, { ... } fn zunionstore<K, RV>(
&self,
dstkey: K,
keys: &[K]
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn zunionstore_min<K, RV>(
&self,
dstkey: K,
keys: &[K]
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn zunionstore_max<K, RV>(
&self,
dstkey: K,
keys: &[K]
) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn pfadd<K, E, RV>(&self, key: K, element: E) -> Result<RV, RedisError>
where
E: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn pfcount<K, RV>(&self, key: K) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn pfmerge<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn publish<K, E, RV>(
&self,
channel: K,
message: E
) -> Result<RV, RedisError>
where
E: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn scan<RV>(&self) -> Result<Iter<RV>, RedisError>
where
RV: FromRedisValue, { ... } fn scan_match<P, RV>(&self, pattern: P) -> Result<Iter<RV>, RedisError>
where
P: ToRedisArgs,
RV: FromRedisValue, { ... } fn hscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn hscan_match<K, P, RV>(
&self,
key: K,
pattern: P
) -> Result<Iter<RV>, RedisError>
where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue, { ... } fn sscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn sscan_match<K, P, RV>(
&self,
key: K,
pattern: P
) -> Result<Iter<RV>, RedisError>
where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue, { ... } fn zscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError>
where
K: ToRedisArgs,
RV: FromRedisValue, { ... } fn zscan_match<K, P, RV>(
&self,
key: K,
pattern: P
) -> Result<Iter<RV>, RedisError>
where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue, { ... } }
Implements common redis commands for connection like objects. This allows you to send commands straight to a connection or client. It is also implemented for redis results of clients which makes for very convenient access in some basic cases.
This allows you to use nicer syntax for some common operations. For instance this code:
let client = try!(redis::Client::open("redis://127.0.0.1/")); let con = try!(client.get_connection()); redis::cmd("SET").arg("my_key").arg(42).execute(&con); assert_eq!(redis::cmd("GET").arg("my_key").query(&con), Ok(42));
Will become this:
use redis::Commands; let client = try!(redis::Client::open("redis://127.0.0.1/")); let con = try!(client.get_connection()); assert_eq!(con.get("my_key"), Ok(42));
Provided Methods
fn get<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Get the value of a key. If key is a vec this becomes an MGET
.
fn keys<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Gets all keys matching pattern
fn set<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
Set the string value of a key.
fn set_multiple<K, V, RV>(&self, items: &[(K, V)]) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
Sets multiple keys to their values.
fn set_ex<K, V, RV>(
&self,
key: K,
value: V,
seconds: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
&self,
key: K,
value: V,
seconds: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
Set the value and expiration of a key.
fn set_nx<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
Set the value of a key, only if the key does not exist
fn mset_nx<K, V, RV>(&self, items: &[(K, V)]) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
Sets multiple keys to their values failing if at least one already exists.
fn getset<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
Set the string value of a key and return its old value.
fn del<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Delete one or more keys.
fn exists<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Determine if a key exists.
fn expire<K, RV>(&self, key: K, seconds: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Set a key's time to live in seconds.
fn expire_at<K, RV>(&self, key: K, ts: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Set the expiration for a key as a UNIX timestamp.
fn pexpire<K, RV>(&self, key: K, ms: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Set a key's time to live in milliseconds.
fn pexpire_at<K, RV>(&self, key: K, ts: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Set the expiration for a key as a UNIX timestamp in milliseconds.
fn persist<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Remove the expiration from a key.
fn ttl<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Check the expiration time of a key.
fn rename<K, RV>(&self, key: K, new_key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Rename a key.
fn rename_nx<K, RV>(&self, key: K, new_key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Rename a key, only if the new key does not exist.
fn append<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
Append a value to a key.
fn incr<K, V, RV>(&self, key: K, delta: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
Increment the numeric value of a key by the given amount. This
issues a INCRBY
or INCRBYFLOAT
depending on the type.
fn setbit<K, RV>(
&self,
key: K,
offset: usize,
value: bool
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
&self,
key: K,
offset: usize,
value: bool
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
Sets or clears the bit at offset in the string value stored at key.
fn getbit<K, RV>(&self, key: K, offset: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Returns the bit value at offset in the string value stored at key.
fn bitcount<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Count set bits in a string.
fn bitcount_range<K, RV>(
&self,
key: K,
start: usize,
end: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
&self,
key: K,
start: usize,
end: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
Count set bits in a string in a range.
fn bit_and<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Perform a bitwise AND between multiple keys (containing string values) and store the result in the destination key.
fn bit_or<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Perform a bitwise OR between multiple keys (containing string values) and store the result in the destination key.
fn bit_xor<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Perform a bitwise XOR between multiple keys (containing string values) and store the result in the destination key.
fn bit_not<K, RV>(&self, dstkey: K, srckey: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Perform a bitwise NOT of the key (containing string values) and store the result in the destination key.
fn strlen<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Get the length of the value stored in a key.
fn hget<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError> where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
Gets a single (or multiple) fields from a hash.
fn hdel<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError> where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
Deletes a single (or multiple) fields from a hash.
fn hset<K, F, V, RV>(
&self,
key: K,
field: F,
value: V
) -> Result<RV, RedisError> where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
&self,
key: K,
field: F,
value: V
) -> Result<RV, RedisError> where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
Sets a single field in a hash.
fn hset_nx<K, F, V, RV>(
&self,
key: K,
field: F,
value: V
) -> Result<RV, RedisError> where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
&self,
key: K,
field: F,
value: V
) -> Result<RV, RedisError> where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
Sets a single field in a hash if it does not exist.
fn hset_multiple<K, F, V, RV>(
&self,
key: K,
items: &[(F, V)]
) -> Result<RV, RedisError> where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
&self,
key: K,
items: &[(F, V)]
) -> Result<RV, RedisError> where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
Sets a multiple fields in a hash.
fn hincr<K, F, D, RV>(
&self,
key: K,
field: F,
delta: D
) -> Result<RV, RedisError> where
D: ToRedisArgs,
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
&self,
key: K,
field: F,
delta: D
) -> Result<RV, RedisError> where
D: ToRedisArgs,
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
Increments a value.
fn hexists<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError> where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
Checks if a field in a hash exists.
fn hkeys<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Gets all the keys in a hash.
fn hvals<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Gets all the values in a hash.
fn hgetall<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Gets all the fields and values in a hash.
fn hlen<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Gets the length of a hash.
fn blpop<K, RV>(&self, key: K, timeout: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Remove and get the first element in a list, or block until one is available.
fn brpop<K, RV>(&self, key: K, timeout: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Remove and get the last element in a list, or block until one is available.
fn brpoplpush<K, RV>(
&self,
srckey: K,
dstkey: K,
timeout: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
&self,
srckey: K,
dstkey: K,
timeout: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
Pop a value from a list, push it to another list and return it; or block until one is available.
fn lindex<K, RV>(&self, key: K, index: isize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Get an element from a list by its index.
fn linsert_before<K, P, V, RV>(
&self,
key: K,
pivot: P,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
&self,
key: K,
pivot: P,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
Insert an element before another element in a list.
fn linsert_after<K, P, V, RV>(
&self,
key: K,
pivot: P,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
&self,
key: K,
pivot: P,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
Insert an element after another element in a list.
fn llen<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Returns the length of the list stored at key.
fn lpop<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Removes and returns the first element of the list stored at key.
fn lpush<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
Insert all the specified values at the head of the list stored at key.
fn lpush_exists<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
Inserts a value at the head of the list stored at key, only if key already exists and holds a list.
fn lrange<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
Returns the specified elements of the list stored at key.
fn lrem<K, V, RV>(
&self,
key: K,
count: isize,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
&self,
key: K,
count: isize,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
Removes the first count occurrences of elements equal to value from the list stored at key.
fn ltrim<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
Trim an existing list so that it will contain only the specified range of elements specified.
fn lset<K, V, RV>(
&self,
key: K,
index: isize,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
&self,
key: K,
index: isize,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
Sets the list element at index to value
fn rpop<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Removes and returns the last element of the list stored at key.
fn rpoplpush<K, RV>(&self, key: K, dstkey: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Pop a value from a list, push it to another list and return it.
fn rpush<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
Insert all the specified values at the tail of the list stored at key.
fn rpush_exists<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
Inserts value at the tail of the list stored at key, only if key already exists and holds a list.
fn sadd<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
Add one or more members to a set.
fn scard<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Get the number of members in a set.
fn sdiff<K, RV>(&self, keys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Subtract multiple sets.
fn sdiffstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Subtract multiple sets and store the resulting set in a key.
fn sinter<K, RV>(&self, keys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Intersect multiple sets.
fn sdinterstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Intersect multiple sets and store the resulting set in a key.
fn sismember<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
Determine if a given value is a member of a set.
fn smembers<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Get all the members in a set.
fn smove<K, M, RV>(
&self,
srckey: K,
dstkey: K,
member: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
&self,
srckey: K,
dstkey: K,
member: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
Move a member from one set to another.
fn spop<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Remove and return a random member from a set.
fn srandmember<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Get one random member from a set.
fn srandmember_multiple<K, RV>(
&self,
key: K,
count: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
&self,
key: K,
count: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
Get multiple random members from a set.
fn srem<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
Remove one or more members from a set.
fn sunion<K, RV>(&self, keys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Add multiple sets.
fn sunionstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Add multiple sets and store the resulting set in a key.
fn zadd<K, S, M, RV>(
&self,
key: K,
member: M,
score: S
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
S: ToRedisArgs,
&self,
key: K,
member: M,
score: S
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
S: ToRedisArgs,
Add one member to a sorted set, or update its score if it already exists.
fn zadd_multiple<K, S, M, RV>(
&self,
key: K,
items: &[(S, M)]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
S: ToRedisArgs,
&self,
key: K,
items: &[(S, M)]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
S: ToRedisArgs,
Add multiple members to a sorted set, or update its score if it already exists.
fn zcard<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Get the number of members in a sorted set.
fn zcount<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
Count the members in a sorted set with scores within the given values.
fn zincr<K, M, D, RV>(
&self,
key: K,
member: M,
delta: D
) -> Result<RV, RedisError> where
D: ToRedisArgs,
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
&self,
key: K,
member: M,
delta: D
) -> Result<RV, RedisError> where
D: ToRedisArgs,
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
Increments the member in a sorted set at key by delta. If the member does not exist, it is added with delta as its score.
fn zinterstore<K, RV>(&self, dstkey: K, keys: &[K]) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Intersect multiple sorted sets and store the resulting sorted set in a new key using SUM as aggregation function.
fn zinterstore_min<K, RV>(
&self,
dstkey: K,
keys: &[K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
&self,
dstkey: K,
keys: &[K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
Intersect multiple sorted sets and store the resulting sorted set in a new key using MIN as aggregation function.
fn zinterstore_max<K, RV>(
&self,
dstkey: K,
keys: &[K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
&self,
dstkey: K,
keys: &[K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
Intersect multiple sorted sets and store the resulting sorted set in a new key using MAX as aggregation function.
fn zlexcount<K, L, RV>(&self, key: K, min: L, max: L) -> Result<RV, RedisError> where
K: ToRedisArgs,
L: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
L: ToRedisArgs,
RV: FromRedisValue,
Count the number of members in a sorted set between a given lexicographical range.
fn zrange<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
Return a range of members in a sorted set, by index
fn zrange_withscores<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
Return a range of members in a sorted set, by index with scores.
fn zrangebylex<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
Return a range of members in a sorted set, by lexicographical range.
fn zrangebylex_limit<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
&self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
Return a range of members in a sorted set, by lexicographical range with offset and limit.
fn zrevrangebylex<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
&self,
key: K,
max: MM,
min: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
Return a range of members in a sorted set, by lexicographical range.
fn zrevrangebylex_limit<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
&self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
Return a range of members in a sorted set, by lexicographical range with offset and limit.
fn zrangebyscore<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
Return a range of members in a sorted set, by score.
fn zrangebyscore_withscores<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
Return a range of members in a sorted set, by score with scores.
fn zrangebyscore_limit<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
&self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
Return a range of members in a sorted set, by score with limit.
fn zrangebyscore_limit_withscores<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
&self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
Return a range of members in a sorted set, by score with limit with scores.
fn zrank<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
Determine the index of a member in a sorted set.
fn zrem<K, M, RV>(&self, key: K, members: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
Remove one or more members from a sorted set.
fn zrembylex<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
Remove all members in a sorted set between the given lexicographical range.
fn zrembyrank<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
Remove all members in a sorted set within the given indexes.
fn zrembyscore<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
Remove all members in a sorted set within the given scores.
fn zrevrange<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
Return a range of members in a sorted set, by index, with scores ordered from high to low.
fn zrevrange_withscores<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
Return a range of members in a sorted set, by index, with scores ordered from high to low.
fn zrevrangebyscore<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
&self,
key: K,
max: MM,
min: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
Return a range of members in a sorted set, by score.
fn zrevrangebyscore_withscores<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
&self,
key: K,
max: MM,
min: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
Return a range of members in a sorted set, by score with scores.
fn zrevrangebyscore_limit<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
&self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
Return a range of members in a sorted set, by score with limit.
fn zrevrangebyscore_limit_withscores<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
&self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
Return a range of members in a sorted set, by score with limit with scores.
fn zrevrank<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
Determine the index of a member in a sorted set, with scores ordered from high to low.
fn zscore<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
Get the score associated with the given member in a sorted set.
fn zunionstore<K, RV>(&self, dstkey: K, keys: &[K]) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Unions multiple sorted sets and store the resulting sorted set in a new key using SUM as aggregation function.
fn zunionstore_min<K, RV>(
&self,
dstkey: K,
keys: &[K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
&self,
dstkey: K,
keys: &[K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
Unions multiple sorted sets and store the resulting sorted set in a new key using MIN as aggregation function.
fn zunionstore_max<K, RV>(
&self,
dstkey: K,
keys: &[K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
&self,
dstkey: K,
keys: &[K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
Unions multiple sorted sets and store the resulting sorted set in a new key using MAX as aggregation function.
fn pfadd<K, E, RV>(&self, key: K, element: E) -> Result<RV, RedisError> where
E: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
E: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
Adds the specified elements to the specified HyperLogLog.
fn pfcount<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
fn pfmerge<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Merge N different HyperLogLogs into a single one.
fn publish<K, E, RV>(&self, channel: K, message: E) -> Result<RV, RedisError> where
E: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
E: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
Posts a message to the given channel.
fn scan<RV>(&self) -> Result<Iter<RV>, RedisError> where
RV: FromRedisValue,
RV: FromRedisValue,
Incrementally iterate the keys space.
fn scan_match<P, RV>(&self, pattern: P) -> Result<Iter<RV>, RedisError> where
P: ToRedisArgs,
RV: FromRedisValue,
P: ToRedisArgs,
RV: FromRedisValue,
Incrementally iterate the keys space for keys matching a pattern.
fn hscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Incrementally iterate hash fields and associated values.
fn hscan_match<K, P, RV>(
&self,
key: K,
pattern: P
) -> Result<Iter<RV>, RedisError> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
&self,
key: K,
pattern: P
) -> Result<Iter<RV>, RedisError> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
Incrementally iterate hash fields and associated values for field names matching a pattern.
fn sscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Incrementally iterate set elements.
fn sscan_match<K, P, RV>(
&self,
key: K,
pattern: P
) -> Result<Iter<RV>, RedisError> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
&self,
key: K,
pattern: P
) -> Result<Iter<RV>, RedisError> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
Incrementally iterate set elements for elements matching a pattern.
fn zscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
K: ToRedisArgs,
RV: FromRedisValue,
Incrementally iterate sorted set elements.
fn zscan_match<K, P, RV>(
&self,
key: K,
pattern: P
) -> Result<Iter<RV>, RedisError> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
&self,
key: K,
pattern: P
) -> Result<Iter<RV>, RedisError> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
Incrementally iterate sorted set elements for elements matching a pattern.
Implementations on Foreign Types
impl Commands for Client
[src]
impl Commands for Client
fn get<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn get<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn keys<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn keys<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn set<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn set<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn set_multiple<K, V, RV>(&self, items: &[(K, V)]) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn set_multiple<K, V, RV>(&self, items: &[(K, V)]) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn set_ex<K, V, RV>(
&self,
key: K,
value: V,
seconds: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn set_ex<K, V, RV>(
&self,
key: K,
value: V,
seconds: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn set_nx<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn set_nx<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn mset_nx<K, V, RV>(&self, items: &[(K, V)]) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn mset_nx<K, V, RV>(&self, items: &[(K, V)]) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn getset<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn getset<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn del<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn del<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn exists<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn exists<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn expire<K, RV>(&self, key: K, seconds: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn expire<K, RV>(&self, key: K, seconds: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn expire_at<K, RV>(&self, key: K, ts: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn expire_at<K, RV>(&self, key: K, ts: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn pexpire<K, RV>(&self, key: K, ms: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn pexpire<K, RV>(&self, key: K, ms: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn pexpire_at<K, RV>(&self, key: K, ts: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn pexpire_at<K, RV>(&self, key: K, ts: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn persist<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn persist<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn ttl<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn ttl<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn rename<K, RV>(&self, key: K, new_key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn rename<K, RV>(&self, key: K, new_key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn rename_nx<K, RV>(&self, key: K, new_key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn rename_nx<K, RV>(&self, key: K, new_key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn append<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn append<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn incr<K, V, RV>(&self, key: K, delta: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn incr<K, V, RV>(&self, key: K, delta: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn setbit<K, RV>(
&self,
key: K,
offset: usize,
value: bool
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn setbit<K, RV>(
&self,
key: K,
offset: usize,
value: bool
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn getbit<K, RV>(&self, key: K, offset: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn getbit<K, RV>(&self, key: K, offset: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn bitcount<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn bitcount<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn bitcount_range<K, RV>(
&self,
key: K,
start: usize,
end: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn bitcount_range<K, RV>(
&self,
key: K,
start: usize,
end: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn bit_and<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn bit_and<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn bit_or<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn bit_or<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn bit_xor<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn bit_xor<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn bit_not<K, RV>(&self, dstkey: K, srckey: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn bit_not<K, RV>(&self, dstkey: K, srckey: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn strlen<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn strlen<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn hget<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError> where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn hget<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError> where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
fn hdel<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError> where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn hdel<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError> where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
fn hset<K, F, V, RV>(
&self,
key: K,
field: F,
value: V
) -> Result<RV, RedisError> where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn hset<K, F, V, RV>(
&self,
key: K,
field: F,
value: V
) -> Result<RV, RedisError> where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn hset_nx<K, F, V, RV>(
&self,
key: K,
field: F,
value: V
) -> Result<RV, RedisError> where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn hset_nx<K, F, V, RV>(
&self,
key: K,
field: F,
value: V
) -> Result<RV, RedisError> where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn hset_multiple<K, F, V, RV>(
&self,
key: K,
items: &[(F, V)]
) -> Result<RV, RedisError> where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn hset_multiple<K, F, V, RV>(
&self,
key: K,
items: &[(F, V)]
) -> Result<RV, RedisError> where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn hincr<K, F, D, RV>(
&self,
key: K,
field: F,
delta: D
) -> Result<RV, RedisError> where
D: ToRedisArgs,
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn hincr<K, F, D, RV>(
&self,
key: K,
field: F,
delta: D
) -> Result<RV, RedisError> where
D: ToRedisArgs,
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
fn hexists<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError> where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn hexists<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError> where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
fn hkeys<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn hkeys<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn hvals<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn hvals<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn hgetall<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn hgetall<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn hlen<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn hlen<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn blpop<K, RV>(&self, key: K, timeout: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn blpop<K, RV>(&self, key: K, timeout: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn brpop<K, RV>(&self, key: K, timeout: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn brpop<K, RV>(&self, key: K, timeout: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn brpoplpush<K, RV>(
&self,
srckey: K,
dstkey: K,
timeout: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn brpoplpush<K, RV>(
&self,
srckey: K,
dstkey: K,
timeout: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn lindex<K, RV>(&self, key: K, index: isize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn lindex<K, RV>(&self, key: K, index: isize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn linsert_before<K, P, V, RV>(
&self,
key: K,
pivot: P,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn linsert_before<K, P, V, RV>(
&self,
key: K,
pivot: P,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn linsert_after<K, P, V, RV>(
&self,
key: K,
pivot: P,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn linsert_after<K, P, V, RV>(
&self,
key: K,
pivot: P,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn llen<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn llen<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn lpop<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn lpop<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn lpush<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn lpush<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn lpush_exists<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn lpush_exists<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn lrange<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn lrange<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn lrem<K, V, RV>(
&self,
key: K,
count: isize,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn lrem<K, V, RV>(
&self,
key: K,
count: isize,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn ltrim<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn ltrim<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn lset<K, V, RV>(
&self,
key: K,
index: isize,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn lset<K, V, RV>(
&self,
key: K,
index: isize,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn rpop<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn rpop<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn rpoplpush<K, RV>(&self, key: K, dstkey: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn rpoplpush<K, RV>(&self, key: K, dstkey: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn rpush<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn rpush<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn rpush_exists<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn rpush_exists<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn sadd<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
[src]
fn sadd<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn scard<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn scard<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn sdiff<K, RV>(&self, keys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn sdiff<K, RV>(&self, keys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn sdiffstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn sdiffstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn sinter<K, RV>(&self, keys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn sinter<K, RV>(&self, keys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn sdinterstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn sdinterstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn sismember<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
[src]
fn sismember<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn smembers<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn smembers<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn smove<K, M, RV>(
&self,
srckey: K,
dstkey: K,
member: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
[src]
fn smove<K, M, RV>(
&self,
srckey: K,
dstkey: K,
member: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn spop<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn spop<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn srandmember<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn srandmember<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn srandmember_multiple<K, RV>(
&self,
key: K,
count: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn srandmember_multiple<K, RV>(
&self,
key: K,
count: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn srem<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
[src]
fn srem<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn sunion<K, RV>(&self, keys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn sunion<K, RV>(&self, keys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn sunionstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn sunionstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn zadd<K, S, M, RV>(
&self,
key: K,
member: M,
score: S
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
S: ToRedisArgs,
[src]
fn zadd<K, S, M, RV>(
&self,
key: K,
member: M,
score: S
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
S: ToRedisArgs,
fn zadd_multiple<K, S, M, RV>(
&self,
key: K,
items: &[(S, M)]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
S: ToRedisArgs,
[src]
fn zadd_multiple<K, S, M, RV>(
&self,
key: K,
items: &[(S, M)]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
S: ToRedisArgs,
fn zcard<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zcard<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn zcount<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zcount<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zincr<K, M, D, RV>(
&self,
key: K,
member: M,
delta: D
) -> Result<RV, RedisError> where
D: ToRedisArgs,
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zincr<K, M, D, RV>(
&self,
key: K,
member: M,
delta: D
) -> Result<RV, RedisError> where
D: ToRedisArgs,
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn zinterstore<K, RV>(&self, dstkey: K, keys: &[K]) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zinterstore<K, RV>(&self, dstkey: K, keys: &[K]) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn zinterstore_min<K, RV>(
&self,
dstkey: K,
keys: &[K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zinterstore_min<K, RV>(
&self,
dstkey: K,
keys: &[K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn zinterstore_max<K, RV>(
&self,
dstkey: K,
keys: &[K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zinterstore_max<K, RV>(
&self,
dstkey: K,
keys: &[K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn zlexcount<K, L, RV>(&self, key: K, min: L, max: L) -> Result<RV, RedisError> where
K: ToRedisArgs,
L: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zlexcount<K, L, RV>(&self, key: K, min: L, max: L) -> Result<RV, RedisError> where
K: ToRedisArgs,
L: ToRedisArgs,
RV: FromRedisValue,
fn zrange<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrange<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn zrange_withscores<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrange_withscores<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn zrangebylex<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrangebylex<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrangebylex_limit<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrangebylex_limit<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrevrangebylex<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrevrangebylex<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrevrangebylex_limit<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrevrangebylex_limit<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrangebyscore<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrangebyscore<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrangebyscore_withscores<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrangebyscore_withscores<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrangebyscore_limit<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrangebyscore_limit<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrangebyscore_limit_withscores<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrangebyscore_limit_withscores<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrank<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrank<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn zrem<K, M, RV>(&self, key: K, members: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrem<K, M, RV>(&self, key: K, members: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn zrembylex<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrembylex<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrembyrank<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrembyrank<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn zrembyscore<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrembyscore<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrevrange<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrevrange<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn zrevrange_withscores<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrevrange_withscores<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn zrevrangebyscore<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrevrangebyscore<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrevrangebyscore_withscores<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrevrangebyscore_withscores<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrevrangebyscore_limit<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrevrangebyscore_limit<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrevrangebyscore_limit_withscores<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrevrangebyscore_limit_withscores<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrevrank<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrevrank<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn zscore<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zscore<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn zunionstore<K, RV>(&self, dstkey: K, keys: &[K]) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zunionstore<K, RV>(&self, dstkey: K, keys: &[K]) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn zunionstore_min<K, RV>(
&self,
dstkey: K,
keys: &[K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zunionstore_min<K, RV>(
&self,
dstkey: K,
keys: &[K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn zunionstore_max<K, RV>(
&self,
dstkey: K,
keys: &[K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zunionstore_max<K, RV>(
&self,
dstkey: K,
keys: &[K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn pfadd<K, E, RV>(&self, key: K, element: E) -> Result<RV, RedisError> where
E: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn pfadd<K, E, RV>(&self, key: K, element: E) -> Result<RV, RedisError> where
E: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
fn pfcount<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn pfcount<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn pfmerge<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn pfmerge<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn publish<K, E, RV>(&self, channel: K, message: E) -> Result<RV, RedisError> where
E: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn publish<K, E, RV>(&self, channel: K, message: E) -> Result<RV, RedisError> where
E: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
fn scan<RV>(&self) -> Result<Iter<RV>, RedisError> where
RV: FromRedisValue,
[src]
fn scan<RV>(&self) -> Result<Iter<RV>, RedisError> where
RV: FromRedisValue,
fn scan_match<P, RV>(&self, pattern: P) -> Result<Iter<RV>, RedisError> where
P: ToRedisArgs,
RV: FromRedisValue,
[src]
fn scan_match<P, RV>(&self, pattern: P) -> Result<Iter<RV>, RedisError> where
P: ToRedisArgs,
RV: FromRedisValue,
fn hscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn hscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn hscan_match<K, P, RV>(
&self,
key: K,
pattern: P
) -> Result<Iter<RV>, RedisError> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
[src]
fn hscan_match<K, P, RV>(
&self,
key: K,
pattern: P
) -> Result<Iter<RV>, RedisError> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
fn sscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn sscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn sscan_match<K, P, RV>(
&self,
key: K,
pattern: P
) -> Result<Iter<RV>, RedisError> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
[src]
fn sscan_match<K, P, RV>(
&self,
key: K,
pattern: P
) -> Result<Iter<RV>, RedisError> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
fn zscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn zscan_match<K, P, RV>(
&self,
key: K,
pattern: P
) -> Result<Iter<RV>, RedisError> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zscan_match<K, P, RV>(
&self,
key: K,
pattern: P
) -> Result<Iter<RV>, RedisError> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
impl Commands for Connection
[src]
impl Commands for Connection
fn get<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn get<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn keys<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn keys<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn set<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn set<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn set_multiple<K, V, RV>(&self, items: &[(K, V)]) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn set_multiple<K, V, RV>(&self, items: &[(K, V)]) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn set_ex<K, V, RV>(
&self,
key: K,
value: V,
seconds: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn set_ex<K, V, RV>(
&self,
key: K,
value: V,
seconds: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn set_nx<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn set_nx<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn mset_nx<K, V, RV>(&self, items: &[(K, V)]) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn mset_nx<K, V, RV>(&self, items: &[(K, V)]) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn getset<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn getset<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn del<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn del<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn exists<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn exists<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn expire<K, RV>(&self, key: K, seconds: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn expire<K, RV>(&self, key: K, seconds: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn expire_at<K, RV>(&self, key: K, ts: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn expire_at<K, RV>(&self, key: K, ts: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn pexpire<K, RV>(&self, key: K, ms: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn pexpire<K, RV>(&self, key: K, ms: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn pexpire_at<K, RV>(&self, key: K, ts: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn pexpire_at<K, RV>(&self, key: K, ts: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn persist<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn persist<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn ttl<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn ttl<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn rename<K, RV>(&self, key: K, new_key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn rename<K, RV>(&self, key: K, new_key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn rename_nx<K, RV>(&self, key: K, new_key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn rename_nx<K, RV>(&self, key: K, new_key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn append<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn append<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn incr<K, V, RV>(&self, key: K, delta: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn incr<K, V, RV>(&self, key: K, delta: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn setbit<K, RV>(
&self,
key: K,
offset: usize,
value: bool
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn setbit<K, RV>(
&self,
key: K,
offset: usize,
value: bool
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn getbit<K, RV>(&self, key: K, offset: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn getbit<K, RV>(&self, key: K, offset: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn bitcount<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn bitcount<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn bitcount_range<K, RV>(
&self,
key: K,
start: usize,
end: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn bitcount_range<K, RV>(
&self,
key: K,
start: usize,
end: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn bit_and<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn bit_and<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn bit_or<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn bit_or<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn bit_xor<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn bit_xor<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn bit_not<K, RV>(&self, dstkey: K, srckey: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn bit_not<K, RV>(&self, dstkey: K, srckey: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn strlen<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn strlen<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn hget<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError> where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn hget<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError> where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
fn hdel<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError> where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn hdel<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError> where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
fn hset<K, F, V, RV>(
&self,
key: K,
field: F,
value: V
) -> Result<RV, RedisError> where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn hset<K, F, V, RV>(
&self,
key: K,
field: F,
value: V
) -> Result<RV, RedisError> where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn hset_nx<K, F, V, RV>(
&self,
key: K,
field: F,
value: V
) -> Result<RV, RedisError> where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn hset_nx<K, F, V, RV>(
&self,
key: K,
field: F,
value: V
) -> Result<RV, RedisError> where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn hset_multiple<K, F, V, RV>(
&self,
key: K,
items: &[(F, V)]
) -> Result<RV, RedisError> where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn hset_multiple<K, F, V, RV>(
&self,
key: K,
items: &[(F, V)]
) -> Result<RV, RedisError> where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn hincr<K, F, D, RV>(
&self,
key: K,
field: F,
delta: D
) -> Result<RV, RedisError> where
D: ToRedisArgs,
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn hincr<K, F, D, RV>(
&self,
key: K,
field: F,
delta: D
) -> Result<RV, RedisError> where
D: ToRedisArgs,
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
fn hexists<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError> where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn hexists<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError> where
F: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
fn hkeys<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn hkeys<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn hvals<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn hvals<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn hgetall<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn hgetall<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn hlen<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn hlen<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn blpop<K, RV>(&self, key: K, timeout: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn blpop<K, RV>(&self, key: K, timeout: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn brpop<K, RV>(&self, key: K, timeout: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn brpop<K, RV>(&self, key: K, timeout: usize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn brpoplpush<K, RV>(
&self,
srckey: K,
dstkey: K,
timeout: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn brpoplpush<K, RV>(
&self,
srckey: K,
dstkey: K,
timeout: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn lindex<K, RV>(&self, key: K, index: isize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn lindex<K, RV>(&self, key: K, index: isize) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn linsert_before<K, P, V, RV>(
&self,
key: K,
pivot: P,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn linsert_before<K, P, V, RV>(
&self,
key: K,
pivot: P,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn linsert_after<K, P, V, RV>(
&self,
key: K,
pivot: P,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn linsert_after<K, P, V, RV>(
&self,
key: K,
pivot: P,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn llen<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn llen<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn lpop<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn lpop<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn lpush<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn lpush<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn lpush_exists<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn lpush_exists<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn lrange<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn lrange<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn lrem<K, V, RV>(
&self,
key: K,
count: isize,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn lrem<K, V, RV>(
&self,
key: K,
count: isize,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn ltrim<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn ltrim<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn lset<K, V, RV>(
&self,
key: K,
index: isize,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn lset<K, V, RV>(
&self,
key: K,
index: isize,
value: V
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn rpop<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn rpop<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn rpoplpush<K, RV>(&self, key: K, dstkey: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn rpoplpush<K, RV>(&self, key: K, dstkey: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn rpush<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn rpush<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn rpush_exists<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
[src]
fn rpush_exists<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
V: ToRedisArgs,
fn sadd<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
[src]
fn sadd<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn scard<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn scard<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn sdiff<K, RV>(&self, keys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn sdiff<K, RV>(&self, keys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn sdiffstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn sdiffstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn sinter<K, RV>(&self, keys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn sinter<K, RV>(&self, keys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn sdinterstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn sdinterstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn sismember<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
[src]
fn sismember<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn smembers<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn smembers<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn smove<K, M, RV>(
&self,
srckey: K,
dstkey: K,
member: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
[src]
fn smove<K, M, RV>(
&self,
srckey: K,
dstkey: K,
member: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn spop<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn spop<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn srandmember<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn srandmember<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn srandmember_multiple<K, RV>(
&self,
key: K,
count: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn srandmember_multiple<K, RV>(
&self,
key: K,
count: usize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn srem<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
[src]
fn srem<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn sunion<K, RV>(&self, keys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn sunion<K, RV>(&self, keys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn sunionstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn sunionstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn zadd<K, S, M, RV>(
&self,
key: K,
member: M,
score: S
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
S: ToRedisArgs,
[src]
fn zadd<K, S, M, RV>(
&self,
key: K,
member: M,
score: S
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
S: ToRedisArgs,
fn zadd_multiple<K, S, M, RV>(
&self,
key: K,
items: &[(S, M)]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
S: ToRedisArgs,
[src]
fn zadd_multiple<K, S, M, RV>(
&self,
key: K,
items: &[(S, M)]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
S: ToRedisArgs,
fn zcard<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zcard<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn zcount<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zcount<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zincr<K, M, D, RV>(
&self,
key: K,
member: M,
delta: D
) -> Result<RV, RedisError> where
D: ToRedisArgs,
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zincr<K, M, D, RV>(
&self,
key: K,
member: M,
delta: D
) -> Result<RV, RedisError> where
D: ToRedisArgs,
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn zinterstore<K, RV>(&self, dstkey: K, keys: &[K]) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zinterstore<K, RV>(&self, dstkey: K, keys: &[K]) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn zinterstore_min<K, RV>(
&self,
dstkey: K,
keys: &[K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zinterstore_min<K, RV>(
&self,
dstkey: K,
keys: &[K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn zinterstore_max<K, RV>(
&self,
dstkey: K,
keys: &[K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zinterstore_max<K, RV>(
&self,
dstkey: K,
keys: &[K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn zlexcount<K, L, RV>(&self, key: K, min: L, max: L) -> Result<RV, RedisError> where
K: ToRedisArgs,
L: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zlexcount<K, L, RV>(&self, key: K, min: L, max: L) -> Result<RV, RedisError> where
K: ToRedisArgs,
L: ToRedisArgs,
RV: FromRedisValue,
fn zrange<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrange<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn zrange_withscores<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrange_withscores<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn zrangebylex<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrangebylex<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrangebylex_limit<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrangebylex_limit<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrevrangebylex<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrevrangebylex<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrevrangebylex_limit<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrevrangebylex_limit<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrangebyscore<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrangebyscore<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrangebyscore_withscores<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrangebyscore_withscores<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrangebyscore_limit<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrangebyscore_limit<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrangebyscore_limit_withscores<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrangebyscore_limit_withscores<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrank<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrank<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn zrem<K, M, RV>(&self, key: K, members: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrem<K, M, RV>(&self, key: K, members: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn zrembylex<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrembylex<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrembyrank<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrembyrank<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn zrembyscore<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrembyscore<K, M, MM, RV>(
&self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrevrange<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrevrange<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn zrevrange_withscores<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrevrange_withscores<K, RV>(
&self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn zrevrangebyscore<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrevrangebyscore<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrevrangebyscore_withscores<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrevrangebyscore_withscores<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrevrangebyscore_limit<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrevrangebyscore_limit<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrevrangebyscore_limit_withscores<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrevrangebyscore_limit_withscores<K, MM, M, RV>(
&self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrevrank<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zrevrank<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn zscore<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zscore<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn zunionstore<K, RV>(&self, dstkey: K, keys: &[K]) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zunionstore<K, RV>(&self, dstkey: K, keys: &[K]) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn zunionstore_min<K, RV>(
&self,
dstkey: K,
keys: &[K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zunionstore_min<K, RV>(
&self,
dstkey: K,
keys: &[K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn zunionstore_max<K, RV>(
&self,
dstkey: K,
keys: &[K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zunionstore_max<K, RV>(
&self,
dstkey: K,
keys: &[K]
) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn pfadd<K, E, RV>(&self, key: K, element: E) -> Result<RV, RedisError> where
E: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn pfadd<K, E, RV>(&self, key: K, element: E) -> Result<RV, RedisError> where
E: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
fn pfcount<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn pfcount<K, RV>(&self, key: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn pfmerge<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn pfmerge<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn publish<K, E, RV>(&self, channel: K, message: E) -> Result<RV, RedisError> where
E: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn publish<K, E, RV>(&self, channel: K, message: E) -> Result<RV, RedisError> where
E: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
fn scan<RV>(&self) -> Result<Iter<RV>, RedisError> where
RV: FromRedisValue,
[src]
fn scan<RV>(&self) -> Result<Iter<RV>, RedisError> where
RV: FromRedisValue,
fn scan_match<P, RV>(&self, pattern: P) -> Result<Iter<RV>, RedisError> where
P: ToRedisArgs,
RV: FromRedisValue,
[src]
fn scan_match<P, RV>(&self, pattern: P) -> Result<Iter<RV>, RedisError> where
P: ToRedisArgs,
RV: FromRedisValue,
fn hscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn hscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn hscan_match<K, P, RV>(
&self,
key: K,
pattern: P
) -> Result<Iter<RV>, RedisError> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
[src]
fn hscan_match<K, P, RV>(
&self,
key: K,
pattern: P
) -> Result<Iter<RV>, RedisError> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
fn sscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn sscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn sscan_match<K, P, RV>(
&self,
key: K,
pattern: P
) -> Result<Iter<RV>, RedisError> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
[src]
fn sscan_match<K, P, RV>(
&self,
key: K,
pattern: P
) -> Result<Iter<RV>, RedisError> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
fn zscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError> where
K: ToRedisArgs,
RV: FromRedisValue,
fn zscan_match<K, P, RV>(
&self,
key: K,
pattern: P
) -> Result<Iter<RV>, RedisError> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
[src]
fn zscan_match<K, P, RV>(
&self,
key: K,
pattern: P
) -> Result<Iter<RV>, RedisError> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
Implementors
impl Commands for redis_cluster_rs::Connection