Struct redis::Connection [] [src]

pub struct Connection {
    // some fields omitted
}

Represents a stateful redis TCP connection.

Methods

impl Connection

A connection is an object that represents a single redis connection. It provides basic support for sending encoded commands into a redis connection and to read a response from it. It's bound to a single database and can only be created from the client.

You generally do not much with this object other than passing it to Cmd objects.

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

Sends an already encoded (packed) command into the TCP socket and does not read a response. This is useful for commands like MONITOR which yield multiple items. This needs to be used with care because it changes the state of the connection.

fn recv_response(&self) -> RedisResult<Value>

Fetches a single response from the connection. This is useful if used in combination with send_packed_command.

Trait Implementations

impl ConnectionLike for Connection

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 Connection

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>>