re
/
redis
forked from mirror/redis
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Review API.

This commit is contained in:
Vladimir Mihailenco 2012-08-17 21:36:48 +03:00
parent df1b8a3f5c
commit 11e1783560
10 changed files with 818 additions and 621 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

77
README.md
View File

@ -20,21 +20,6 @@ Install:
go get github.com/vmihailenco/redis go get github.com/vmihailenco/redis
Contributing
------------
Configure Redis to allow maximum 10 clients:
maxclients 10
Run tests:
go test -gocheck.v
Run benchmarks:
go test -gocheck.b
Getting Client instance Getting Client instance
----------------------- -----------------------
@ -64,7 +49,7 @@ Example 2:
} }
initConn := func(client *redis.Client) error { initConn := func(client *redis.Client) error {
auth := client.Auth("foo") auth := client.Auth("key")
if auth.Err() != nil { if auth.Err() != nil {
return auth.Err() return auth.Err()
} }
@ -84,13 +69,13 @@ Both `closeConn` and `initConn` functions can be `nil`.
Running commands Running commands
---------------- ----------------
set := redisClient.Set("foo", "bar") set := redisClient.Set("key", "hello")
if set.Err() != nil { if set.Err() != nil {
panic(set.Err()) panic(set.Err())
} }
ok := set.Val() ok := set.Val()
get := redisClient.Get("foo") get := redisClient.Get("key")
if get.Err() != nil && get.Err() != redis.Nil { if get.Err() != nil && get.Err() != redis.Nil {
panic(get.Err()) panic(get.Err())
} }
@ -101,14 +86,27 @@ Pipelining
Client has ability to run commands in batches: Client has ability to run commands in batches:
reqs, err := redisClient.Pipelined(func(c *redis.PipelineClient) {
c.Set("key1", "hello1") // queue command SET
c.Set("key2", "hello2") // queue command SET
})
if err != nil {
panic(err)
}
for _, req := range reqs {
// ...
}
Or:
pipeline, err := redisClient.PipelineClient() pipeline, err := redisClient.PipelineClient()
if err != nil { if err != nil {
panic(err) panic(err)
} }
defer pipeline.Close() defer pipeline.Close()
setReq := pipeline.Set("foo1", "bar1") // queue command SET setReq := pipeline.Set("key1", "hello1") // queue command SET
getReq := pipeline.Get("foo2") // queue command GET getReq := pipeline.Get("key2") // queue command GET
reqs, err := pipeline.RunQueued() // run queued commands reqs, err := pipeline.RunQueued() // run queued commands
if err != nil { if err != nil {
@ -132,13 +130,13 @@ Multi/Exec
Example: Example:
func transaction(multi *redis.MultiClient) ([]redis.Req, error) { func transaction(multi *redis.MultiClient) ([]redis.Req, error) {
get := multiClient.Get("foo") get := multiClient.Get("key")
if get.Err() != nil { if get.Err() != nil {
panic(get.Err()) panic(get.Err())
} }
reqs, err = multiClient.Exec(func() { reqs, err = multiClient.Exec(func() {
multi.Set("foo", get.Val() + "1") multi.Set("key", get.Val() + "1")
}) })
if err == redis.Nil { if err == redis.Nil {
return transaction() return transaction()
@ -153,7 +151,7 @@ Example:
} }
defer multiClient.Close() defer multiClient.Close()
watch := multiClient.Watch("foo") watch := multiClient.Watch("key")
if watch.Err() != nil { if watch.Err() != nil {
panic(watch.Err()) panic(watch.Err())
} }
@ -205,7 +203,7 @@ Commands are thread safe. Following code is correct:
for i := 0; i < 1000; i++ { for i := 0; i < 1000; i++ {
go func() { go func() {
redisClient.Incr("foo") redisClient.Incr("key")
}() }()
} }
@ -220,7 +218,7 @@ Example:
return req return req
} }
get := Get(redisClient, "foo") get := Get(redisClient, "key")
if get.Err() != nil && get.Err() != redis.Nil { if get.Err() != nil && get.Err() != redis.Nil {
panic(get.Err()) panic(get.Err())
} }
@ -231,3 +229,32 @@ Connection pool
Client uses connection pool with default capacity of 10 connections. To change pool capacity: Client uses connection pool with default capacity of 10 connections. To change pool capacity:
redisClient.ConnPool.(*redis.MultiConnPool).MaxCap = 1 redisClient.ConnPool.(*redis.MultiConnPool).MaxCap = 1
Look and feel
-------------
Some corner cases:
SORT list LIMIT 0 2 ASC
client.Sort("list", redis.Sort{Offset: 0, Count: 2, Order: "ASC"})
ZRANGEBYSCORE zset -inf +inf WITHSCORES LIMIT 0 2
client.ZRangeByScoreWithScores("zset", "-inf", "+inf", 0, 2)
ZINTERSTORE out 2 zset1 zset2 WEIGHTS 2 3 AGGREGATE SUM
client.ZInterStore("out", 2, redis.ZStore{Weights: []int64{2, 3}}, "zset1", "zset2")
Contributing
------------
Configure Redis to allow maximum 10 clients:
maxclients 10
Run tests:
go test -gocheck.v
Run benchmarks:
go test -gocheck.b

301
commands.go
View File

@ -4,14 +4,8 @@ import (
"strconv" "strconv"
) )
//------------------------------------------------------------------------------ func formatFloat(f float64) string {
return strconv.FormatFloat(f, 'f', -1, 32)
type Limit struct {
Offset, Count int64
}
func NewLimit(offset, count int64) *Limit {
return &Limit{offset, count}
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
@ -22,8 +16,8 @@ func (c *Client) Auth(password string) *StatusReq {
return req return req
} }
func (c *Client) Echo(message string) *BulkReq { func (c *Client) Echo(message string) *StringReq {
req := NewBulkReq("ECHO", message) req := NewStringReq("ECHO", message)
c.Process(req) c.Process(req)
return req return req
} }
@ -49,8 +43,8 @@ func (c *Client) Del(keys ...string) *IntReq {
return req return req
} }
func (c *Client) Dump(key string) *BulkReq { func (c *Client) Dump(key string) *StringReq {
req := NewBulkReq("DUMP", key) req := NewStringReq("DUMP", key)
c.Process(req) c.Process(req)
return req return req
} }
@ -73,19 +67,19 @@ func (c *Client) ExpireAt(key string, timestamp int64) *BoolReq {
return req return req
} }
func (c *Client) Keys(pattern string) *MultiBulkReq { func (c *Client) Keys(pattern string) *StringSliceReq {
req := NewMultiBulkReq("KEYS", pattern) req := NewStringSliceReq("KEYS", pattern)
c.Process(req) c.Process(req)
return req return req
} }
func (c *Client) Migrate(host string, port int32, key, db string, timeout int64) *StatusReq { func (c *Client) Migrate(host, port, key string, db, timeout int64) *StatusReq {
req := NewStatusReq( req := NewStatusReq(
"MIGRATE", "MIGRATE",
host, host,
strconv.FormatInt(int64(port), 10), port,
key, key,
db, strconv.FormatInt(db, 10),
strconv.FormatInt(timeout, 10), strconv.FormatInt(timeout, 10),
) )
c.Process(req) c.Process(req)
@ -105,9 +99,9 @@ func (c *Client) ObjectRefCount(keys ...string) *IntReq {
return req return req
} }
func (c *Client) ObjectEncoding(keys ...string) *BulkReq { func (c *Client) ObjectEncoding(keys ...string) *StringReq {
args := append([]string{"OBJECT", "ENCODING"}, keys...) args := append([]string{"OBJECT", "ENCODING"}, keys...)
req := NewBulkReq(args...) req := NewStringReq(args...)
c.Process(req) c.Process(req)
return req return req
} }
@ -143,8 +137,8 @@ func (c *Client) PTTL(key string) *IntReq {
return req return req
} }
func (c *Client) RandomKey() *BulkReq { func (c *Client) RandomKey() *StringReq {
req := NewBulkReq("RANDOMKEY") req := NewStringReq("RANDOMKEY")
c.Process(req) c.Process(req)
return req return req
} }
@ -161,9 +155,10 @@ func (c *Client) RenameNX(key, newkey string) *BoolReq {
return req return req
} }
func (c *Client) Restore(key, ttl int64, value string) *StatusReq { func (c *Client) Restore(key string, ttl int64, value string) *StatusReq {
req := NewStatusReq( req := NewStatusReq(
"RESTORE", "RESTORE",
key,
strconv.FormatInt(ttl, 10), strconv.FormatInt(ttl, 10),
value, value,
) )
@ -171,9 +166,36 @@ func (c *Client) Restore(key, ttl int64, value string) *StatusReq {
return req return req
} }
func (c *Client) Sort(key string, params ...string) *MultiBulkReq { type Sort struct {
args := append([]string{"SORT", key}, params...) By string
req := NewMultiBulkReq(args...) Offset, Count float64
Get []string
Order string
IsAlpha bool
Store string
}
func (c *Client) Sort(key string, sort Sort) *StringSliceReq {
args := []string{"SORT", key}
if sort.By != "" {
args = append(args, sort.By)
}
if sort.Offset != 0 || sort.Count != 0 {
args = append(args, "LIMIT", formatFloat(sort.Offset), formatFloat(sort.Count))
}
for _, get := range sort.Get {
args = append(args, "GET", get)
}
if sort.Order != "" {
args = append(args, sort.Order)
}
if sort.IsAlpha {
args = append(args, "ALPHA")
}
if sort.Store != "" {
args = append(args, "STORE", sort.Store)
}
req := NewStringSliceReq(args...)
c.Process(req) c.Process(req)
return req return req
} }
@ -214,8 +236,8 @@ func (c *Client) DecrBy(key string, decrement int64) *IntReq {
return req return req
} }
func (c *Client) Get(key string) *BulkReq { func (c *Client) Get(key string) *StringReq {
req := NewBulkReq("GET", key) req := NewStringReq("GET", key)
c.Process(req) c.Process(req)
return req return req
} }
@ -226,8 +248,8 @@ func (c *Client) GetBit(key string, offset int64) *IntReq {
return req return req
} }
func (c *Client) GetRange(key string, start, end int64) *BulkReq { func (c *Client) GetRange(key string, start, end int64) *StringReq {
req := NewBulkReq( req := NewStringReq(
"GETRANGE", "GETRANGE",
key, key,
strconv.FormatInt(start, 10), strconv.FormatInt(start, 10),
@ -237,8 +259,8 @@ func (c *Client) GetRange(key string, start, end int64) *BulkReq {
return req return req
} }
func (c *Client) GetSet(key, value string) *BulkReq { func (c *Client) GetSet(key, value string) *StringReq {
req := NewBulkReq("GETSET", key, value) req := NewStringReq("GETSET", key, value)
c.Process(req) c.Process(req)
return req return req
} }
@ -257,9 +279,9 @@ func (c *Client) IncrBy(key string, value int64) *IntReq {
// incrbyfloat // incrbyfloat
func (c *Client) MGet(keys ...string) *MultiBulkReq { func (c *Client) MGet(keys ...string) *IfaceSliceReq {
args := append([]string{"MGET"}, keys...) args := append([]string{"MGET"}, keys...)
req := NewMultiBulkReq(args...) req := NewIfaceSliceReq(args...)
c.Process(req) c.Process(req)
return req return req
} }
@ -345,14 +367,14 @@ func (c *Client) HExists(key, field string) *BoolReq {
return req return req
} }
func (c *Client) HGet(key, field string) *BulkReq { func (c *Client) HGet(key, field string) *StringReq {
req := NewBulkReq("HGET", key, field) req := NewStringReq("HGET", key, field)
c.Process(req) c.Process(req)
return req return req
} }
func (c *Client) HGetAll(key string) *MultiBulkReq { func (c *Client) HGetAll(key string) *StringSliceReq {
req := NewMultiBulkReq("HGETALL", key) req := NewStringSliceReq("HGETALL", key)
c.Process(req) c.Process(req)
return req return req
} }
@ -363,10 +385,14 @@ func (c *Client) HIncrBy(key, field string, incr int64) *IntReq {
return req return req
} }
// hincrbyfloat func (c *Client) HIncrByFloat(key, field string, incr float64) *FloatReq {
req := NewFloatReq("HINCRBYFLOAT", key, field, formatFloat(incr))
c.Process(req)
return req
}
func (c *Client) HKeys(key string) *MultiBulkReq { func (c *Client) HKeys(key string) *StringSliceReq {
req := NewMultiBulkReq("HKEYS", key) req := NewStringSliceReq("HKEYS", key)
c.Process(req) c.Process(req)
return req return req
} }
@ -377,9 +403,9 @@ func (c *Client) HLen(key string) *IntReq {
return req return req
} }
func (c *Client) HMGet(key string, fields ...string) *MultiBulkReq { func (c *Client) HMGet(key string, fields ...string) *IfaceSliceReq {
args := append([]string{"HMGET", key}, fields...) args := append([]string{"HMGET", key}, fields...)
req := NewMultiBulkReq(args...) req := NewIfaceSliceReq(args...)
c.Process(req) c.Process(req)
return req return req
} }
@ -403,32 +429,32 @@ func (c *Client) HSetNX(key, field, value string) *BoolReq {
return req return req
} }
func (c *Client) HVals(key string) *MultiBulkReq { func (c *Client) HVals(key string) *StringSliceReq {
req := NewMultiBulkReq("HVALS", key) req := NewStringSliceReq("HVALS", key)
c.Process(req) c.Process(req)
return req return req
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
func (c *Client) BLPop(timeout int64, keys ...string) *MultiBulkReq { func (c *Client) BLPop(timeout int64, keys ...string) *StringSliceReq {
args := append([]string{"BLPOP"}, keys...) args := append([]string{"BLPOP"}, keys...)
args = append(args, strconv.FormatInt(timeout, 10)) args = append(args, strconv.FormatInt(timeout, 10))
req := NewMultiBulkReq(args...) req := NewStringSliceReq(args...)
c.Process(req) c.Process(req)
return req return req
} }
func (c *Client) BRPop(timeout int64, keys ...string) *MultiBulkReq { func (c *Client) BRPop(timeout int64, keys ...string) *StringSliceReq {
args := append([]string{"BRPOP"}, keys...) args := append([]string{"BRPOP"}, keys...)
args = append(args, strconv.FormatInt(timeout, 10)) args = append(args, strconv.FormatInt(timeout, 10))
req := NewMultiBulkReq(args...) req := NewStringSliceReq(args...)
c.Process(req) c.Process(req)
return req return req
} }
func (c *Client) BRPopLPush(source, destination string, timeout int64) *BulkReq { func (c *Client) BRPopLPush(source, destination string, timeout int64) *StringReq {
req := NewBulkReq( req := NewStringReq(
"BRPOPLPUSH", "BRPOPLPUSH",
source, source,
destination, destination,
@ -438,8 +464,8 @@ func (c *Client) BRPopLPush(source, destination string, timeout int64) *BulkReq
return req return req
} }
func (c *Client) LIndex(key string, index int64) *BulkReq { func (c *Client) LIndex(key string, index int64) *StringReq {
req := NewBulkReq("LINDEX", key, strconv.FormatInt(index, 10)) req := NewStringReq("LINDEX", key, strconv.FormatInt(index, 10))
c.Process(req) c.Process(req)
return req return req
} }
@ -456,8 +482,8 @@ func (c *Client) LLen(key string) *IntReq {
return req return req
} }
func (c *Client) LPop(key string) *BulkReq { func (c *Client) LPop(key string) *StringReq {
req := NewBulkReq("LPOP", key) req := NewStringReq("LPOP", key)
c.Process(req) c.Process(req)
return req return req
} }
@ -475,8 +501,8 @@ func (c *Client) LPushX(key, value string) *IntReq {
return req return req
} }
func (c *Client) LRange(key string, start, stop int64) *MultiBulkReq { func (c *Client) LRange(key string, start, stop int64) *StringSliceReq {
req := NewMultiBulkReq( req := NewStringSliceReq(
"LRANGE", "LRANGE",
key, key,
strconv.FormatInt(start, 10), strconv.FormatInt(start, 10),
@ -509,14 +535,14 @@ func (c *Client) LTrim(key string, start, stop int64) *StatusReq {
return req return req
} }
func (c *Client) RPop(key string) *BulkReq { func (c *Client) RPop(key string) *StringReq {
req := NewBulkReq("RPOP", key) req := NewStringReq("RPOP", key)
c.Process(req) c.Process(req)
return req return req
} }
func (c *Client) RPopLPush(source, destination string) *BulkReq { func (c *Client) RPopLPush(source, destination string) *StringReq {
req := NewBulkReq("RPOPLPUSH", source, destination) req := NewStringReq("RPOPLPUSH", source, destination)
c.Process(req) c.Process(req)
return req return req
} }
@ -549,9 +575,9 @@ func (c *Client) SCard(key string) *IntReq {
return req return req
} }
func (c *Client) SDiff(keys ...string) *MultiBulkReq { func (c *Client) SDiff(keys ...string) *StringSliceReq {
args := append([]string{"SDIFF"}, keys...) args := append([]string{"SDIFF"}, keys...)
req := NewMultiBulkReq(args...) req := NewStringSliceReq(args...)
c.Process(req) c.Process(req)
return req return req
} }
@ -563,9 +589,9 @@ func (c *Client) SDiffStore(destination string, keys ...string) *IntReq {
return req return req
} }
func (c *Client) SInter(keys ...string) *MultiBulkReq { func (c *Client) SInter(keys ...string) *StringSliceReq {
args := append([]string{"SINTER"}, keys...) args := append([]string{"SINTER"}, keys...)
req := NewMultiBulkReq(args...) req := NewStringSliceReq(args...)
c.Process(req) c.Process(req)
return req return req
} }
@ -583,8 +609,8 @@ func (c *Client) SIsMember(key, member string) *BoolReq {
return req return req
} }
func (c *Client) SMembers(key string) *MultiBulkReq { func (c *Client) SMembers(key string) *StringSliceReq {
req := NewMultiBulkReq("SMEMBERS", key) req := NewStringSliceReq("SMEMBERS", key)
c.Process(req) c.Process(req)
return req return req
} }
@ -595,14 +621,14 @@ func (c *Client) SMove(source, destination, member string) *BoolReq {
return req return req
} }
func (c *Client) SPop(key string) *BulkReq { func (c *Client) SPop(key string) *StringReq {
req := NewBulkReq("SPOP", key) req := NewStringReq("SPOP", key)
c.Process(req) c.Process(req)
return req return req
} }
func (c *Client) SRandMember(key string) *BulkReq { func (c *Client) SRandMember(key string) *StringReq {
req := NewBulkReq("SRANDMEMBER", key) req := NewStringReq("SRANDMEMBER", key)
c.Process(req) c.Process(req)
return req return req
} }
@ -614,9 +640,9 @@ func (c *Client) SRem(key string, members ...string) *IntReq {
return req return req
} }
func (c *Client) SUnion(keys ...string) *MultiBulkReq { func (c *Client) SUnion(keys ...string) *StringSliceReq {
args := append([]string{"SUNION"}, keys...) args := append([]string{"SUNION"}, keys...)
req := NewMultiBulkReq(args...) req := NewStringSliceReq(args...)
c.Process(req) c.Process(req)
return req return req
} }
@ -630,20 +656,21 @@ func (c *Client) SUnionStore(destination string, keys ...string) *IntReq {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
type ZMember struct { type Z struct {
Score float64 Score float64
Member string Member string
} }
func NewZMember(score float64, member string) *ZMember { type ZStore struct {
return &ZMember{score, member} Weights []int64
Aggregate string
} }
func (m *ZMember) ScoreString() string { func (m *Z) ScoreString() string {
return strconv.FormatFloat(m.Score, 'f', -1, 32) return formatFloat(m.Score)
} }
func (c *Client) ZAdd(key string, members ...*ZMember) *IntReq { func (c *Client) ZAdd(key string, members ...Z) *IntReq {
args := []string{"ZADD", key} args := []string{"ZADD", key}
for _, m := range members { for _, m := range members {
args = append(args, m.ScoreString(), m.Member) args = append(args, m.ScoreString(), m.Member)
@ -665,8 +692,8 @@ func (c *Client) ZCount(key, min, max string) *IntReq {
return req return req
} }
func (c *Client) ZIncrBy(key string, increment int64, member string) *FloatReq { func (c *Client) ZIncrBy(key string, increment float64, member string) *FloatReq {
req := NewFloatReq("ZINCRBY", key, strconv.FormatInt(increment, 10), member) req := NewFloatReq("ZINCRBY", key, formatFloat(increment), member)
c.Process(req) c.Process(req)
return req return req
} }
@ -674,27 +701,26 @@ func (c *Client) ZIncrBy(key string, increment int64, member string) *FloatReq {
func (c *Client) ZInterStore( func (c *Client) ZInterStore(
destination string, destination string,
numkeys int64, numkeys int64,
keys []string, store ZStore,
weights []int64, keys ...string,
aggregate string,
) *IntReq { ) *IntReq {
args := []string{"ZINTERSTORE", destination, strconv.FormatInt(numkeys, 10)} args := []string{"ZINTERSTORE", destination, strconv.FormatInt(numkeys, 10)}
args = append(args, keys...) args = append(args, keys...)
if weights != nil { if len(store.Weights) > 0 {
args = append(args, "WEIGHTS") args = append(args, "WEIGHTS")
for _, w := range weights { for _, weight := range store.Weights {
args = append(args, strconv.FormatInt(w, 10)) args = append(args, strconv.FormatInt(weight, 10))
} }
} }
if aggregate != "" { if store.Aggregate != "" {
args = append(args, "AGGREGATE", aggregate) args = append(args, "AGGREGATE", store.Aggregate)
} }
req := NewIntReq(args...) req := NewIntReq(args...)
c.Process(req) c.Process(req)
return req return req
} }
func (c *Client) ZRange(key string, start, stop int64, withScores bool) *MultiBulkReq { func (c *Client) zRange(key string, start, stop int64, withScores bool) *StringSliceReq {
args := []string{ args := []string{
"ZRANGE", "ZRANGE",
key, key,
@ -704,34 +730,50 @@ func (c *Client) ZRange(key string, start, stop int64, withScores bool) *MultiBu
if withScores { if withScores {
args = append(args, "WITHSCORES") args = append(args, "WITHSCORES")
} }
req := NewMultiBulkReq(args...) req := NewStringSliceReq(args...)
c.Process(req) c.Process(req)
return req return req
} }
func (c *Client) ZRangeByScore( func (c *Client) ZRange(key string, start, stop int64) *StringSliceReq {
return c.zRange(key, start, stop, false)
}
func (c *Client) ZRangeWithScores(key string, start, stop int64) *StringSliceReq {
return c.zRange(key, start, stop, true)
}
func (c *Client) zRangeByScore(
key string, key string,
min, max string, min, max string,
withScores bool, withScores bool,
limit *Limit, offset, count int64,
) *MultiBulkReq { ) *StringSliceReq {
args := []string{"ZRANGEBYSCORE", key, min, max} args := []string{"ZRANGEBYSCORE", key, min, max}
if withScores { if withScores {
args = append(args, "WITHSCORES") args = append(args, "WITHSCORES")
} }
if limit != nil { if offset != 0 || count != 0 {
args = append( args = append(
args, args,
"LIMIT", "LIMIT",
strconv.FormatInt(limit.Offset, 10), strconv.FormatInt(offset, 10),
strconv.FormatInt(limit.Count, 10), strconv.FormatInt(count, 10),
) )
} }
req := NewMultiBulkReq(args...) req := NewStringSliceReq(args...)
c.Process(req) c.Process(req)
return req return req
} }
func (c *Client) ZRangeByScore(key string, min, max string, offset, count int64) *StringSliceReq {
return c.zRangeByScore(key, min, max, false, offset, count)
}
func (c *Client) ZRangeByScoreWithScores(key string, min, max string, offset, count int64) *StringSliceReq {
return c.zRangeByScore(key, min, max, true, offset, count)
}
func (c *Client) ZRank(key, member string) *IntReq { func (c *Client) ZRank(key, member string) *IntReq {
req := NewIntReq("ZRANK", key, member) req := NewIntReq("ZRANK", key, member)
c.Process(req) c.Process(req)
@ -762,38 +804,50 @@ func (c *Client) ZRemRangeByScore(key, min, max string) *IntReq {
return req return req
} }
func (c *Client) ZRevRange(key, start, stop string, withScores bool) *MultiBulkReq { func (c *Client) zRevRange(key, start, stop string, withScores bool) *StringSliceReq {
args := []string{"ZREVRANGE", key, start, stop} args := []string{"ZREVRANGE", key, start, stop}
if withScores { if withScores {
args = append(args, "WITHSCORES") args = append(args, "WITHSCORES")
} }
req := NewMultiBulkReq(args...) req := NewStringSliceReq(args...)
c.Process(req) c.Process(req)
return req return req
} }
func (c *Client) ZRevRangeByScore( func (c *Client) ZRevRange(key, start, stop string) *StringSliceReq {
key, start, stop string, return c.zRevRange(key, start, stop, false)
withScores bool, }
limit *Limit,
) *MultiBulkReq { func (c *Client) ZRevRangeWithScores(key, start, stop string) *StringSliceReq {
return c.zRevRange(key, start, stop, true)
}
func (c *Client) zRevRangeByScore(key, start, stop string, withScores bool, offset, count int64) *StringSliceReq {
args := []string{"ZREVRANGEBYSCORE", key, start, stop} args := []string{"ZREVRANGEBYSCORE", key, start, stop}
if withScores { if withScores {
args = append(args, "WITHSCORES") args = append(args, "WITHSCORES")
} }
if limit != nil { if offset != 0 || count != 0 {
args = append( args = append(
args, args,
"LIMIT", "LIMIT",
strconv.FormatInt(limit.Offset, 10), strconv.FormatInt(offset, 10),
strconv.FormatInt(limit.Count, 10), strconv.FormatInt(count, 10),
) )
} }
req := NewMultiBulkReq(args...) req := NewStringSliceReq(args...)
c.Process(req) c.Process(req)
return req return req
} }
func (c *Client) ZRevRangeByScore(key, start, stop string, offset, count int64) *StringSliceReq {
return c.zRevRangeByScore(key, start, stop, false, offset, count)
}
func (c *Client) ZRevRangeByScoreWithScores(key, start, stop string, offset, count int64) *StringSliceReq {
return c.zRevRangeByScore(key, start, stop, false, offset, count)
}
func (c *Client) ZRevRank(key, member string) *IntReq { func (c *Client) ZRevRank(key, member string) *IntReq {
req := NewIntReq("ZREVRANK", key, member) req := NewIntReq("ZREVRANK", key, member)
c.Process(req) c.Process(req)
@ -809,20 +863,19 @@ func (c *Client) ZScore(key, member string) *FloatReq {
func (c *Client) ZUnionStore( func (c *Client) ZUnionStore(
destination string, destination string,
numkeys int64, numkeys int64,
keys []string, store ZStore,
weights []int64, keys ...string,
aggregate string,
) *IntReq { ) *IntReq {
args := []string{"ZUNIONSTORE", destination, strconv.FormatInt(numkeys, 10)} args := []string{"ZUNIONSTORE", destination, strconv.FormatInt(numkeys, 10)}
args = append(args, keys...) args = append(args, keys...)
if weights != nil { if len(store.Weights) > 0 {
args = append(args, "WEIGHTS") args = append(args, "WEIGHTS")
for _, w := range weights { for _, weight := range store.Weights {
args = append(args, strconv.FormatInt(w, 10)) args = append(args, strconv.FormatInt(weight, 10))
} }
} }
if aggregate != "" { if store.Aggregate != "" {
args = append(args, "AGGREGATE", aggregate) args = append(args, "AGGREGATE", store.Aggregate)
} }
req := NewIntReq(args...) req := NewIntReq(args...)
c.Process(req) c.Process(req)
@ -849,14 +902,14 @@ func (c *Client) ClientKill(ipPort string) *StatusReq {
return req return req
} }
func (c *Client) ClientList() *BulkReq { func (c *Client) ClientList() *StringReq {
req := NewBulkReq("CLIENT", "LIST") req := NewStringReq("CLIENT", "LIST")
c.Process(req) c.Process(req)
return req return req
} }
func (c *Client) ConfigGet(parameter string) *MultiBulkReq { func (c *Client) ConfigGet(parameter string) *StringSliceReq {
req := NewMultiBulkReq("CONFIG", "GET", parameter) req := NewStringSliceReq("CONFIG", "GET", parameter)
c.Process(req) c.Process(req)
return req return req
} }
@ -891,8 +944,8 @@ func (c *Client) FlushDb() *StatusReq {
return req return req
} }
func (c *Client) Info() *BulkReq { func (c *Client) Info() *StringReq {
req := NewBulkReq("INFO") req := NewStringReq("INFO")
c.Process(req) c.Process(req)
return req return req
} }
@ -931,8 +984,8 @@ func (c *Client) Sync() {
panic("not implemented") panic("not implemented")
} }
func (c *Client) Time() *MultiBulkReq { func (c *Client) Time() *StringSliceReq {
req := NewMultiBulkReq("TIME") req := NewStringSliceReq("TIME")
c.Process(req) c.Process(req)
return req return req
} }

10
connpool.go
View File

@ -10,16 +10,14 @@ import (
) )
type Conn struct { type Conn struct {
RW io.ReadWriteCloser RW io.ReadWriteCloser
Rd *bufio.Reader Rd reader
ReqBuf []byte
} }
func NewConn(rw io.ReadWriteCloser) *Conn { func NewConn(rw io.ReadWriteCloser) *Conn {
return &Conn{ return &Conn{
RW: rw, RW: rw,
Rd: bufio.NewReaderSize(rw, 1024), Rd: bufio.NewReaderSize(rw, 1024),
ReqBuf: make([]byte, 0, 1024),
} }
} }

2
multi.go
View File

@ -45,7 +45,7 @@ func (c *MultiClient) Exec(do func()) ([]Req, error) {
do() do()
c.mtx.Lock() c.mtx.Lock()
c.reqs = append(c.reqs, NewMultiBulkReq("EXEC")) c.reqs = append(c.reqs, NewIfaceSliceReq("EXEC"))
if len(c.reqs) == 2 { if len(c.reqs) == 2 {
c.mtx.Unlock() c.mtx.Unlock()
return []Req{}, nil return []Req{}, nil

109
parser.go
View File

@ -21,7 +21,7 @@ var (
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
func AppendReq(buf []byte, args []string) []byte { func appendReq(buf []byte, args []string) []byte {
buf = append(buf, '*') buf = append(buf, '*')
buf = strconv.AppendUint(buf, uint64(len(args)), 10) buf = strconv.AppendUint(buf, uint64(len(args)), 10)
buf = append(buf, '\r', '\n') buf = append(buf, '\r', '\n')
@ -37,13 +37,14 @@ func AppendReq(buf []byte, args []string) []byte {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
type ReadLiner interface { type reader interface {
ReadLine() ([]byte, bool, error) ReadLine() ([]byte, bool, error)
Read([]byte) (int, error) Read([]byte) (int, error)
ReadN(n int) ([]byte, error) ReadN(n int) ([]byte, error)
Buffered() int
} }
func readLine(rd ReadLiner) ([]byte, error) { func readLine(rd reader) ([]byte, error) {
line, isPrefix, err := rd.ReadLine() line, isPrefix, err := rd.ReadLine()
if err != nil { if err != nil {
return line, err return line, err
@ -56,42 +57,15 @@ func readLine(rd ReadLiner) ([]byte, error) {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
func ParseReq(rd ReadLiner) ([]string, error) { func parseReply(rd reader) (interface{}, error) {
line, err := readLine(rd) return _parseReply(rd, false)
if err != nil {
return nil, err
}
if line[0] != '*' {
return []string{string(line)}, nil
}
numReplies, err := strconv.ParseInt(string(line[1:]), 10, 64)
if err != nil {
return nil, err
}
args := make([]string, 0)
for i := int64(0); i < numReplies; i++ {
line, err = readLine(rd)
if err != nil {
return nil, err
}
if line[0] != '$' {
return nil, fmt.Errorf("Expected '$', but got %q", line)
}
line, err = readLine(rd)
if err != nil {
return nil, err
}
args = append(args, string(line))
}
return args, nil
} }
//------------------------------------------------------------------------------ func parseIfaceSliceReply(rd reader) (interface{}, error) {
return _parseReply(rd, true)
}
func ParseReply(rd ReadLiner) (interface{}, error) { func _parseReply(rd reader, useIfaceSlice bool) (interface{}, error) {
line, err := readLine(rd) line, err := readLine(rd)
if err != nil { if err != nil {
return 0, err return 0, err
@ -139,28 +113,51 @@ func ParseReply(rd ReadLiner) (interface{}, error) {
return nil, Nil return nil, Nil
} }
val := make([]interface{}, 0) if useIfaceSlice {
if len(line) == 2 && line[1] == '0' { vals := make([]interface{}, 0)
return val, nil if len(line) == 2 && line[1] == '0' {
} return vals, nil
numReplies, err := strconv.ParseInt(string(line[1:]), 10, 64)
if err != nil {
return nil, err
}
for i := int64(0); i < numReplies; i++ {
v, err := ParseReply(rd)
if err == Nil {
val = append(val, nil)
} else if err != nil {
return nil, err
} else {
val = append(val, v)
} }
}
return val, nil numReplies, err := strconv.ParseInt(string(line[1:]), 10, 64)
if err != nil {
return nil, err
}
for i := int64(0); i < numReplies; i++ {
v, err := parseReply(rd)
if err == Nil {
vals = append(vals, nil)
} else if err != nil {
return nil, err
} else {
vals = append(vals, v)
}
}
return vals, nil
} else {
vals := make([]string, 0)
if len(line) == 2 && line[1] == '0' {
return vals, nil
}
numReplies, err := strconv.ParseInt(string(line[1:]), 10, 64)
if err != nil {
return nil, err
}
for i := int64(0); i < numReplies; i++ {
v, err := parseReply(rd)
if err != nil {
return nil, err
} else {
vals = append(vals, v.(string))
}
}
return vals, nil
}
default: default:
return nil, fmt.Errorf("redis: can't parse %q", line) return nil, fmt.Errorf("redis: can't parse %q", line)
} }

10
pipeline.go
View File

@ -16,6 +16,16 @@ func (c *Client) PipelineClient() (*PipelineClient, error) {
}, nil }, nil
} }
func (c *Client) Pipelined(do func(*PipelineClient)) ([]Req, error) {
pc, err := c.PipelineClient()
if err != nil {
return nil, err
}
defer pc.Close()
do(pc)
return pc.RunQueued()
}
func (c *PipelineClient) Close() error { func (c *PipelineClient) Close() error {
return nil return nil
} }

16
pubsub.go
View File

@ -11,20 +11,16 @@ type PubSubClient struct {
once sync.Once once sync.Once
} }
func newPubSubClient(client *Client) (*PubSubClient, error) { func (c *Client) PubSubClient() (*PubSubClient, error) {
return &PubSubClient{ return &PubSubClient{
BaseClient: &BaseClient{ BaseClient: &BaseClient{
ConnPool: NewSingleConnPool(client.ConnPool, false), ConnPool: NewSingleConnPool(c.ConnPool, false),
InitConn: client.InitConn, InitConn: c.InitConn,
}, },
ch: make(chan *Message), ch: make(chan *Message),
}, nil }, nil
} }
func (c *Client) PubSubClient() (*PubSubClient, error) {
return newPubSubClient(c)
}
func (c *Client) Publish(channel, message string) *IntReq { func (c *Client) Publish(channel, message string) *IntReq {
req := NewIntReq("PUBLISH", channel, message) req := NewIntReq("PUBLISH", channel, message)
c.Process(req) c.Process(req)
@ -39,7 +35,7 @@ type Message struct {
} }
func (c *PubSubClient) consumeMessages(conn *Conn) { func (c *PubSubClient) consumeMessages(conn *Conn) {
req := NewMultiBulkReq() req := NewIfaceSliceReq()
for { for {
for { for {
@ -82,7 +78,7 @@ func (c *PubSubClient) consumeMessages(conn *Conn) {
func (c *PubSubClient) subscribe(cmd string, channels ...string) (chan *Message, error) { func (c *PubSubClient) subscribe(cmd string, channels ...string) (chan *Message, error) {
args := append([]string{cmd}, channels...) args := append([]string{cmd}, channels...)
req := NewMultiBulkReq(args...) req := NewIfaceSliceReq(args...)
conn, err := c.conn() conn, err := c.conn()
if err != nil { if err != nil {
@ -110,7 +106,7 @@ func (c *PubSubClient) PSubscribe(patterns ...string) (chan *Message, error) {
func (c *PubSubClient) unsubscribe(cmd string, channels ...string) error { func (c *PubSubClient) unsubscribe(cmd string, channels ...string) error {
args := append([]string{cmd}, channels...) args := append([]string{cmd}, channels...)
req := NewMultiBulkReq(args...) req := NewIfaceSliceReq(args...)
conn, err := c.conn() conn, err := c.conn()
if err != nil { if err != nil {

6
redis.go
View File

@ -57,12 +57,12 @@ type BaseClient struct {
} }
func (c *BaseClient) WriteReq(conn *Conn, reqs ...Req) error { func (c *BaseClient) WriteReq(conn *Conn, reqs ...Req) error {
conn.ReqBuf = conn.ReqBuf[:0] buf := make([]byte, 0, 1000)
for _, req := range reqs { for _, req := range reqs {
conn.ReqBuf = AppendReq(conn.ReqBuf, req.Args()) buf = appendReq(buf, req.Args())
} }
_, err := conn.RW.Write(conn.ReqBuf) _, err := conn.RW.Write(buf)
return err return err
} }

851
redis_test.go
View File

File diff suppressed because it is too large Load Diff

57
request.go
View File

@ -6,11 +6,11 @@ import (
type Req interface { type Req interface {
Args() []string Args() []string
ParseReply(ReadLiner) (interface{}, error) ParseReply(reader) (interface{}, error)
SetErr(error) SetErr(error)
Err() error Err() error
SetVal(interface{}) SetVal(interface{})
InterfaceVal() interface{} IfaceVal() interface{}
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
@ -56,12 +56,12 @@ func (r *BaseReq) SetVal(val interface{}) {
r.val = val r.val = val
} }
func (r *BaseReq) InterfaceVal() interface{} { func (r *BaseReq) IfaceVal() interface{} {
return r.val return r.val
} }
func (r *BaseReq) ParseReply(rd ReadLiner) (interface{}, error) { func (r *BaseReq) ParseReply(rd reader) (interface{}, error) {
return ParseReply(rd) return parseReply(rd)
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
@ -114,8 +114,8 @@ func NewBoolReq(args ...string) *BoolReq {
} }
} }
func (r *BoolReq) ParseReply(rd ReadLiner) (interface{}, error) { func (r *BoolReq) ParseReply(rd reader) (interface{}, error) {
v, err := ParseReply(rd) v, err := parseReply(rd)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -131,17 +131,17 @@ func (r *BoolReq) Val() bool {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
type BulkReq struct { type StringReq struct {
*BaseReq *BaseReq
} }
func NewBulkReq(args ...string) *BulkReq { func NewStringReq(args ...string) *StringReq {
return &BulkReq{ return &StringReq{
BaseReq: NewBaseReq(args...), BaseReq: NewBaseReq(args...),
} }
} }
func (r *BulkReq) Val() string { func (r *StringReq) Val() string {
if r.val == nil { if r.val == nil {
return "" return ""
} }
@ -160,8 +160,8 @@ func NewFloatReq(args ...string) *FloatReq {
} }
} }
func (r *FloatReq) ParseReply(rd ReadLiner) (interface{}, error) { func (r *FloatReq) ParseReply(rd reader) (interface{}, error) {
v, err := ParseReply(rd) v, err := parseReply(rd)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -177,19 +177,42 @@ func (r *FloatReq) Val() float64 {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
type MultiBulkReq struct { type IfaceSliceReq struct {
*BaseReq *BaseReq
} }
func NewMultiBulkReq(args ...string) *MultiBulkReq { func NewIfaceSliceReq(args ...string) *IfaceSliceReq {
return &MultiBulkReq{ return &IfaceSliceReq{
BaseReq: NewBaseReq(args...), BaseReq: NewBaseReq(args...),
} }
} }
func (r *MultiBulkReq) Val() []interface{} { func (r *IfaceSliceReq) ParseReply(rd reader) (interface{}, error) {
return parseIfaceSliceReply(rd)
}
func (r *IfaceSliceReq) Val() []interface{} {
if r.val == nil { if r.val == nil {
return nil return nil
} }
return r.val.([]interface{}) return r.val.([]interface{})
} }
//------------------------------------------------------------------------------
type StringSliceReq struct {
*BaseReq
}
func NewStringSliceReq(args ...string) *StringSliceReq {
return &StringSliceReq{
BaseReq: NewBaseReq(args...),
}
}
func (r *StringSliceReq) Val() []string {
if r.val == nil {
return nil
}
return r.val.([]string)
}