Struct redis::Client [] [src]

pub struct Client {
    // some fields omitted
}

The client type.

Methods

impl Client

The client acts as connector to the redis server. By itself it does not do much other than providing a convenient way to fetch a connection from it. In the future the plan is to provide a connection pool in the client.

When opening a client a URL in the following format should be used:

redis://host:port/db

Example usage::

let client = redis::Client::open("redis://127.0.0.1/").unwrap();
let con = client.get_connection().unwrap();

fn open<T: IntoConnectionInfo>(params: T) -> RedisResult<Client>

Connects to a redis server and returns a client. This does not actually open a connection yet but it does perform some basic checks on the URL that might make the operation fail.

fn get_connection(&self) -> RedisResult<Connection>

Instructs the client to actually connect to redis and returns a connection object. The connection object can be used to send commands to the server. This can fail with a variety of errors (like unreachable host) so it's important that you handle those errors.

fn get_pubsub(&self) -> RedisResult<PubSub>

Returns a PubSub connection. A pubsub connection can be used to listen to messages coming in through the redis publish/subscribe system.

Note that redis' pubsub operates across all databases.

Trait Implementations

impl ConnectionLike for Client

fn req_packed_command(&self, cmd: &[u8]) -> RedisResult<Value>

fn req_packed_commands(&self, cmd: &[u8], offset: usize, count: usize) -> RedisResult<Vec<Value>>

fn get_db(&self) -> i64

impl Commands for Client

fn get<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>

fn set<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(&self, key: K, value: V) -> RedisResult<RV>

fn set_multiple<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(&self, items: &[(K, V)]) -> RedisResult<RV>

fn set_ex<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(&self, key: K, value: V, seconds: usize) -> RedisResult<RV>

fn set_nx<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(&self, key: K, value: V) -> RedisResult<RV>

fn mset_nx<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(&self, items: &[(K, V)]) -> RedisResult<RV>

fn getset<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(&self, key: K, value: V) -> RedisResult<RV>

fn del<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>

fn exists<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>

fn expire<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K, seconds: usize) -> RedisResult<RV>

fn expire_at<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K, ts: usize) -> RedisResult<RV>

fn pexpire<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K, ms: usize) -> RedisResult<RV>

fn pexpire_at<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K, ts: usize) -> RedisResult<RV>

fn persist<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>

fn rename<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K, new_key: K) -> RedisResult<RV>

fn rename_nx<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K, new_key: K) -> RedisResult<RV>

fn append<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(&self, key: K, value: V) -> RedisResult<RV>

fn incr<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(&self, key: K, delta: V) -> RedisResult<RV>

fn setbit<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K, offset: usize, value: bool) -> RedisResult<RV>

fn getbit<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K, offset: usize) -> RedisResult<RV>

fn bitcount<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>

fn bitcount_range<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K, start: usize, end: usize) -> RedisResult<RV>

fn bit_and<K: ToRedisArgs, RV: FromRedisValue>(&self, dstkey: K, srckeys: K) -> RedisResult<RV>

fn bit_or<K: ToRedisArgs, RV: FromRedisValue>(&self, dstkey: K, srckeys: K) -> RedisResult<RV>

fn bit_xor<K: ToRedisArgs, RV: FromRedisValue>(&self, dstkey: K, srckeys: K) -> RedisResult<RV>

fn bit_not<K: ToRedisArgs, RV: FromRedisValue>(&self, dstkey: K, srckey: K) -> RedisResult<RV>

fn strlen<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>

fn hget<K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>(&self, key: K, field: F) -> RedisResult<RV>

fn hdel<K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>(&self, key: K, field: F) -> RedisResult<RV>

fn hset<K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(&self, key: K, field: F, value: V) -> RedisResult<RV>

fn hset_nx<K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(&self, key: K, field: F, value: V) -> RedisResult<RV>

fn hset_multiple<K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(&self, key: K, items: &[(F, V)]) -> RedisResult<RV>

fn hincr<K: ToRedisArgs, F: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>(&self, key: K, field: F, delta: D) -> RedisResult<RV>

fn hexists<K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>(&self, key: K, field: F) -> RedisResult<RV>

fn hkeys<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>

fn hvals<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>

fn hgetall<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>

fn hlen<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>

fn blpop<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K, timeout: usize) -> RedisResult<RV>

fn brpop<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K, timeout: usize) -> RedisResult<RV>

fn brpoplpush<K: ToRedisArgs, RV: FromRedisValue>(&self, srckey: K, dstkey: K, timeout: usize) -> RedisResult<RV>

fn lindex<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K, index: isize) -> RedisResult<RV>

fn linsert_before<K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(&self, key: K, pivot: P, value: V) -> RedisResult<RV>

fn linsert_after<K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(&self, key: K, pivot: P, value: V) -> RedisResult<RV>

fn llen<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>

fn lpop<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>

fn lpush<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(&self, key: K, value: V) -> RedisResult<RV>

fn lpush_exists<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(&self, key: K, value: V) -> RedisResult<RV>

fn lrange<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K, start: isize, stop: isize) -> RedisResult<RV>

fn lrem<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(&self, key: K, count: isize, value: V) -> RedisResult<RV>

fn ltrim<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K, start: isize, stop: isize) -> RedisResult<RV>

fn rpop<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>

fn rpoplpush<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K, dstkey: K) -> RedisResult<RV>

fn rpush<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(&self, key: K, value: V) -> RedisResult<RV>

fn rpush_exists<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(&self, key: K, value: V) -> RedisResult<RV>

fn sadd<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(&self, key: K, member: M) -> RedisResult<RV>

fn scard<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>

fn sdiff<K: ToRedisArgs, RV: FromRedisValue>(&self, keys: K) -> RedisResult<RV>

fn sdiffstore<K: ToRedisArgs, RV: FromRedisValue>(&self, dstkey: K, keys: K) -> RedisResult<RV>

fn sinter<K: ToRedisArgs, RV: FromRedisValue>(&self, keys: K) -> RedisResult<RV>

fn sdinterstore<K: ToRedisArgs, RV: FromRedisValue>(&self, dstkey: K, keys: K) -> RedisResult<RV>

fn sismember<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(&self, key: K, member: M) -> RedisResult<RV>

fn smembers<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>

fn smove<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(&self, srckey: K, dstkey: K, member: M) -> RedisResult<RV>

fn spop<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>

fn srandmember<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>

fn srandmember_multiple<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K, count: usize) -> RedisResult<RV>

fn srem<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(&self, key: K, member: M) -> RedisResult<RV>

fn sunion<K: ToRedisArgs, RV: FromRedisValue>(&self, keys: K) -> RedisResult<RV>

fn sunionstore<K: ToRedisArgs, RV: FromRedisValue>(&self, dstkey: K, keys: K) -> RedisResult<RV>

fn zadd<K: ToRedisArgs, S: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(&self, key: K, member: M, score: S) -> RedisResult<RV>

fn zadd_multiple<K: ToRedisArgs, S: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(&self, key: K, items: &[(S, M)]) -> RedisResult<RV>

fn zcard<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>

fn zcount<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(&self, key: K, min: M, max: MM) -> RedisResult<RV>

fn zincr<K: ToRedisArgs, M: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>(&self, key: K, member: M, delta: D) -> RedisResult<RV>

fn zinterstore<K: ToRedisArgs, RV: FromRedisValue>(&self, dstkey: K, keys: &[K]) -> RedisResult<RV>

fn zinterstore_min<K: ToRedisArgs, RV: FromRedisValue>(&self, dstkey: K, keys: &[K]) -> RedisResult<RV>

fn zinterstore_max<K: ToRedisArgs, RV: FromRedisValue>(&self, dstkey: K, keys: &[K]) -> RedisResult<RV>

fn zlexcount<K: ToRedisArgs, L: ToRedisArgs, RV: FromRedisValue>(&self, key: K, min: L, max: L) -> RedisResult<RV>

fn zrange<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K, start: isize, stop: isize) -> RedisResult<RV>

fn zrange_withscores<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K, start: isize, stop: isize) -> RedisResult<RV>

fn zrangebylex<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(&self, key: K, min: M, max: MM) -> RedisResult<RV>

fn zrangebylex_limit<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(&self, key: K, min: M, max: MM, offset: isize, count: isize) -> RedisResult<RV>

fn zrevrangebylex<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(&self, key: K, max: MM, min: M) -> RedisResult<RV>

fn zrevrangebylex_limit<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(&self, key: K, max: MM, min: M, offset: isize, count: isize) -> RedisResult<RV>

fn zrangebyscore<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(&self, key: K, min: M, max: MM) -> RedisResult<RV>

fn zrangebyscore_withscores<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(&self, key: K, min: M, max: MM) -> RedisResult<RV>

fn zrangebyscore_limit<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(&self, key: K, min: M, max: MM, offset: isize, count: isize) -> RedisResult<RV>

fn zrangebyscore_limit_withscores<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(&self, key: K, min: M, max: MM, offset: isize, count: isize) -> RedisResult<RV>

fn zrank<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(&self, key: K, member: M) -> RedisResult<RV>

fn zrem<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(&self, key: K, members: M) -> RedisResult<RV>

fn zrembylex<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(&self, key: K, min: M, max: MM) -> RedisResult<RV>

fn zrembyrank<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K, start: isize, stop: isize) -> RedisResult<RV>

fn zrembyscore<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(&self, key: K, min: M, max: MM) -> RedisResult<RV>

fn zrevrange<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K, start: isize, stop: isize) -> RedisResult<RV>

fn zrevrange_withscores<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K, start: isize, stop: isize) -> RedisResult<RV>

fn zrevrangebyscore<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(&self, key: K, max: MM, min: M) -> RedisResult<RV>

fn zrevrangebyscore_withscores<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(&self, key: K, max: MM, min: M) -> RedisResult<RV>

fn zrevrangebyscore_limit<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(&self, key: K, max: MM, min: M, offset: isize, count: isize) -> RedisResult<RV>

fn zrevrangebyscore_limit_withscores<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(&self, key: K, max: MM, min: M, offset: isize, count: isize) -> RedisResult<RV>

fn zrevrank<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(&self, key: K, member: M) -> RedisResult<RV>

fn zscore<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(&self, key: K, member: M) -> RedisResult<RV>

fn zunionstore<K: ToRedisArgs, RV: FromRedisValue>(&self, dstkey: K, keys: &[K]) -> RedisResult<RV>

fn zunionstore_min<K: ToRedisArgs, RV: FromRedisValue>(&self, dstkey: K, keys: &[K]) -> RedisResult<RV>

fn zunionstore_max<K: ToRedisArgs, RV: FromRedisValue>(&self, dstkey: K, keys: &[K]) -> RedisResult<RV>

fn pfadd<K: ToRedisArgs, E: ToRedisArgs, RV: FromRedisValue>(&self, key: K, element: E) -> RedisResult<RV>

fn pfcount<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>

fn pfmerge<K: ToRedisArgs, RV: FromRedisValue>(&self, dstkey: K, srckeys: K) -> RedisResult<RV>

fn scan<RV: FromRedisValue>(&self) -> RedisResult<Iter<RV>>

fn scan_match<P: ToRedisArgs, RV: FromRedisValue>(&self, pattern: P) -> RedisResult<Iter<RV>>

fn hscan<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<Iter<RV>>

fn hscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(&self, key: K, pattern: P) -> RedisResult<Iter<RV>>

fn sscan<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<Iter<RV>>

fn sscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(&self, key: K, pattern: P) -> RedisResult<Iter<RV>>

fn zscan<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<Iter<RV>>

fn zscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(&self, key: K, pattern: P) -> RedisResult<Iter<RV>>

Derived Implementations

impl Clone for Client

fn clone(&self) -> Client

1.0.0fn clone_from(&mut self, source: &Self)

impl Debug for Client

fn fmt(&self, __arg_0: &mut Formatter) -> Result