diff --git a/redis.go b/redis.go
index c612088356b247fac53dbb23e5dc052cc5fc30b6..caea7f9320e2204471e540652027384e7e4a9b16 100644
--- a/redis.go
+++ b/redis.go
@@ -5,14 +5,17 @@ import (
"log"
+ "fmt"
+
+ "strings"
+
"github.com/garyburd/redigo/redis"
)
//NewRedisConn 返回一个新的redis连接
-func NewRedisConn(u string, writeable bool) *RedisConn {
- return &RedisConn{
+func NewRedisConn(u string, params ...interface{}) *RedisConn {
+ return &RedisClient{
u: u,
- w: writeable,
p: &redis.Pool{
MaxActive: 200,
MaxIdle: 50,
@@ -29,205 +32,864 @@ func NewRedisConn(u string, writeable bool) *RedisConn {
}
//RedisClient redis连接
-type RedisClient = RedisConn
+type RedisConn = RedisClient
//NewRedisClient 返回一个新的redis连接
-func NewRedisClient(u string, writeable bool) *RedisClient {
- return NewRedisConn(u, writeable)
+func NewRedisClient(u string, params ...interface{}) *RedisClient {
+ return NewRedisConn(u, params...)
}
-//RedisConn redis连接
-//
-//deprecated use RedisClient instead
-type RedisConn struct {
+//RedisClient redis连接
+type RedisClient struct {
u string //连接URL
- w bool //可写?
p *redis.Pool
}
//Do 执行命令
-func (c RedisConn) Do(command string, args ...interface{}) (interface{}, error) {
+func (c RedisClient) Do(command string, args ...interface{}) (interface{}, error) {
conn := c.p.Get()
defer conn.Close()
return conn.Do(command, args...)
}
-func (c RedisConn) panicWrite() {
- if !c.w {
- log.Panicf("redis conn{%s} is not writeable", c.u)
- }
-}
-
//----KEY----
-func (c RedisConn) Del(key string) bool {
- c.panicWrite()
-
+func (c RedisClient) Del(key interface{}) bool {
if r, e := redis.Int(c.Do("DEL", key)); e != nil {
+ log.Printf("DEL %v err: %s", key, e)
return false
} else {
return r >= 0
}
}
-func (c RedisConn) Dump(key string) (string, error) {
- return redis.String(c.Do("DUMP", key))
+func (c RedisClient) Dump(key interface{}) (string, error) {
+ r, e := redis.String(c.Do("DUMP", key))
+ if e != nil {
+ log.Printf("DUMP %v err: %s", key, e)
+ return "", e
+ } else {
+ return r, nil
+ }
}
-func (c RedisConn) Exists(key string) bool {
+func (c RedisClient) Exists(key interface{}) bool {
if r, e := redis.Int(c.Do("EXISTS", key)); e != nil {
+ log.Printf("EXISTS %v err: %s", key, e)
return false
} else {
return r == 1
}
}
-func (c RedisConn) Expire(key string, seconds int64) bool {
- c.panicWrite()
-
+func (c RedisClient) Expire(key interface{}, seconds int64) bool {
if r, e := redis.Int(c.Do("EXPIRE", key, seconds)); e != nil {
+ log.Printf("EXPIRE %v %d err: %s", key, seconds, e)
return false
} else {
return r == 1
}
}
-func (c RedisConn) ExpireAt(key string, timestamp int64) bool {
- c.panicWrite()
-
+func (c RedisClient) ExpireAt(key interface{}, timestamp int64) bool {
if r, e := redis.Int(c.Do("EXPIREAT", key, timestamp)); e != nil {
+ log.Printf("EXPIREAT %v %d err: %s", key, timestamp, e)
return false
} else {
return r == 1
}
}
-//----KEY----
+func (c RedisClient) PExpire(key interface{}, milliSeconds int64) bool {
+ if r, e := redis.Int(c.Do("PEXPIREAT", key, milliSeconds)); e != nil {
+ log.Printf("PEXPIRE %v %d err: %s", key, milliSeconds, e)
+ return false
+ } else {
+ return r == 1
+ }
+}
-func (c RedisConn) MGet(keys ...string) ([]string, error) {
- args := make([]interface{}, 0)
- for _, k := range keys {
- args = append(args, k)
+func (c RedisClient) PExpireAt(key interface{}, timestamp int64) bool {
+ if r, e := redis.Int(c.Do("PEXPIREAT", key, timestamp)); e != nil {
+ log.Printf("PEXPIREAT %v %d err: %s", key, timestamp, e)
+ return false
+ } else {
+ return r == 1
}
- return redis.Strings(c.Do("MGET", args...))
}
-func (c RedisConn) Get(key string) (string, error) {
- return redis.String(c.Do("GET", key))
+func (c RedisClient) Keys(pattern interface{}) ([]string, error) {
+ r, e := redis.Strings(c.Do("KEYS", pattern))
+ if e != nil {
+ log.Printf("KEYS %v err: %s", pattern, e)
+ return nil, e
+ } else {
+ return r, nil
+ }
}
-func (c RedisConn) MSet(kvPairs [][2]interface{}) bool {
- c.panicWrite()
+func (c RedisClient) Move(key interface{}, db int) bool {
+ if r, e := redis.Int(c.Do("MOVE", key, db)); e != nil {
+ log.Printf("MOVE %v %d err: %s", key, db, e)
+ return false
+ } else {
+ return r == 1
+ }
+}
- args := make([]interface{}, 0)
- for _, pair := range kvPairs {
- args = append(args, pair[:]...)
+func (c RedisClient) Persist(key interface{}) bool {
+ if r, e := redis.Int(c.Do("PERSIST", key)); e != nil {
+ log.Printf("PERSIST %v err: %s", key, e)
+ return false
+ } else {
+ return r == 1
}
- re, e := redis.String(c.Do("MSET", args...))
+}
+
+func (c RedisClient) PTTL(key interface{}) (int64, error) {
+ r, e := redis.Int64(c.Do("PTTL", key))
if e != nil {
+ log.Printf("PTTL %v err: %s", key, e)
+ return r, e
+ }
+ switch r {
+ case -2:
+ return r, fmt.Errorf("%v is not exist", key)
+ case -1:
+ return r, fmt.Errorf("%v does not have expire time", key)
+ default:
+ return r, nil
+ }
+}
+
+func (c RedisClient) TTL(key interface{}) (int64, error) {
+ r, e := redis.Int64(c.Do("TTL", key))
+ if e != nil {
+ log.Printf("TTL %v err: %s", key, e)
+ return r, e
+ }
+ switch r {
+ case -2:
+ return r, fmt.Errorf("%v is not exist", key)
+ case -1:
+ return r, fmt.Errorf("%v does not have expire time", key)
+ default:
+ return r, nil
+ }
+}
+
+func (c RedisClient) RandomKey() (string, error) {
+ if r, e := redis.String(c.Do("RANDOMKEY")); e != nil {
+ log.Printf("RANDOMKEY err: %s", e)
+ return r, e
+ } else {
+ return r, nil
+ }
+}
+
+func (c RedisClient) Rename(oldKey, newKey interface{}) bool {
+ if r, e := redis.String(c.Do("RENAME", oldKey, newKey)); e != nil {
+ log.Printf("RENAME %v %v err: %s", oldKey, newKey, e)
return false
+ } else {
+ if strings.ToUpper(r) != "OK" {
+ log.Printf("RENAME %v %v err: %s", oldKey, newKey, r)
+ return false
+ }
+
+ return true
+ }
+}
+
+func (c RedisClient) RenameNX(oldKey, newKey interface{}) bool {
+ if r, e := redis.Int(c.Do("RENAMENX", oldKey, newKey)); e != nil {
+ log.Printf("RENAMENX %v %v err: %s", oldKey, newKey, e)
+ return false
+ } else {
+ return r == 1
}
- return re == "OK"
}
-func (c RedisConn) RPush(key string, values ...interface{}) (int64, error) {
- c.panicWrite()
+type Type = string
- args := make([]interface{}, 0)
- args = append(args, key)
- args = append(args, values...)
- return redis.Int64(c.Do("RPUSH", args...))
+const (
+ None Type = "none"
+ String = "string"
+ List = "list"
+ Set = "set"
+ ZSet = "zset"
+ Hash = "hash"
+)
+
+func (c RedisClient) Type(key interface{}) (Type, error) {
+ if r, e := redis.String(c.Do("TYPE", key)); e != nil {
+ log.Printf("TYPE %v err: %s", key, e)
+ return None, e
+ } else {
+ return r, nil
+ }
}
-func (c RedisConn) Set(key string, value string) bool {
- c.panicWrite()
+//----KEY----
+
+//----STRING----
- if reply, err := redis.String(c.Do("SET", key, value)); err != nil {
+func (c RedisClient) Set(key interface{}, value interface{}) bool {
+ if r, e := redis.String(c.Do("SET", key, value)); e != nil {
+ log.Printf("SET %v %v err: %s", key, value, e)
return false
} else {
- return reply == "OK"
+ return r == "OK"
+ }
+}
+
+func (c RedisClient) Get(key interface{}) (r string, e error) {
+ if r, e = redis.String(c.Do("GET", key)); e != nil {
+ log.Printf("GET %v err: %s", key, e)
}
+
+ return
}
-func (c RedisConn) HDel(key string, fields ...interface{}) bool {
- c.panicWrite()
+func (c RedisClient) GetRange(key interface{}, start, end int) (r string, e error) {
+ if r, e = redis.String(c.Do("GETRANGE", key, start, end)); e != nil {
+ log.Printf("GETRANGE %v %d %d err: %s", key, start, end, e)
+ }
+
+ return
+}
+func (c RedisClient) GetSet(key, value interface{}) (r string, e error) {
+ r, e = redis.String(c.Do("GETSET", key, value))
+ if e != nil {
+ log.Printf("GETSET %v %v err: %s", key, value, e)
+ }
+
+ return
+}
+
+func (c RedisClient) GetBit(key interface{}, offset int) (r int, e error) {
+ r, e = redis.Int(c.Do("GETBIT", key, offset))
+ if e != nil {
+ log.Printf("GETBIT %v %d err: %s", key, offset, e)
+ }
+
+ return
+}
+
+func (c RedisClient) MGet(keys ...interface{}) ([]string, error) {
+ r, e := redis.Strings(c.Do("MGET", keys...))
+ if e != nil {
+ log.Printf("MGET %v err: %s", keys, e)
+ }
+
+ return r, e
+}
+
+func (c RedisClient) SetBit(key interface{}, offset int, bit int) (r int, e error) {
+ r, e = redis.Int(c.Do("SETBIT", key, offset, bit))
+ if e != nil {
+ log.Printf("SETBIT %v %d %d err: %s", key, offset, bit, e)
+ }
+
+ return
+}
+
+func (c RedisClient) SetEX(key, value interface{}, seconds int64) bool {
+ r, e := redis.String(c.Do("SETEX", key, seconds, value))
+ if e != nil {
+ log.Printf("SETEX %v %d %v err: %s", key, seconds, value, e)
+ return false
+ }
+
+ return r == "OK"
+}
+
+func (c RedisClient) SetNX(key, value interface{}) bool {
+ r, e := redis.Int(c.Do("SETNX", key, value))
+ if e != nil {
+ log.Printf("SETNX %v %v err: %s", key, value, e)
+ return false
+ }
+
+ return r == 1
+}
+
+func (c RedisClient) SetRange(key, value interface{}, offset int) (r int, e error) {
+ r, e = redis.Int(c.Do("SETRANGE", key, offset, value))
+ if e != nil {
+ log.Printf("SETRANGE %v %d %v err: %s", key, offset, value, e)
+ }
+
+ return
+}
+
+func (c RedisClient) StrLen(key interface{}) (r int, e error) {
+ r, e = redis.Int(c.Do("STRLEN", key))
+ if e != nil {
+ log.Printf("STRLEN %v err: %s", key, e)
+ }
+
+ return
+}
+
+func (c RedisClient) MSet(pairs [][2]interface{}) bool {
+ args := make([]interface{}, len(pairs)*2)
+ for i, pair := range pairs {
+ args[2*i] = pair[0]
+ args[2*i+1] = pair[1]
+ }
+
+ r, e := redis.String(c.Do("MSET", args...))
+ if e != nil {
+ log.Printf("MSET %v err: %s", pairs, e)
+ return false
+ }
+
+ return r == "OK"
+}
+
+func (c RedisClient) MSetNX(pairs [][2]interface{}) bool {
+ args := make([]interface{}, len(pairs)*2)
+ for i, pair := range pairs {
+ args[i*2] = pair[0]
+ args[i*2+1] = pair[1]
+ }
+
+ r, e := redis.Int(c.Do("MSETNX", args...))
+ if e != nil {
+ log.Printf("MSETNX %v err: %s", pairs, e)
+ return false
+ }
+
+ return r == 1
+}
+
+func (c RedisClient) PSetEX(key, value interface{}, milliSeconds int64) bool {
+ r, e := redis.String(c.Do("PSETEX", key, milliSeconds, value))
+ if e != nil {
+ log.Printf("PSETEX %v %d %v err: %s", key, milliSeconds, value, e)
+ }
+
+ return r == "OK"
+}
+
+func (c RedisClient) Incr(key interface{}) (r int, e error) {
+ r, e = redis.Int(c.Do("INCR", key))
+ if e != nil {
+ log.Printf("INCR %v err: %s", key, e)
+ }
+
+ return
+}
+
+func (c RedisClient) IncrBy(key interface{}, incrAmount int64) (r int, e error) {
+ r, e = redis.Int(c.Do("INCRBY", key, incrAmount))
+ if e != nil {
+ log.Printf("INCRBY %v %d err: %s", key, incrAmount, e)
+ }
+
+ return
+}
+
+func (c RedisClient) IncrByFloat(key interface{}, incrAmount float64) (r float64, e error) {
+ r, e = redis.Float64(c.Do("INCRBYFLOAT", key, incrAmount))
+ if e != nil {
+ log.Printf("INCRBYFLOAT %v %f err: %s", key, incrAmount, e)
+ }
+
+ return
+}
+
+func (c RedisClient) Decr(key interface{}) (r int, e error) {
+ r, e = redis.Int(c.Do("Decr", key))
+ if e != nil {
+ log.Printf("Decr %v err: %s", key, e)
+ }
+
+ return
+}
+
+func (c RedisClient) DecrBy(key interface{}, incrAmount int64) (r int, e error) {
+ r, e = redis.Int(c.Do("DecrBy", key, incrAmount))
+ if e != nil {
+ log.Printf("DecrBy %v %d err: %s", key, incrAmount, e)
+ }
+
+ return
+}
+
+func (c RedisClient) Append(key, value interface{}) (r int, e error) {
+ r, e = redis.Int(c.Do("APPEND", key, value))
+ if e != nil {
+ log.Printf("APPEND %v %v err: %s", key, value, e)
+ }
+
+ return
+}
+
+//----STRING----
+
+//----HASH----
+
+func (c RedisClient) HDel(key interface{}, fields ...interface{}) bool {
args := []interface{}{key}
args = append(args, fields...)
+
if count, e := redis.Int(c.Do("HDEL", args...)); e != nil {
+ log.Printf("HDEL %v %v err: %s", key, fields, e)
return false
} else {
return count >= 0
}
}
-func (c RedisConn) HExists(key, field string) (bool, error) {
- return redis.Bool(c.Do("HEXISTS", key, field))
+func (c RedisClient) HExists(key, field interface{}) bool {
+ r, e := redis.Bool(c.Do("HEXISTS", key, field))
+ if e != nil {
+ log.Printf("HEXISTS %v %v err: %s", key, field, e)
+ }
+
+ return r
}
-func (c RedisConn) HGet(key, field string) (string, error) {
- return redis.String(c.Do("HGET", key, field))
+func (c RedisClient) HGet(key, field interface{}) (r string, e error) {
+ r, e = redis.String(c.Do("HGET", key, field))
+ if e != nil {
+ log.Printf("HGET %v %v err: %s", key, field, e)
+ }
+
+ return
}
-func (c RedisConn) HGetAll(key string) (map[string]string, error) {
- return redis.StringMap(c.Do("HGETALL", key))
+func (c RedisClient) HGetAll(key interface{}) (r map[string]string, e error) {
+ r, e = redis.StringMap(c.Do("HGETALL", key))
+ if e != nil {
+ log.Printf("HGETALL %v err: %s", key, e)
+ }
+
+ return
}
-func (c RedisConn) HIncrBy(key, field string, incr int64) (int64, error) {
- c.panicWrite()
+func (c RedisClient) HIncrBy(key, field interface{}, incr int64) (r int64, e error) {
+ r, e = redis.Int64(c.Do("HINCRBY", key, field, incr))
+ if e != nil {
+ log.Printf("HINCRBY %v %v %d err: %s", key, field, incr, e)
+ }
- return redis.Int64(c.Do("HINCRBY", key, field, incr))
+ return
}
-func (c RedisConn) HIncrByFloat(key, field string, incr float64) (float64, error) {
- c.panicWrite()
+func (c RedisClient) HIncrByFloat(key, field interface{}, incr float64) (r float64, e error) {
+ r, e = redis.Float64(c.Do("HINCRBYFLOAT", key, field, incr))
+ if e != nil {
+ log.Printf("HINCRBYFLOAT %v %v %f err: %s", key, field, incr, e)
+ }
- return redis.Float64(c.Do("HINCRBYFLOAT", key, field, incr))
+ return
}
-func (c RedisConn) HKeys(key string) ([]string, error) {
- return redis.Strings(c.Do("HKEYS", key))
+func (c RedisClient) HKeys(key interface{}) (r []string, e error) {
+ r, e = redis.Strings(c.Do("HKEYS", key))
+ if e != nil {
+ log.Printf("HKEYS %v err: %s", key, e)
+ }
+
+ return
}
-func (c RedisConn) HLen(key string) (int, error) {
- return redis.Int(c.Do("HLEN", key))
+func (c RedisClient) HLen(key interface{}) (r int, e error) {
+ r, e = redis.Int(c.Do("HLEN", key))
+ if e != nil {
+ log.Printf("HLEN %v err: %s", key, e)
+ }
+
+ return
}
-func (c RedisConn) HMGet(key string, fields ...interface{}) ([]interface{}, error) {
+func (c RedisClient) HMGet(key interface{}, fields ...interface{}) (r []string, e error) {
args := []interface{}{key}
args = append(args, fields...)
- return redis.Values(c.Do("HMGET", args...))
-}
+ r, e = redis.Strings(c.Do("HMGET", args...))
+ if e != nil {
+ log.Printf("HMGET %v %v err: %s", key, fields, e)
+ }
-func (c RedisConn) HMSet(key string, fieldValues ...map[string]interface{}) bool {
- c.panicWrite()
+ return
+}
- args := []interface{}{key}
- for i := range fieldValues {
- for k, v := range fieldValues[i] {
- args = append(args, k)
- args = append(args, v)
- }
+func (c RedisClient) HMSet(key interface{}, pairs [][2]interface{}) bool {
+ args := make([]interface{}, 1+len(pairs)*2)
+ args[0] = key
+ for i, pair := range pairs {
+ args[1+2*i] = pair[0]
+ args[2+2*i] = pair[1]
}
+
if r, e := redis.String(c.Do("HMSET", args...)); e != nil {
+ log.Printf("HMSET %v %v err: %s", key, pairs, e)
return false
} else {
return r == "OK"
}
}
-func (c RedisConn) HSet(key, field string, value string) bool {
- c.panicWrite()
+func (c RedisClient) HSet(key, field, value interface{}) bool {
+ r, e := redis.Int(c.Do("HSET", key, field, value))
+ if e != nil {
+ log.Printf("HSET %v %v %v err: %s", key, field, value, e)
+ return false
+ }
+
+ return r >= 0
+}
+
+func (c RedisClient) HSetNX(key, field, value interface{}) bool {
+ r, e := redis.Int(c.Do("HSETNX", key, field, value))
+ if e != nil {
+ log.Printf("HSETNX %v %v %v err: %s", key, field, value, e)
+ return false
+ }
+
+ return r == 1
+}
+
+func (c RedisClient) HVals(key interface{}) (r []string, e error) {
+ r, e = redis.Strings(c.Do("HVALS", key))
+ if e != nil {
+ log.Printf("HVALS %v err: %s", key, e)
+ }
+
+ return
+}
+
+//----HASH----
+
+//----LIST----
+
+func (c RedisClient) LIndex(key interface{}, pos int) (r string, e error) {
+ r, e = redis.String(c.Do("LINDEX", key, pos))
+ if e != nil {
+ log.Printf("LINDEX %v %d err: %s", key, pos, e)
+ }
+
+ return
+}
+
+func (c RedisClient) LPush(key interface{}, values ...interface{}) (r int, e error) {
+ args := []interface{}{key}
+ args = append(args, values...)
+ r, e = redis.Int(c.Do("LPUSH", args...))
+ if e != nil {
+ log.Printf("LPUSH %v %v err: %s", key, values, e)
+ }
+
+ return
+}
+
+func (c RedisClient) LRange(key interface{}, start, end int) (r []string, e error) {
+ r, e = redis.Strings(c.Do("LRANGE", key, start, end))
+ if e != nil {
+ log.Printf("LRANGE %v %d %d err: %s", key, start, end, e)
+ }
+
+ return
+}
+
+func (c RedisClient) RPush(key interface{}, values ...interface{}) (r int64, e error) {
+ args := []interface{}{key}
+ args = append(args, values...)
+ r, e = redis.Int64(c.Do("RPUSH", args...))
+ if e != nil {
+ log.Printf("RPUSH %v %v err: %s", key, values, e)
+ }
+
+ return
+}
+
+func (c RedisClient) LLen(key interface{}) (r int, e error) {
+ r, e = redis.Int(c.Do("LLEN", key))
+ if e != nil {
+ log.Printf("LLEN %v err: %s", key, e)
+ }
+
+ return
+}
+
+func (c RedisClient) LPop(key interface{}) (r string, e error) {
+ r, e = redis.String(c.Do("LPOP", key))
+ if e != nil {
+ log.Printf("LPOP %v err: %s", key, e)
+ }
+
+ return
+}
+
+func (c RedisClient) LSet(key, value interface{}, pos int) bool {
+ r, e := redis.String(c.Do("LSET", key, pos, value))
+ if e != nil {
+ log.Printf("LSET %v %d %v err: %s", key, pos, value, e)
+ }
+
+ return r == "OK"
+}
+
+func (c RedisClient) RPop(key interface{}) (r string, e error) {
+ r, e = redis.String(c.Do("RPOP", key))
+ if e != nil {
+ log.Printf("RPOP %v err: %s", key, e)
+ }
+
+ return
+}
+
+//----LIST----
+
+//----SET----
+
+func (c RedisClient) SAdd(key interface{}, values ...interface{}) (r int, e error) {
+ args := []interface{}{key}
+ args = append(args, values...)
+ r, e = redis.Int(c.Do("SADD", args...))
+ if e != nil {
+ log.Printf("SADD %v %v err: %s", key, values, e)
+ }
+
+ return
+}
+
+func (c RedisClient) SCard(key interface{}) (r int, e error) {
+ r, e = redis.Int(c.Do("SCARD", key))
+ if e != nil {
+ log.Printf("SCARD %v err: %s", key, e)
+ }
+
+ return
+}
+
+func (c RedisClient) SDiff(keys ...interface{}) (r []string, e error) {
+ r, e = redis.Strings(c.Do("SDIFF", keys...))
+ if e != nil {
+ log.Printf("SDIFF %v err: %s", keys, e)
+ }
+
+ return
+}
+
+func (c RedisClient) SDiffStore(dest interface{}, keys ...interface{}) (r int, e error) {
+ args := []interface{}{dest}
+ args = append(args, keys...)
+ r, e = redis.Int(c.Do("SDIFFSTORE", args...))
+ if e != nil {
+ log.Printf("SDIFFSTORE %v %v err: %s", dest, keys, e)
+ }
+
+ return
+}
+
+func (c RedisClient) SMembers(key interface{}) (r []string, e error) {
+ r, e = redis.Strings(c.Do("SMEMBERS", key))
+ if e != nil {
+ log.Printf("SMEMBERS %v err: %s", key, e)
+ }
+ return
+}
+
+func (c RedisClient) SInter(keys ...interface{}) (r []string, e error) {
+ r, e = redis.Strings(c.Do("SINTER", keys...))
+ if e != nil {
+ log.Printf("SINTER %v err: %s", keys, e)
+ }
+ return
+}
+
+func (c RedisClient) SInterStore(dest interface{}, keys ...interface{}) (r int, e error) {
+ args := []interface{}{dest}
+ args = append(args, keys...)
+ r, e = redis.Int(c.Do("SINTERSTORE", args...))
+ if e != nil {
+ log.Printf("SINTERSTORE %v %v err: %s", dest, keys, e)
+ }
+
+ return
+}
+
+func (c RedisClient) SIsMember(key, value interface{}) bool {
+ r, e := redis.Bool(c.Do("SISMEMBER", key, value))
+ if e != nil {
+ log.Printf("SISMEMBER %v %v err: %s", key, value, e)
+ }
+ return r
+}
+
+func (c RedisClient) SPop(key interface{}) (r string, e error) {
+ r, e = redis.String(c.Do("SPOP", key))
+ if e != nil {
+ log.Printf("SPOP %v err: %s", key, e)
+ }
+ return
+}
- _, e := c.Do("HSET", key, field, value)
- return e == nil
+func (c RedisClient) SPopN(key interface{}, n int) (r []string, e error) {
+ r, e = redis.Strings(c.Do("SPOP", key, n))
+ if e != nil {
+ log.Printf("SPOP %v %d err: %s", key, n, e)
+ }
+ return
}
-func (c RedisConn) HVals(key string) ([]interface{}, error) {
- return redis.Values(c.Do("HVALS", key))
+func (c RedisClient) SRandMember(key interface{}) (r string, e error) {
+ r, e = redis.String(c.Do("SRANDMEMBER", key))
+ if e != nil {
+ log.Printf("SRANDMEMBER %v err: %s", key, e)
+ }
+ return
}
-func (c RedisConn) Keys(key string) ([]string, error) {
- return redis.Strings(c.Do("KEYS", key))
+func (c RedisClient) SRandMemberN(key interface{}, n int) (r []string, e error) {
+ r, e = redis.Strings(c.Do("SRANDMEMBER", key, n))
+ if e != nil {
+ log.Printf("SRANDMEMBER %v %d err: %s", key, n, e)
+ }
+ return
+}
+
+func (c RedisClient) SRem(key interface{}, members ...interface{}) (r int, e error) {
+ args := []interface{}{key}
+ args = append(args, members...)
+ r, e = redis.Int(c.Do("SREM", args...))
+ if e != nil {
+ log.Printf("SREM %v %v err: %s", key, members, e)
+ }
+ return
+}
+
+func (c RedisClient) SUnion(keys ...interface{}) (r []string, e error) {
+ r, e = redis.Strings(c.Do("SUNION", keys...))
+ if e != nil {
+ log.Printf("SUNION %v err: %s", keys, e)
+ }
+ return
+}
+
+func (c RedisClient) SUnionStore(dest interface{}, keys ...interface{}) (r int, e error) {
+ args := []interface{}{dest}
+ args = append(args, keys...)
+ r, e = redis.Int(c.Do("SUNIONSTORE", args...))
+ if e != nil {
+ log.Printf("SUNIONSTORE %v err: %s", args, e)
+ }
+ return
+}
+
+//----SET----
+
+//----SORTED SET----
+
+func (c RedisClient) ZAdd(key interface{}, pairs [][2]interface{}) (r int, e error) {
+ args := make([]interface{}, 1+2*len(pairs))
+ args[0] = key
+ for i, pair := range pairs {
+ args[1+2*i] = pair[0]
+ args[2+2*i] = pair[1]
+ }
+
+ r, e = redis.Int(c.Do("ZADD", args...))
+ if e != nil {
+ log.Printf("ZADD %v %v err: %s", key, pairs, e)
+ }
+ return
}
+
+func (c RedisClient) ZCard(key interface{}) (r int, e error) {
+ r, e = redis.Int(c.Do("ZCARD", key))
+ if e != nil {
+ log.Printf("ZCARD %v err: %s", key, e)
+ }
+ return
+}
+
+func (c RedisClient) ZRange(key interface{}, start, stop int) (r []string, e error) {
+ r, e = redis.Strings(c.Do("ZRANGE", key, start, stop))
+ if e != nil {
+ log.Printf("ZRANGE %v %d %d err: %s", key, start, stop, e)
+ }
+ return
+}
+
+func (c RedisClient) ZRangeWithScores(key interface{}, start, stop int) (r map[string]string, e error) {
+ r, e = redis.StringMap(c.Do("ZRANGE", key, start, stop, "WITHSCORES"))
+ if e != nil {
+ log.Printf("ZRANGE %v %d %d WITHSCORES err: %s", key, start, stop, e)
+ }
+ return
+}
+
+func (c RedisClient) ZCount(key interface{}, min, max float64) (r int, e error) {
+ r, e = redis.Int(c.Do("ZCOUNT", key, min, max))
+ if e != nil {
+ log.Printf("ZCOUNT %v %f %f err: %s", key, min, max, e)
+ }
+ return
+}
+
+func (c RedisClient) ZIncrBy(key, member interface{}, incr float64) (r float64, e error) {
+ r, e = redis.Float64(c.Do("ZINCRBY", key, incr, member))
+ if e != nil {
+ log.Printf("ZINCRBY %v %f %v err: %s", key, incr, member, e)
+ }
+ return
+}
+
+func (c RedisClient) ZRank(key, member interface{}) (r int, e error) {
+ r, e = redis.Int(c.Do("ZRANK", key, member))
+ if e != nil {
+ log.Printf("ZRANK %v %v err: %s", key, member, e)
+ }
+ return
+}
+
+func (c RedisClient) ZRevRank(key, member interface{}) (r int, e error) {
+ r, e = redis.Int(c.Do("ZREVRANK", key, member))
+ if e != nil {
+ log.Printf("ZREVRANK %v %v err: %s", key, member, e)
+ }
+ return
+}
+
+func (c RedisClient) ZRem(key interface{}, members ...interface{}) (r int, e error) {
+ args := []interface{}{key}
+ args = append(args, members...)
+ r, e = redis.Int(c.Do("ZREM", args...))
+ if e != nil {
+ log.Printf("ZREM %v %v err: %s", key, members, e)
+ }
+ return
+}
+
+func (c RedisClient) ZRevRange(key interface{}, start, stop int) (r []string, e error) {
+ r, e = redis.Strings(c.Do("ZREVRANGE", key, start, stop))
+ if e != nil {
+ log.Printf("ZREVRANGE %v %d %d err: %s", key, start, stop, e)
+ }
+ return
+}
+
+func (c RedisClient) ZRevRangeWithScores(key interface{}, start, stop int) (r map[string]string, e error) {
+ r, e = redis.StringMap(c.Do("ZREVRANGE", key, start, stop, "WITHSCORES"))
+ if e != nil {
+ log.Printf("ZREVRANGE %v %d %d WITHSCORES err: %s", key, start, stop, e)
+ }
+ return
+}
+
+func (c RedisClient) ZScore(key, member interface{}) (r float64, e error) {
+ r, e = redis.Float64(c.Do("ZSCORE", key, member))
+ if e != nil {
+ log.Printf("ZSCORE %v %v err: %s", key, member, e)
+ }
+ return
+}
+
+//----SORTED SET----
diff --git a/redis_test.go b/redis_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..1dfaa68db2840f6d08c6de76d458cfbd66da111d
--- /dev/null
+++ b/redis_test.go
@@ -0,0 +1,511 @@
+package helper
+
+import "testing"
+
+var test = NewRedisClient("redis://192.168.10.99/1")
+
+func TestRedisClient_Get(t *testing.T) {
+ t.Log(test.Set("key", "value"))
+ t.Log(test.Get("key"))
+ t.Log(test.Set("key", "new-value"))
+ t.Log(test.Get("key"))
+
+ test.Del("key")
+}
+
+func TestRedisClient_MGet(t *testing.T) {
+ t.Log(test.MGet("123", "12", "1", "2"))
+ t.Log(test.MGet("a"))
+}
+
+func TestRedisClient_SetBit(t *testing.T) {
+ t.Log(test.SetBit("bit", 10086, 1))
+ t.Log(test.GetBit("bit", 10086))
+ t.Log(test.GetBit("bit", 100))
+
+ test.Del("bit")
+}
+
+func TestRedisClient_SetEX(t *testing.T) {
+ t.Log(test.SetEX("mykey", "redis", 60))
+ t.Log(test.TTL("mykey"))
+ t.Log(test.Get("mykey"))
+
+ test.Del("mykey")
+}
+
+func TestRedisClient_SetNX(t *testing.T) {
+ t.Log(test.Exists("job"))
+ t.Log(test.SetNX("job", "programmer"))
+ t.Log(test.SetNX("job", "code-farmer"))
+ t.Log(test.Get("job"))
+
+ test.Del("job")
+}
+
+func TestRedisClient_SetRange(t *testing.T) {
+ t.Log(test.Set("key1", "Hello World"))
+ t.Log(test.SetRange("key1", "Redis", 6))
+ t.Log(test.Get("key1"))
+
+ test.Del("key1")
+}
+
+func TestRedisClient_StrLen(t *testing.T) {
+ t.Log(test.Set("mykey", "Hello World"))
+ t.Log(test.StrLen("mykey"))
+
+ test.Del("mykey")
+ t.Log(test.StrLen("mykey"))
+}
+
+func TestRedisClient_MSet(t *testing.T) {
+ t.Log(test.MSet([][2]interface{}{
+ {"key1", "Hello"},
+ {"key2", "World"},
+ }))
+
+ t.Log(test.Get("key1"))
+ t.Log(test.Get("key2"))
+
+ test.Del("key1")
+ test.Del("key2")
+}
+
+func TestRedisClient_MSetNX(t *testing.T) {
+ t.Log(test.MSetNX([][2]interface{}{
+ {"rmdbs", "MySql"},
+ {"nosql", "MongoDB"},
+ {"key-value-store", "redis"},
+ }))
+
+ t.Log(test.MGet("rmdbs", "nosql", "key-value-store"))
+
+ t.Log(test.MSetNX([][2]interface{}{
+ {"rmdbs", "Sqlite"},
+ {"language", "python"},
+ }))
+ t.Log(test.Exists("language"))
+ t.Log(test.Get("rmdbs"))
+
+ test.Del("rmdbs")
+ test.Del("nosql")
+ test.Del("key-value-store")
+}
+
+func TestRedisClient_PSetEX(t *testing.T) {
+ t.Log(test.PSetEX("mykey", "Hello", 1000))
+ t.Log(test.PTTL("mykey"))
+ t.Log(test.Get("mykey"))
+
+ test.Del("mykey")
+}
+
+func TestRedisClient_Incr(t *testing.T) {
+ t.Log(test.Set("page_view", "20"))
+ t.Log(test.Incr("page_view"))
+ t.Log(test.Get("page_view"))
+
+ t.Log(test.Set("page_view", "NaN"))
+ t.Log(test.Incr("page_view"))
+ t.Log(test.Get("page_view"))
+
+ test.Del("page_view")
+}
+
+func TestRedisClient_IncrBy(t *testing.T) {
+ t.Log(test.Set("rank", "50"))
+ t.Log(test.IncrBy("rank", 20))
+ t.Log(test.Get("rank"))
+ test.Del("rank")
+
+ t.Log(test.Exists("rank"))
+ t.Log(test.IncrBy("rank", 30))
+ t.Log(test.Get("rank"))
+
+ t.Log(test.Set("rank", "NaN"))
+ t.Log(test.IncrBy("rank", 200))
+ t.Log(test.Get("rank"))
+
+ test.Del("rank")
+}
+
+func TestRedisClient_IncrByFloat(t *testing.T) {
+ t.Log(test.Set("k", "10.50"))
+ t.Log(test.IncrByFloat("k", 0.1))
+
+ t.Log(test.Set("k", "314e-2"))
+ t.Log(test.IncrByFloat("k", 0))
+
+ t.Log(test.Set("k", "3"))
+ t.Log(test.IncrByFloat("k", 1.1))
+
+ t.Log(test.Set("k", "3.0"))
+ t.Log(test.Get("k"))
+ t.Log(test.IncrByFloat("k", 1.000000000000))
+ t.Log(test.Get("k"))
+
+ test.Del("k")
+}
+
+func TestRedisClient_Append(t *testing.T) {
+ t.Log(test.Exists("k"))
+ t.Log(test.Append("k", "nokia"))
+ t.Log(test.Append("k", " - 1110"))
+ t.Log(test.Get("k"))
+
+ test.Del("k")
+}
+
+func TestRedisClient_HDel(t *testing.T) {
+ t.Log(test.HSet("k", "f", "foo"))
+ t.Log(test.HDel("k", "f"))
+ t.Log(test.HDel("k", "b"))
+
+ test.Del("k")
+}
+func TestRedisClient_HExists(t *testing.T) {
+ t.Log(test.HSet("k", "f", "foo"))
+ t.Log(test.HExists("k", "f"))
+ t.Log(test.HExists("k", "b"))
+
+ test.Del("k")
+}
+func TestRedisClient_HGet(t *testing.T) {
+ t.Log(test.HSet("k", "redis", "redis.com"))
+ t.Log(test.HGet("k", "redis"))
+ t.Log(test.HGet("k", "mysql"))
+
+ test.Del("k")
+}
+func TestRedisClient_HGetAll(t *testing.T) {
+ t.Log(test.HSet("k", "f", "foo"))
+ t.Log(test.HSet("k", "b", "bar"))
+ t.Log(test.HGetAll("k"))
+
+ test.Del("k")
+}
+func TestRedisClient_HIncrBy(t *testing.T) {
+ t.Log(test.HSet("k", "f", 5))
+ t.Log(test.HIncrBy("k", "f", 1))
+ t.Log(test.HIncrBy("k", "f", -1))
+ t.Log(test.HIncrBy("k", "f", -10))
+
+ test.Del("k")
+}
+func TestRedisClient_HIncrByFloat(t *testing.T) {
+ t.Log(test.HSet("k", "f", 10.50))
+ t.Log(test.HIncrByFloat("k", "f", 0.1))
+ t.Log(test.HIncrByFloat("k", "f", -5))
+
+ t.Log(test.HSet("k", "f", "5.0e3"))
+ t.Log(test.HIncrByFloat("k", "f", 200))
+
+ test.Del("k")
+}
+func TestRedisClient_HKeys(t *testing.T) {
+ t.Log(test.HSet("k", "f", "foo"))
+ t.Log(test.HSet("k", "b", "bar"))
+ t.Log(test.HKeys("k"))
+
+ test.Del("k")
+
+ t.Log(test.HKeys("k"))
+}
+func TestRedisClient_HLen(t *testing.T) {
+ t.Log(test.HSet("k", "f", "foo"))
+ t.Log(test.HSet("k", "b", "bar"))
+ t.Log(test.HLen("k"))
+
+ test.Del("k")
+
+ t.Log(test.HLen("k"))
+}
+func TestRedisClient_HMGet(t *testing.T) {
+ t.Log(test.HSet("k", "f", "foo"))
+ t.Log(test.HSet("k", "b", "bar"))
+ t.Log(test.HMGet("k", "f", "n", "b"))
+
+ test.Del("k")
+}
+func TestRedisClient_HMSet(t *testing.T) {
+ t.Log(test.HMSet("k", [][2]interface{}{
+ {1, 1}, {2, 2},
+ }))
+
+ t.Log(test.HGet("k", 1))
+ t.Log(test.HGet("k", 2))
+ t.Log(test.HGet("k", 3))
+
+ test.Del("k")
+}
+func TestRedisClient_HSetNX(t *testing.T) {
+ t.Log(test.HSetNX("k", 1, 1))
+ t.Log(test.HSetNX("k", 1, 2))
+ t.Log(test.HGet("k", 1))
+
+ test.Del("k")
+}
+func TestRedisClient_HVals(t *testing.T) {
+ t.Log(test.HSet(1, 1, 1))
+ t.Log(test.HSet(1, 2, 2))
+ t.Log(test.HVals(1))
+
+ test.Del(1)
+
+ t.Log(test.HVals(1))
+}
+func TestRedisClient_LPush(t *testing.T) {
+ t.Log(test.LPush(1, 1))
+ t.Log(test.LPush(1, 2, 3))
+ t.Log(test.LRange(1, 0, -1))
+
+ test.Del(1)
+
+}
+func TestRedisClient_LIndex(t *testing.T) {
+ t.Log(test.LPush("k", "World", "Hello"))
+ t.Log(test.LIndex("k", 0))
+ t.Log(test.LIndex("k", -1))
+ t.Log(test.LIndex("k", 3))
+
+ test.Del("k")
+}
+func TestRedisClient_LRange(t *testing.T) {
+ t.Log(test.RPush("k", "hello"))
+ t.Log(test.RPush("k", "foo", "bar"))
+ t.Log(test.LRange("k", 0, 0))
+ t.Log(test.LRange("k", -3, 2))
+ t.Log(test.LRange("k", -100, 100))
+ t.Log(test.LRange("k", 5, 10))
+
+ test.Del("k")
+}
+func TestRedisClient_RPush(t *testing.T) {
+ t.Log(test.RPush("k", "hello"))
+ t.Log(test.RPush("k", "foo", "bar"))
+ t.Log(test.LRange("k", 0, -1))
+
+ test.Del("k")
+}
+func TestRedisClient_LLen(t *testing.T) {
+ test.RPush(1, 1, 1, 1, 1)
+ t.Log(test.LLen(1))
+
+ test.Del(1)
+}
+func TestRedisClient_LPop(t *testing.T) {
+ test.RPush(1, 1, 2, 3, 4)
+ t.Log(test.LPop(1))
+ t.Log(test.LPop(1))
+ t.Log(test.LPop(1))
+ t.Log(test.LPop(1))
+ t.Log(test.LPop(1))
+
+ test.Del(1)
+}
+func TestRedisClient_LSet(t *testing.T) {
+ test.RPush(1, 1, 2, 3, 4, 5, 6, 7)
+ t.Log(test.LSet(1, "foo", 4))
+ t.Log(test.LRange(1, 0, -1))
+
+ test.Del(1)
+}
+func TestRedisClient_RPop(t *testing.T) {
+ test.RPush(1, 1, 2, 3, 4, 5, 6, 7)
+ t.Log(test.RPop(1))
+ t.Log(test.RPop(1))
+ t.Log(test.RPop(1))
+ t.Log(test.RPop(1))
+ t.Log(test.RPop(1))
+ t.Log(test.RPop(1))
+ t.Log(test.RPop(1))
+ t.Log(test.RPop(1))
+ t.Log(test.RPop(1))
+ t.Log(test.RPop(1))
+
+ test.Del(1)
+}
+func TestRedisClient_SCard(t *testing.T) {
+ t.Log(test.SAdd(1, 1, 2, 3, 4, 5, 1, 2, 3))
+ t.Log(test.SCard(1))
+
+ test.Del(1)
+}
+func TestRedisClient_SDiff(t *testing.T) {
+ test.SAdd(1, 1, 2, 3)
+ test.SAdd(2, 3, 4, 5)
+ t.Log(test.SDiff(1, 2))
+
+ test.Del(1)
+ test.Del(2)
+}
+func TestRedisClient_SInter(t *testing.T) {
+ test.SAdd(1, 1, 2, 3)
+ test.SAdd(2, 3, 4, 5)
+ t.Log(test.SInter(1, 2))
+
+ test.Del(1)
+ test.Del(2)
+}
+func TestRedisClient_SIsMember(t *testing.T) {
+ test.SAdd(1, 1)
+ t.Log(test.SIsMember(1, 1))
+ t.Log(test.SIsMember(1, 2))
+
+ test.Del(1)
+}
+func TestRedisClient_SMembers(t *testing.T) {
+ test.SAdd(1, 1, 2, 3, 4)
+ t.Log(test.SMembers(1))
+
+ test.Del(1)
+}
+func TestRedisClient_SPop(t *testing.T) {
+ test.SAdd(1, 1, 2, 3, 4, 5)
+ t.Log(test.SPop(1))
+ t.Log(test.SPopN(1, 13))
+
+ test.Del(1)
+}
+func TestRedisClient_SRandMember(t *testing.T) {
+ test.SAdd(1, 1, 2, 3, 4, 5, 6)
+ t.Log(test.SRandMember(1))
+ t.Log(test.SRandMemberN(1, 3))
+
+ test.Del(1)
+}
+func TestRedisClient_SRem(t *testing.T) {
+ test.SAdd(1, 1, 2, 3, 4, 5, 6)
+ t.Log(test.SRem(1, 2))
+ t.Log(test.SRem(1, 2, 3, 4, 5))
+ t.Log(test.SMembers(1))
+
+ test.Del(1)
+}
+func TestRedisClient_SUnion(t *testing.T) {
+ test.SAdd(1, 1, 2, 3, 4, 5, 6)
+ test.SAdd(2, 4, 5, 6, 7, 8, 9)
+ t.Log(test.SUnion(1, 2))
+
+ test.Del(1)
+ test.Del(2)
+}
+func TestRedisClient_ZRange(t *testing.T) {
+ test.ZAdd(1, [][2]interface{}{
+ {1, 1},
+ {2, 2},
+ {3, 3},
+ {4, 4},
+ })
+ t.Log(test.ZRange(1, 0, -1))
+ t.Log(test.ZRangeWithScores(1, 0, -1))
+
+ t.Log(test.ZRange(1, 1, 2))
+ t.Log(test.ZRangeWithScores(1, 1, 2))
+
+ t.Log(test.ZRange(1, 0, 20000))
+ t.Log(test.ZRangeWithScores(1, 0, 20000))
+
+ t.Log(test.ZRange(1, 20000, 30000))
+ t.Log(test.ZRangeWithScores(1, 20000, 30000))
+
+ test.Del(1)
+}
+func TestRedisClient_ZCard(t *testing.T) {
+ test.ZAdd(1, [][2]interface{}{
+ {1, 1},
+ {2, 2},
+ {3, 3},
+ {4, 4},
+ })
+ t.Log(test.ZCard(1))
+
+ test.Del(1)
+}
+func TestRedisClient_ZCount(t *testing.T) {
+ test.ZAdd(1, [][2]interface{}{
+ {1, 1},
+ {2, 2},
+ {3, 3},
+ {4, 4},
+ })
+ t.Log(test.ZCount(1, 1, 3))
+
+ test.Del(1)
+}
+func TestRedisClient_ZIncrBy(t *testing.T) {
+ test.ZAdd(1, [][2]interface{}{
+ {1, 1},
+ {2, 2},
+ {3, 3},
+ {4, 4},
+ })
+ t.Log(test.ZIncrBy(1, 1, 3.4))
+ t.Log(test.ZRangeWithScores(1, 0, -1))
+
+ test.Del(1)
+}
+func TestRedisClient_ZRank(t *testing.T) {
+ test.ZAdd(1, [][2]interface{}{
+ {1, 1},
+ {2, 2},
+ {3, 3},
+ {4, 4},
+ })
+ t.Log(test.ZRangeWithScores(1, 0, -1))
+ t.Log(test.ZRank(1, 1))
+ t.Log(test.ZRevRank(1, 1))
+ t.Log(test.ZRank(1, 3))
+ t.Log(test.ZRevRank(1, 3))
+
+ test.Del(1)
+}
+func TestRedisClient_ZRem(t *testing.T) {
+ test.ZAdd(1, [][2]interface{}{
+ {1, 1},
+ {2, 2},
+ {3, 3},
+ {4, 4},
+ })
+
+ t.Log(test.ZRem(1, 1))
+ t.Log(test.ZRem(1, 1, 2, 3))
+ t.Log(test.ZRangeWithScores(1, 0, -1))
+
+ test.Del(1)
+}
+func TestRedisClient_ZRevRange(t *testing.T) {
+ test.ZAdd(1, [][2]interface{}{
+ {1, 1},
+ {2, 2},
+ {3, 3},
+ {4, 4},
+ })
+ t.Log(test.ZRevRange(1, 0, -1))
+ t.Log(test.ZRevRangeWithScores(1, 0, -1))
+
+ t.Log(test.ZRevRange(1, 1, 2))
+ t.Log(test.ZRevRangeWithScores(1, 1, 2))
+
+ t.Log(test.ZRevRange(1, 0, 20000))
+ t.Log(test.ZRevRangeWithScores(1, 0, 20000))
+
+ t.Log(test.ZRevRange(1, 20000, 30000))
+ t.Log(test.ZRevRangeWithScores(1, 20000, 30000))
+
+ test.Del(1)
+}
+func TestRedisClient_ZScore(t *testing.T) {
+ test.ZAdd(1, [][2]interface{}{
+ {1, 1},
+ {2, 2},
+ {3, 3},
+ {4, 4},
+ })
+ t.Log(test.ZRangeWithScores(1, 0, -1))
+ t.Log(test.ZScore(1, 1))
+ t.Log(test.ZScore(1, 3))
+
+ test.Del(1)
+}