From 1c4c05e970b928908e03dce3b7677cc0d9a09079 Mon Sep 17 00:00:00 2001 From: Dimitrij Denissenko Date: Fri, 1 Jul 2016 13:25:28 +0100 Subject: [PATCH] Ensure to use pointer methods where appropriate. Tidy up godoc. --- commands.go | 404 ++++++++++++++++++++++++++-------------------------- iterator.go | 2 +- pipeline.go | 54 +++---- ring.go | 110 +++++++------- tx.go | 54 +++---- 5 files changed, 312 insertions(+), 312 deletions(-) diff --git a/commands.go b/commands.go index b21a8eec..f84311c5 100644 --- a/commands.go +++ b/commands.go @@ -61,7 +61,7 @@ type statefulCmdable struct { //------------------------------------------------------------------------------ -func (c statefulCmdable) Auth(password string) *StatusCmd { +func (c *statefulCmdable) Auth(password string) *StatusCmd { cmd := NewStatusCmd("auth", password) c.process(cmd) return cmd @@ -79,11 +79,11 @@ func (c *cmdable) Ping() *StatusCmd { return cmd } -func (c cmdable) Quit() *StatusCmd { +func (c *cmdable) Quit() *StatusCmd { panic("not implemented") } -func (c statefulCmdable) Select(index int) *StatusCmd { +func (c *statefulCmdable) Select(index int) *StatusCmd { cmd := NewStatusCmd("select", index) c.process(cmd) return cmd @@ -91,7 +91,7 @@ func (c statefulCmdable) Select(index int) *StatusCmd { //------------------------------------------------------------------------------ -func (c cmdable) Del(keys ...string) *IntCmd { +func (c *cmdable) Del(keys ...string) *IntCmd { args := make([]interface{}, 1+len(keys)) args[0] = "DEL" for i, key := range keys { @@ -102,37 +102,37 @@ func (c cmdable) Del(keys ...string) *IntCmd { return cmd } -func (c cmdable) Dump(key string) *StringCmd { +func (c *cmdable) Dump(key string) *StringCmd { cmd := NewStringCmd("dump", key) c.process(cmd) return cmd } -func (c cmdable) Exists(key string) *BoolCmd { +func (c *cmdable) Exists(key string) *BoolCmd { cmd := NewBoolCmd("exists", key) c.process(cmd) return cmd } -func (c cmdable) Expire(key string, expiration time.Duration) *BoolCmd { +func (c *cmdable) Expire(key string, expiration time.Duration) *BoolCmd { cmd := NewBoolCmd("expire", key, formatSec(expiration)) c.process(cmd) return cmd } -func (c cmdable) ExpireAt(key string, tm time.Time) *BoolCmd { +func (c *cmdable) ExpireAt(key string, tm time.Time) *BoolCmd { cmd := NewBoolCmd("expireat", key, tm.Unix()) c.process(cmd) return cmd } -func (c cmdable) Keys(pattern string) *StringSliceCmd { +func (c *cmdable) Keys(pattern string) *StringSliceCmd { cmd := NewStringSliceCmd("keys", pattern) c.process(cmd) return cmd } -func (c cmdable) Migrate(host, port, key string, db int64, timeout time.Duration) *StatusCmd { +func (c *cmdable) Migrate(host, port, key string, db int64, timeout time.Duration) *StatusCmd { cmd := NewStatusCmd( "migrate", host, @@ -146,13 +146,13 @@ func (c cmdable) Migrate(host, port, key string, db int64, timeout time.Duration return cmd } -func (c cmdable) Move(key string, db int64) *BoolCmd { +func (c *cmdable) Move(key string, db int64) *BoolCmd { cmd := NewBoolCmd("move", key, db) c.process(cmd) return cmd } -func (c cmdable) ObjectRefCount(keys ...string) *IntCmd { +func (c *cmdable) ObjectRefCount(keys ...string) *IntCmd { args := make([]interface{}, 2+len(keys)) args[0] = "object" args[1] = "refcount" @@ -164,7 +164,7 @@ func (c cmdable) ObjectRefCount(keys ...string) *IntCmd { return cmd } -func (c cmdable) ObjectEncoding(keys ...string) *StringCmd { +func (c *cmdable) ObjectEncoding(keys ...string) *StringCmd { args := make([]interface{}, 2+len(keys)) args[0] = "object" args[1] = "encoding" @@ -176,7 +176,7 @@ func (c cmdable) ObjectEncoding(keys ...string) *StringCmd { return cmd } -func (c cmdable) ObjectIdleTime(keys ...string) *DurationCmd { +func (c *cmdable) ObjectIdleTime(keys ...string) *DurationCmd { args := make([]interface{}, 2+len(keys)) args[0] = "object" args[1] = "idletime" @@ -188,19 +188,19 @@ func (c cmdable) ObjectIdleTime(keys ...string) *DurationCmd { return cmd } -func (c cmdable) Persist(key string) *BoolCmd { +func (c *cmdable) Persist(key string) *BoolCmd { cmd := NewBoolCmd("persist", key) c.process(cmd) return cmd } -func (c cmdable) PExpire(key string, expiration time.Duration) *BoolCmd { +func (c *cmdable) PExpire(key string, expiration time.Duration) *BoolCmd { cmd := NewBoolCmd("pexpire", key, formatMs(expiration)) c.process(cmd) return cmd } -func (c cmdable) PExpireAt(key string, tm time.Time) *BoolCmd { +func (c *cmdable) PExpireAt(key string, tm time.Time) *BoolCmd { cmd := NewBoolCmd( "pexpireat", key, @@ -210,31 +210,31 @@ func (c cmdable) PExpireAt(key string, tm time.Time) *BoolCmd { return cmd } -func (c cmdable) PTTL(key string) *DurationCmd { +func (c *cmdable) PTTL(key string) *DurationCmd { cmd := NewDurationCmd(time.Millisecond, "pttl", key) c.process(cmd) return cmd } -func (c cmdable) RandomKey() *StringCmd { +func (c *cmdable) RandomKey() *StringCmd { cmd := NewStringCmd("randomkey") c.process(cmd) return cmd } -func (c cmdable) Rename(key, newkey string) *StatusCmd { +func (c *cmdable) Rename(key, newkey string) *StatusCmd { cmd := NewStatusCmd("rename", key, newkey) c.process(cmd) return cmd } -func (c cmdable) RenameNX(key, newkey string) *BoolCmd { +func (c *cmdable) RenameNX(key, newkey string) *BoolCmd { cmd := NewBoolCmd("renamenx", key, newkey) c.process(cmd) return cmd } -func (c cmdable) Restore(key string, ttl time.Duration, value string) *StatusCmd { +func (c *cmdable) Restore(key string, ttl time.Duration, value string) *StatusCmd { cmd := NewStatusCmd( "restore", key, @@ -245,7 +245,7 @@ func (c cmdable) Restore(key string, ttl time.Duration, value string) *StatusCmd return cmd } -func (c cmdable) RestoreReplace(key string, ttl time.Duration, value string) *StatusCmd { +func (c *cmdable) RestoreReplace(key string, ttl time.Duration, value string) *StatusCmd { cmd := NewStatusCmd( "restore", key, @@ -289,31 +289,31 @@ func (sort *Sort) args(key string) []interface{} { return args } -func (c cmdable) Sort(key string, sort Sort) *StringSliceCmd { +func (c *cmdable) Sort(key string, sort Sort) *StringSliceCmd { cmd := NewStringSliceCmd(sort.args(key)...) c.process(cmd) return cmd } -func (c cmdable) SortInterfaces(key string, sort Sort) *SliceCmd { +func (c *cmdable) SortInterfaces(key string, sort Sort) *SliceCmd { cmd := NewSliceCmd(sort.args(key)...) c.process(cmd) return cmd } -func (c cmdable) TTL(key string) *DurationCmd { +func (c *cmdable) TTL(key string) *DurationCmd { cmd := NewDurationCmd(time.Second, "ttl", key) c.process(cmd) return cmd } -func (c cmdable) Type(key string) *StatusCmd { +func (c *cmdable) Type(key string) *StatusCmd { cmd := NewStatusCmd("type", key) c.process(cmd) return cmd } -func (c cmdable) Scan(cursor uint64, match string, count int64) Scanner { +func (c *cmdable) Scan(cursor uint64, match string, count int64) Scanner { args := []interface{}{"scan", cursor} if match != "" { args = append(args, "match", match) @@ -329,7 +329,7 @@ func (c cmdable) Scan(cursor uint64, match string, count int64) Scanner { } } -func (c cmdable) SScan(key string, cursor uint64, match string, count int64) Scanner { +func (c *cmdable) SScan(key string, cursor uint64, match string, count int64) Scanner { args := []interface{}{"sscan", key, cursor} if match != "" { args = append(args, "match", match) @@ -345,7 +345,7 @@ func (c cmdable) SScan(key string, cursor uint64, match string, count int64) Sca } } -func (c cmdable) HScan(key string, cursor uint64, match string, count int64) Scanner { +func (c *cmdable) HScan(key string, cursor uint64, match string, count int64) Scanner { args := []interface{}{"hscan", key, cursor} if match != "" { args = append(args, "match", match) @@ -361,7 +361,7 @@ func (c cmdable) HScan(key string, cursor uint64, match string, count int64) Sca } } -func (c cmdable) ZScan(key string, cursor uint64, match string, count int64) Scanner { +func (c *cmdable) ZScan(key string, cursor uint64, match string, count int64) Scanner { args := []interface{}{"zscan", key, cursor} if match != "" { args = append(args, "match", match) @@ -379,7 +379,7 @@ func (c cmdable) ZScan(key string, cursor uint64, match string, count int64) Sca //------------------------------------------------------------------------------ -func (c cmdable) Append(key, value string) *IntCmd { +func (c *cmdable) Append(key, value string) *IntCmd { cmd := NewIntCmd("append", key, value) c.process(cmd) return cmd @@ -389,7 +389,7 @@ type BitCount struct { Start, End int64 } -func (c cmdable) BitCount(key string, bitCount *BitCount) *IntCmd { +func (c *cmdable) BitCount(key string, bitCount *BitCount) *IntCmd { args := []interface{}{"bitcount", key} if bitCount != nil { args = append( @@ -403,7 +403,7 @@ func (c cmdable) BitCount(key string, bitCount *BitCount) *IntCmd { return cmd } -func (c cmdable) bitOp(op, destKey string, keys ...string) *IntCmd { +func (c *cmdable) bitOp(op, destKey string, keys ...string) *IntCmd { args := make([]interface{}, 3+len(keys)) args[0] = "bitop" args[1] = op @@ -416,23 +416,23 @@ func (c cmdable) bitOp(op, destKey string, keys ...string) *IntCmd { return cmd } -func (c cmdable) BitOpAnd(destKey string, keys ...string) *IntCmd { +func (c *cmdable) BitOpAnd(destKey string, keys ...string) *IntCmd { return c.bitOp("and", destKey, keys...) } -func (c cmdable) BitOpOr(destKey string, keys ...string) *IntCmd { +func (c *cmdable) BitOpOr(destKey string, keys ...string) *IntCmd { return c.bitOp("or", destKey, keys...) } -func (c cmdable) BitOpXor(destKey string, keys ...string) *IntCmd { +func (c *cmdable) BitOpXor(destKey string, keys ...string) *IntCmd { return c.bitOp("xor", destKey, keys...) } -func (c cmdable) BitOpNot(destKey string, key string) *IntCmd { +func (c *cmdable) BitOpNot(destKey string, key string) *IntCmd { return c.bitOp("not", destKey, key) } -func (c cmdable) BitPos(key string, bit int64, pos ...int64) *IntCmd { +func (c *cmdable) BitPos(key string, bit int64, pos ...int64) *IntCmd { args := make([]interface{}, 3+len(pos)) args[0] = "bitpos" args[1] = key @@ -452,61 +452,61 @@ func (c cmdable) BitPos(key string, bit int64, pos ...int64) *IntCmd { return cmd } -func (c cmdable) Decr(key string) *IntCmd { +func (c *cmdable) Decr(key string) *IntCmd { cmd := NewIntCmd("decr", key) c.process(cmd) return cmd } -func (c cmdable) DecrBy(key string, decrement int64) *IntCmd { +func (c *cmdable) DecrBy(key string, decrement int64) *IntCmd { cmd := NewIntCmd("decrby", key, decrement) c.process(cmd) return cmd } -func (c cmdable) Get(key string) *StringCmd { +func (c *cmdable) Get(key string) *StringCmd { cmd := NewStringCmd("get", key) c.process(cmd) return cmd } -func (c cmdable) GetBit(key string, offset int64) *IntCmd { +func (c *cmdable) GetBit(key string, offset int64) *IntCmd { cmd := NewIntCmd("getbit", key, offset) c.process(cmd) return cmd } -func (c cmdable) GetRange(key string, start, end int64) *StringCmd { +func (c *cmdable) GetRange(key string, start, end int64) *StringCmd { cmd := NewStringCmd("getrange", key, start, end) c.process(cmd) return cmd } -func (c cmdable) GetSet(key string, value interface{}) *StringCmd { +func (c *cmdable) GetSet(key string, value interface{}) *StringCmd { cmd := NewStringCmd("getset", key, value) c.process(cmd) return cmd } -func (c cmdable) Incr(key string) *IntCmd { +func (c *cmdable) Incr(key string) *IntCmd { cmd := NewIntCmd("incr", key) c.process(cmd) return cmd } -func (c cmdable) IncrBy(key string, value int64) *IntCmd { +func (c *cmdable) IncrBy(key string, value int64) *IntCmd { cmd := NewIntCmd("incrby", key, value) c.process(cmd) return cmd } -func (c cmdable) IncrByFloat(key string, value float64) *FloatCmd { +func (c *cmdable) IncrByFloat(key string, value float64) *FloatCmd { cmd := NewFloatCmd("incrbyfloat", key, value) c.process(cmd) return cmd } -func (c cmdable) MGet(keys ...string) *SliceCmd { +func (c *cmdable) MGet(keys ...string) *SliceCmd { args := make([]interface{}, 1+len(keys)) args[0] = "mget" for i, key := range keys { @@ -517,7 +517,7 @@ func (c cmdable) MGet(keys ...string) *SliceCmd { return cmd } -func (c cmdable) MSet(pairs ...interface{}) *StatusCmd { +func (c *cmdable) MSet(pairs ...interface{}) *StatusCmd { args := make([]interface{}, 1+len(pairs)) args[0] = "mset" for i, pair := range pairs { @@ -528,7 +528,7 @@ func (c cmdable) MSet(pairs ...interface{}) *StatusCmd { return cmd } -func (c cmdable) MSetNX(pairs ...interface{}) *BoolCmd { +func (c *cmdable) MSetNX(pairs ...interface{}) *BoolCmd { args := make([]interface{}, 1+len(pairs)) args[0] = "msetnx" for i, pair := range pairs { @@ -542,7 +542,7 @@ func (c cmdable) MSetNX(pairs ...interface{}) *BoolCmd { // Redis `SET key value [expiration]` command. // // Zero expiration means the key has no expiration time. -func (c cmdable) Set(key string, value interface{}, expiration time.Duration) *StatusCmd { +func (c *cmdable) Set(key string, value interface{}, expiration time.Duration) *StatusCmd { args := make([]interface{}, 3, 4) args[0] = "set" args[1] = key @@ -559,7 +559,7 @@ func (c cmdable) Set(key string, value interface{}, expiration time.Duration) *S return cmd } -func (c cmdable) SetBit(key string, offset int64, value int) *IntCmd { +func (c *cmdable) SetBit(key string, offset int64, value int) *IntCmd { cmd := NewIntCmd( "SETBIT", key, @@ -573,7 +573,7 @@ func (c cmdable) SetBit(key string, offset int64, value int) *IntCmd { // Redis `SET key value [expiration] NX` command. // // Zero expiration means the key has no expiration time. -func (c cmdable) SetNX(key string, value interface{}, expiration time.Duration) *BoolCmd { +func (c *cmdable) SetNX(key string, value interface{}, expiration time.Duration) *BoolCmd { var cmd *BoolCmd if expiration == 0 { // Use old `SETNX` to support old Redis versions. @@ -592,7 +592,7 @@ func (c cmdable) SetNX(key string, value interface{}, expiration time.Duration) // Redis `SET key value [expiration] XX` command. // // Zero expiration means the key has no expiration time. -func (c cmdable) SetXX(key string, value interface{}, expiration time.Duration) *BoolCmd { +func (c *cmdable) SetXX(key string, value interface{}, expiration time.Duration) *BoolCmd { var cmd *BoolCmd if usePrecise(expiration) { cmd = NewBoolCmd("set", key, value, "px", formatMs(expiration), "xx") @@ -603,13 +603,13 @@ func (c cmdable) SetXX(key string, value interface{}, expiration time.Duration) return cmd } -func (c cmdable) SetRange(key string, offset int64, value string) *IntCmd { +func (c *cmdable) SetRange(key string, offset int64, value string) *IntCmd { cmd := NewIntCmd("setrange", key, offset, value) c.process(cmd) return cmd } -func (c cmdable) StrLen(key string) *IntCmd { +func (c *cmdable) StrLen(key string) *IntCmd { cmd := NewIntCmd("strlen", key) c.process(cmd) return cmd @@ -617,7 +617,7 @@ func (c cmdable) StrLen(key string) *IntCmd { //------------------------------------------------------------------------------ -func (c cmdable) HDel(key string, fields ...string) *IntCmd { +func (c *cmdable) HDel(key string, fields ...string) *IntCmd { args := make([]interface{}, 2+len(fields)) args[0] = "hdel" args[1] = key @@ -629,49 +629,49 @@ func (c cmdable) HDel(key string, fields ...string) *IntCmd { return cmd } -func (c cmdable) HExists(key, field string) *BoolCmd { +func (c *cmdable) HExists(key, field string) *BoolCmd { cmd := NewBoolCmd("hexists", key, field) c.process(cmd) return cmd } -func (c cmdable) HGet(key, field string) *StringCmd { +func (c *cmdable) HGet(key, field string) *StringCmd { cmd := NewStringCmd("hget", key, field) c.process(cmd) return cmd } -func (c cmdable) HGetAll(key string) *StringStringMapCmd { +func (c *cmdable) HGetAll(key string) *StringStringMapCmd { cmd := NewStringStringMapCmd("hgetall", key) c.process(cmd) return cmd } -func (c cmdable) HIncrBy(key, field string, incr int64) *IntCmd { +func (c *cmdable) HIncrBy(key, field string, incr int64) *IntCmd { cmd := NewIntCmd("hincrby", key, field, incr) c.process(cmd) return cmd } -func (c cmdable) HIncrByFloat(key, field string, incr float64) *FloatCmd { +func (c *cmdable) HIncrByFloat(key, field string, incr float64) *FloatCmd { cmd := NewFloatCmd("hincrbyfloat", key, field, incr) c.process(cmd) return cmd } -func (c cmdable) HKeys(key string) *StringSliceCmd { +func (c *cmdable) HKeys(key string) *StringSliceCmd { cmd := NewStringSliceCmd("hkeys", key) c.process(cmd) return cmd } -func (c cmdable) HLen(key string) *IntCmd { +func (c *cmdable) HLen(key string) *IntCmd { cmd := NewIntCmd("hlen", key) c.process(cmd) return cmd } -func (c cmdable) HMGet(key string, fields ...string) *SliceCmd { +func (c *cmdable) HMGet(key string, fields ...string) *SliceCmd { args := make([]interface{}, 2+len(fields)) args[0] = "hmget" args[1] = key @@ -683,7 +683,7 @@ func (c cmdable) HMGet(key string, fields ...string) *SliceCmd { return cmd } -func (c cmdable) HMSet(key string, fields map[string]string) *StatusCmd { +func (c *cmdable) HMSet(key string, fields map[string]string) *StatusCmd { args := make([]interface{}, 2+len(fields)*2) args[0] = "hmset" args[1] = key @@ -698,19 +698,19 @@ func (c cmdable) HMSet(key string, fields map[string]string) *StatusCmd { return cmd } -func (c cmdable) HSet(key, field, value string) *BoolCmd { +func (c *cmdable) HSet(key, field, value string) *BoolCmd { cmd := NewBoolCmd("hset", key, field, value) c.process(cmd) return cmd } -func (c cmdable) HSetNX(key, field, value string) *BoolCmd { +func (c *cmdable) HSetNX(key, field, value string) *BoolCmd { cmd := NewBoolCmd("hsetnx", key, field, value) c.process(cmd) return cmd } -func (c cmdable) HVals(key string) *StringSliceCmd { +func (c *cmdable) HVals(key string) *StringSliceCmd { cmd := NewStringSliceCmd("hvals", key) c.process(cmd) return cmd @@ -718,7 +718,7 @@ func (c cmdable) HVals(key string) *StringSliceCmd { //------------------------------------------------------------------------------ -func (c cmdable) BLPop(timeout time.Duration, keys ...string) *StringSliceCmd { +func (c *cmdable) BLPop(timeout time.Duration, keys ...string) *StringSliceCmd { args := make([]interface{}, 1+len(keys)+1) args[0] = "blpop" for i, key := range keys { @@ -731,7 +731,7 @@ func (c cmdable) BLPop(timeout time.Duration, keys ...string) *StringSliceCmd { return cmd } -func (c cmdable) BRPop(timeout time.Duration, keys ...string) *StringSliceCmd { +func (c *cmdable) BRPop(timeout time.Duration, keys ...string) *StringSliceCmd { args := make([]interface{}, 1+len(keys)+1) args[0] = "brpop" for i, key := range keys { @@ -744,7 +744,7 @@ func (c cmdable) BRPop(timeout time.Duration, keys ...string) *StringSliceCmd { return cmd } -func (c cmdable) BRPopLPush(source, destination string, timeout time.Duration) *StringCmd { +func (c *cmdable) BRPopLPush(source, destination string, timeout time.Duration) *StringCmd { cmd := NewStringCmd( "brpoplpush", source, @@ -756,43 +756,43 @@ func (c cmdable) BRPopLPush(source, destination string, timeout time.Duration) * return cmd } -func (c cmdable) LIndex(key string, index int64) *StringCmd { +func (c *cmdable) LIndex(key string, index int64) *StringCmd { cmd := NewStringCmd("lindex", key, index) c.process(cmd) return cmd } -func (c cmdable) LInsert(key, op string, pivot, value interface{}) *IntCmd { +func (c *cmdable) LInsert(key, op string, pivot, value interface{}) *IntCmd { cmd := NewIntCmd("linsert", key, op, pivot, value) c.process(cmd) return cmd } -func (c cmdable) LInsertBefore(key string, pivot, value interface{}) *IntCmd { +func (c *cmdable) LInsertBefore(key string, pivot, value interface{}) *IntCmd { cmd := NewIntCmd("linsert", key, "before", pivot, value) c.process(cmd) return cmd } -func (c cmdable) LInsertAfter(key string, pivot, value interface{}) *IntCmd { +func (c *cmdable) LInsertAfter(key string, pivot, value interface{}) *IntCmd { cmd := NewIntCmd("linsert", key, "after", pivot, value) c.process(cmd) return cmd } -func (c cmdable) LLen(key string) *IntCmd { +func (c *cmdable) LLen(key string) *IntCmd { cmd := NewIntCmd("llen", key) c.process(cmd) return cmd } -func (c cmdable) LPop(key string) *StringCmd { +func (c *cmdable) LPop(key string) *StringCmd { cmd := NewStringCmd("lpop", key) c.process(cmd) return cmd } -func (c cmdable) LPush(key string, values ...interface{}) *IntCmd { +func (c *cmdable) LPush(key string, values ...interface{}) *IntCmd { args := make([]interface{}, 2+len(values)) args[0] = "lpush" args[1] = key @@ -804,13 +804,13 @@ func (c cmdable) LPush(key string, values ...interface{}) *IntCmd { return cmd } -func (c cmdable) LPushX(key string, value interface{}) *IntCmd { +func (c *cmdable) LPushX(key string, value interface{}) *IntCmd { cmd := NewIntCmd("lpushx", key, value) c.process(cmd) return cmd } -func (c cmdable) LRange(key string, start, stop int64) *StringSliceCmd { +func (c *cmdable) LRange(key string, start, stop int64) *StringSliceCmd { cmd := NewStringSliceCmd( "lrange", key, @@ -821,19 +821,19 @@ func (c cmdable) LRange(key string, start, stop int64) *StringSliceCmd { return cmd } -func (c cmdable) LRem(key string, count int64, value interface{}) *IntCmd { +func (c *cmdable) LRem(key string, count int64, value interface{}) *IntCmd { cmd := NewIntCmd("lrem", key, count, value) c.process(cmd) return cmd } -func (c cmdable) LSet(key string, index int64, value interface{}) *StatusCmd { +func (c *cmdable) LSet(key string, index int64, value interface{}) *StatusCmd { cmd := NewStatusCmd("lset", key, index, value) c.process(cmd) return cmd } -func (c cmdable) LTrim(key string, start, stop int64) *StatusCmd { +func (c *cmdable) LTrim(key string, start, stop int64) *StatusCmd { cmd := NewStatusCmd( "ltrim", key, @@ -844,19 +844,19 @@ func (c cmdable) LTrim(key string, start, stop int64) *StatusCmd { return cmd } -func (c cmdable) RPop(key string) *StringCmd { +func (c *cmdable) RPop(key string) *StringCmd { cmd := NewStringCmd("rpop", key) c.process(cmd) return cmd } -func (c cmdable) RPopLPush(source, destination string) *StringCmd { +func (c *cmdable) RPopLPush(source, destination string) *StringCmd { cmd := NewStringCmd("rpoplpush", source, destination) c.process(cmd) return cmd } -func (c cmdable) RPush(key string, values ...interface{}) *IntCmd { +func (c *cmdable) RPush(key string, values ...interface{}) *IntCmd { args := make([]interface{}, 2+len(values)) args[0] = "rpush" args[1] = key @@ -868,7 +868,7 @@ func (c cmdable) RPush(key string, values ...interface{}) *IntCmd { return cmd } -func (c cmdable) RPushX(key string, value interface{}) *IntCmd { +func (c *cmdable) RPushX(key string, value interface{}) *IntCmd { cmd := NewIntCmd("rpushx", key, value) c.process(cmd) return cmd @@ -876,7 +876,7 @@ func (c cmdable) RPushX(key string, value interface{}) *IntCmd { //------------------------------------------------------------------------------ -func (c cmdable) SAdd(key string, members ...interface{}) *IntCmd { +func (c *cmdable) SAdd(key string, members ...interface{}) *IntCmd { args := make([]interface{}, 2+len(members)) args[0] = "sadd" args[1] = key @@ -888,13 +888,13 @@ func (c cmdable) SAdd(key string, members ...interface{}) *IntCmd { return cmd } -func (c cmdable) SCard(key string) *IntCmd { +func (c *cmdable) SCard(key string) *IntCmd { cmd := NewIntCmd("scard", key) c.process(cmd) return cmd } -func (c cmdable) SDiff(keys ...string) *StringSliceCmd { +func (c *cmdable) SDiff(keys ...string) *StringSliceCmd { args := make([]interface{}, 1+len(keys)) args[0] = "sdiff" for i, key := range keys { @@ -905,7 +905,7 @@ func (c cmdable) SDiff(keys ...string) *StringSliceCmd { return cmd } -func (c cmdable) SDiffStore(destination string, keys ...string) *IntCmd { +func (c *cmdable) SDiffStore(destination string, keys ...string) *IntCmd { args := make([]interface{}, 2+len(keys)) args[0] = "sdiffstore" args[1] = destination @@ -917,7 +917,7 @@ func (c cmdable) SDiffStore(destination string, keys ...string) *IntCmd { return cmd } -func (c cmdable) SInter(keys ...string) *StringSliceCmd { +func (c *cmdable) SInter(keys ...string) *StringSliceCmd { args := make([]interface{}, 1+len(keys)) args[0] = "sinter" for i, key := range keys { @@ -928,7 +928,7 @@ func (c cmdable) SInter(keys ...string) *StringSliceCmd { return cmd } -func (c cmdable) SInterStore(destination string, keys ...string) *IntCmd { +func (c *cmdable) SInterStore(destination string, keys ...string) *IntCmd { args := make([]interface{}, 2+len(keys)) args[0] = "sinterstore" args[1] = destination @@ -940,53 +940,53 @@ func (c cmdable) SInterStore(destination string, keys ...string) *IntCmd { return cmd } -func (c cmdable) SIsMember(key string, member interface{}) *BoolCmd { +func (c *cmdable) SIsMember(key string, member interface{}) *BoolCmd { cmd := NewBoolCmd("sismember", key, member) c.process(cmd) return cmd } -func (c cmdable) SMembers(key string) *StringSliceCmd { +func (c *cmdable) SMembers(key string) *StringSliceCmd { cmd := NewStringSliceCmd("smembers", key) c.process(cmd) return cmd } -func (c cmdable) SMove(source, destination string, member interface{}) *BoolCmd { +func (c *cmdable) SMove(source, destination string, member interface{}) *BoolCmd { cmd := NewBoolCmd("smove", source, destination, member) c.process(cmd) return cmd } // Redis `SPOP key` command. -func (c cmdable) SPop(key string) *StringCmd { +func (c *cmdable) SPop(key string) *StringCmd { cmd := NewStringCmd("spop", key) c.process(cmd) return cmd } // Redis `SPOP key count` command. -func (c cmdable) SPopN(key string, count int64) *StringSliceCmd { +func (c *cmdable) SPopN(key string, count int64) *StringSliceCmd { cmd := NewStringSliceCmd("spop", key, count) c.process(cmd) return cmd } // Redis `SRANDMEMBER key` command. -func (c cmdable) SRandMember(key string) *StringCmd { +func (c *cmdable) SRandMember(key string) *StringCmd { cmd := NewStringCmd("srandmember", key) c.process(cmd) return cmd } // Redis `SRANDMEMBER key count` command. -func (c cmdable) SRandMemberN(key string, count int64) *StringSliceCmd { +func (c *cmdable) SRandMemberN(key string, count int64) *StringSliceCmd { cmd := NewStringSliceCmd("srandmember", key, count) c.process(cmd) return cmd } -func (c cmdable) SRem(key string, members ...interface{}) *IntCmd { +func (c *cmdable) SRem(key string, members ...interface{}) *IntCmd { args := make([]interface{}, 2+len(members)) args[0] = "srem" args[1] = key @@ -998,7 +998,7 @@ func (c cmdable) SRem(key string, members ...interface{}) *IntCmd { return cmd } -func (c cmdable) SUnion(keys ...string) *StringSliceCmd { +func (c *cmdable) SUnion(keys ...string) *StringSliceCmd { args := make([]interface{}, 1+len(keys)) args[0] = "sunion" for i, key := range keys { @@ -1009,7 +1009,7 @@ func (c cmdable) SUnion(keys ...string) *StringSliceCmd { return cmd } -func (c cmdable) SUnionStore(destination string, keys ...string) *IntCmd { +func (c *cmdable) SUnionStore(destination string, keys ...string) *IntCmd { args := make([]interface{}, 2+len(keys)) args[0] = "sunionstore" args[1] = destination @@ -1036,7 +1036,7 @@ type ZStore struct { Aggregate string } -func (c cmdable) zAdd(a []interface{}, n int, members ...Z) *IntCmd { +func (c *cmdable) zAdd(a []interface{}, n int, members ...Z) *IntCmd { for i, m := range members { a[n+2*i] = m.Score a[n+2*i+1] = m.Member @@ -1047,7 +1047,7 @@ func (c cmdable) zAdd(a []interface{}, n int, members ...Z) *IntCmd { } // Redis `ZADD key score member [score member ...]` command. -func (c cmdable) ZAdd(key string, members ...Z) *IntCmd { +func (c *cmdable) ZAdd(key string, members ...Z) *IntCmd { const n = 2 a := make([]interface{}, n+2*len(members)) a[0], a[1] = "zadd", key @@ -1055,7 +1055,7 @@ func (c cmdable) ZAdd(key string, members ...Z) *IntCmd { } // Redis `ZADD key NX score member [score member ...]` command. -func (c cmdable) ZAddNX(key string, members ...Z) *IntCmd { +func (c *cmdable) ZAddNX(key string, members ...Z) *IntCmd { const n = 3 a := make([]interface{}, n+2*len(members)) a[0], a[1], a[2] = "zadd", key, "nx" @@ -1063,7 +1063,7 @@ func (c cmdable) ZAddNX(key string, members ...Z) *IntCmd { } // Redis `ZADD key XX score member [score member ...]` command. -func (c cmdable) ZAddXX(key string, members ...Z) *IntCmd { +func (c *cmdable) ZAddXX(key string, members ...Z) *IntCmd { const n = 3 a := make([]interface{}, n+2*len(members)) a[0], a[1], a[2] = "zadd", key, "xx" @@ -1071,7 +1071,7 @@ func (c cmdable) ZAddXX(key string, members ...Z) *IntCmd { } // Redis `ZADD key CH score member [score member ...]` command. -func (c cmdable) ZAddCh(key string, members ...Z) *IntCmd { +func (c *cmdable) ZAddCh(key string, members ...Z) *IntCmd { const n = 3 a := make([]interface{}, n+2*len(members)) a[0], a[1], a[2] = "zadd", key, "ch" @@ -1079,7 +1079,7 @@ func (c cmdable) ZAddCh(key string, members ...Z) *IntCmd { } // Redis `ZADD key NX CH score member [score member ...]` command. -func (c cmdable) ZAddNXCh(key string, members ...Z) *IntCmd { +func (c *cmdable) ZAddNXCh(key string, members ...Z) *IntCmd { const n = 4 a := make([]interface{}, n+2*len(members)) a[0], a[1], a[2], a[3] = "zadd", key, "nx", "ch" @@ -1087,14 +1087,14 @@ func (c cmdable) ZAddNXCh(key string, members ...Z) *IntCmd { } // Redis `ZADD key XX CH score member [score member ...]` command. -func (c cmdable) ZAddXXCh(key string, members ...Z) *IntCmd { +func (c *cmdable) ZAddXXCh(key string, members ...Z) *IntCmd { const n = 4 a := make([]interface{}, n+2*len(members)) a[0], a[1], a[2], a[3] = "zadd", key, "xx", "ch" return c.zAdd(a, n, members...) } -func (c cmdable) zIncr(a []interface{}, n int, members ...Z) *FloatCmd { +func (c *cmdable) zIncr(a []interface{}, n int, members ...Z) *FloatCmd { for i, m := range members { a[n+2*i] = m.Score a[n+2*i+1] = m.Member @@ -1105,7 +1105,7 @@ func (c cmdable) zIncr(a []interface{}, n int, members ...Z) *FloatCmd { } // Redis `ZADD key INCR score member` command. -func (c cmdable) ZIncr(key string, member Z) *FloatCmd { +func (c *cmdable) ZIncr(key string, member Z) *FloatCmd { const n = 3 a := make([]interface{}, n+2) a[0], a[1], a[2] = "zadd", key, "incr" @@ -1113,7 +1113,7 @@ func (c cmdable) ZIncr(key string, member Z) *FloatCmd { } // Redis `ZADD key NX INCR score member` command. -func (c cmdable) ZIncrNX(key string, member Z) *FloatCmd { +func (c *cmdable) ZIncrNX(key string, member Z) *FloatCmd { const n = 4 a := make([]interface{}, n+2) a[0], a[1], a[2], a[3] = "zadd", key, "incr", "nx" @@ -1121,32 +1121,32 @@ func (c cmdable) ZIncrNX(key string, member Z) *FloatCmd { } // Redis `ZADD key XX INCR score member` command. -func (c cmdable) ZIncrXX(key string, member Z) *FloatCmd { +func (c *cmdable) ZIncrXX(key string, member Z) *FloatCmd { const n = 4 a := make([]interface{}, n+2) a[0], a[1], a[2], a[3] = "zadd", key, "incr", "xx" return c.zIncr(a, n, member) } -func (c cmdable) ZCard(key string) *IntCmd { +func (c *cmdable) ZCard(key string) *IntCmd { cmd := NewIntCmd("zcard", key) c.process(cmd) return cmd } -func (c cmdable) ZCount(key, min, max string) *IntCmd { +func (c *cmdable) ZCount(key, min, max string) *IntCmd { cmd := NewIntCmd("zcount", key, min, max) c.process(cmd) return cmd } -func (c cmdable) ZIncrBy(key string, increment float64, member string) *FloatCmd { +func (c *cmdable) ZIncrBy(key string, increment float64, member string) *FloatCmd { cmd := NewFloatCmd("zincrby", key, increment, member) c.process(cmd) return cmd } -func (c cmdable) ZInterStore(destination string, store ZStore, keys ...string) *IntCmd { +func (c *cmdable) ZInterStore(destination string, store ZStore, keys ...string) *IntCmd { args := make([]interface{}, 3+len(keys)) args[0] = "zinterstore" args[1] = destination @@ -1168,7 +1168,7 @@ func (c cmdable) ZInterStore(destination string, store ZStore, keys ...string) * return cmd } -func (c cmdable) zRange(key string, start, stop int64, withScores bool) *StringSliceCmd { +func (c *cmdable) zRange(key string, start, stop int64, withScores bool) *StringSliceCmd { args := []interface{}{ "zrange", key, @@ -1183,11 +1183,11 @@ func (c cmdable) zRange(key string, start, stop int64, withScores bool) *StringS return cmd } -func (c cmdable) ZRange(key string, start, stop int64) *StringSliceCmd { +func (c *cmdable) ZRange(key string, start, stop int64) *StringSliceCmd { return c.zRange(key, start, stop, false) } -func (c cmdable) ZRangeWithScores(key string, start, stop int64) *ZSliceCmd { +func (c *cmdable) ZRangeWithScores(key string, start, stop int64) *ZSliceCmd { cmd := NewZSliceCmd("zrange", key, start, stop, "withscores") c.process(cmd) return cmd @@ -1198,7 +1198,7 @@ type ZRangeBy struct { Offset, Count int64 } -func (c cmdable) zRangeBy(zcmd, key string, opt ZRangeBy, withScores bool) *StringSliceCmd { +func (c *cmdable) zRangeBy(zcmd, key string, opt ZRangeBy, withScores bool) *StringSliceCmd { args := []interface{}{zcmd, key, opt.Min, opt.Max} if withScores { args = append(args, "withscores") @@ -1216,15 +1216,15 @@ func (c cmdable) zRangeBy(zcmd, key string, opt ZRangeBy, withScores bool) *Stri return cmd } -func (c cmdable) ZRangeByScore(key string, opt ZRangeBy) *StringSliceCmd { +func (c *cmdable) ZRangeByScore(key string, opt ZRangeBy) *StringSliceCmd { return c.zRangeBy("zrangebyscore", key, opt, false) } -func (c cmdable) ZRangeByLex(key string, opt ZRangeBy) *StringSliceCmd { +func (c *cmdable) ZRangeByLex(key string, opt ZRangeBy) *StringSliceCmd { return c.zRangeBy("zrangebylex", key, opt, false) } -func (c cmdable) ZRangeByScoreWithScores(key string, opt ZRangeBy) *ZSliceCmd { +func (c *cmdable) ZRangeByScoreWithScores(key string, opt ZRangeBy) *ZSliceCmd { args := []interface{}{"zrangebyscore", key, opt.Min, opt.Max, "withscores"} if opt.Offset != 0 || opt.Count != 0 { args = append( @@ -1239,13 +1239,13 @@ func (c cmdable) ZRangeByScoreWithScores(key string, opt ZRangeBy) *ZSliceCmd { return cmd } -func (c cmdable) ZRank(key, member string) *IntCmd { +func (c *cmdable) ZRank(key, member string) *IntCmd { cmd := NewIntCmd("zrank", key, member) c.process(cmd) return cmd } -func (c cmdable) ZRem(key string, members ...interface{}) *IntCmd { +func (c *cmdable) ZRem(key string, members ...interface{}) *IntCmd { args := make([]interface{}, 2+len(members)) args[0] = "zrem" args[1] = key @@ -1257,7 +1257,7 @@ func (c cmdable) ZRem(key string, members ...interface{}) *IntCmd { return cmd } -func (c cmdable) ZRemRangeByRank(key string, start, stop int64) *IntCmd { +func (c *cmdable) ZRemRangeByRank(key string, start, stop int64) *IntCmd { cmd := NewIntCmd( "zremrangebyrank", key, @@ -1268,25 +1268,25 @@ func (c cmdable) ZRemRangeByRank(key string, start, stop int64) *IntCmd { return cmd } -func (c cmdable) ZRemRangeByScore(key, min, max string) *IntCmd { +func (c *cmdable) ZRemRangeByScore(key, min, max string) *IntCmd { cmd := NewIntCmd("zremrangebyscore", key, min, max) c.process(cmd) return cmd } -func (c cmdable) ZRevRange(key string, start, stop int64) *StringSliceCmd { +func (c *cmdable) ZRevRange(key string, start, stop int64) *StringSliceCmd { cmd := NewStringSliceCmd("zrevrange", key, start, stop) c.process(cmd) return cmd } -func (c cmdable) ZRevRangeWithScores(key string, start, stop int64) *ZSliceCmd { +func (c *cmdable) ZRevRangeWithScores(key string, start, stop int64) *ZSliceCmd { cmd := NewZSliceCmd("zrevrange", key, start, stop, "withscores") c.process(cmd) return cmd } -func (c cmdable) zRevRangeBy(zcmd, key string, opt ZRangeBy) *StringSliceCmd { +func (c *cmdable) zRevRangeBy(zcmd, key string, opt ZRangeBy) *StringSliceCmd { args := []interface{}{zcmd, key, opt.Max, opt.Min} if opt.Offset != 0 || opt.Count != 0 { args = append( @@ -1301,15 +1301,15 @@ func (c cmdable) zRevRangeBy(zcmd, key string, opt ZRangeBy) *StringSliceCmd { return cmd } -func (c cmdable) ZRevRangeByScore(key string, opt ZRangeBy) *StringSliceCmd { +func (c *cmdable) ZRevRangeByScore(key string, opt ZRangeBy) *StringSliceCmd { return c.zRevRangeBy("zrevrangebyscore", key, opt) } -func (c cmdable) ZRevRangeByLex(key string, opt ZRangeBy) *StringSliceCmd { +func (c *cmdable) ZRevRangeByLex(key string, opt ZRangeBy) *StringSliceCmd { return c.zRevRangeBy("zrevrangebylex", key, opt) } -func (c cmdable) ZRevRangeByScoreWithScores(key string, opt ZRangeBy) *ZSliceCmd { +func (c *cmdable) ZRevRangeByScoreWithScores(key string, opt ZRangeBy) *ZSliceCmd { args := []interface{}{"zrevrangebyscore", key, opt.Max, opt.Min, "withscores"} if opt.Offset != 0 || opt.Count != 0 { args = append( @@ -1324,19 +1324,19 @@ func (c cmdable) ZRevRangeByScoreWithScores(key string, opt ZRangeBy) *ZSliceCmd return cmd } -func (c cmdable) ZRevRank(key, member string) *IntCmd { +func (c *cmdable) ZRevRank(key, member string) *IntCmd { cmd := NewIntCmd("zrevrank", key, member) c.process(cmd) return cmd } -func (c cmdable) ZScore(key, member string) *FloatCmd { +func (c *cmdable) ZScore(key, member string) *FloatCmd { cmd := NewFloatCmd("zscore", key, member) c.process(cmd) return cmd } -func (c cmdable) ZUnionStore(dest string, store ZStore, keys ...string) *IntCmd { +func (c *cmdable) ZUnionStore(dest string, store ZStore, keys ...string) *IntCmd { args := make([]interface{}, 3+len(keys)) args[0] = "zunionstore" args[1] = dest @@ -1360,7 +1360,7 @@ func (c cmdable) ZUnionStore(dest string, store ZStore, keys ...string) *IntCmd //------------------------------------------------------------------------------ -func (c cmdable) PFAdd(key string, els ...interface{}) *IntCmd { +func (c *cmdable) PFAdd(key string, els ...interface{}) *IntCmd { args := make([]interface{}, 2+len(els)) args[0] = "pfadd" args[1] = key @@ -1372,7 +1372,7 @@ func (c cmdable) PFAdd(key string, els ...interface{}) *IntCmd { return cmd } -func (c cmdable) PFCount(keys ...string) *IntCmd { +func (c *cmdable) PFCount(keys ...string) *IntCmd { args := make([]interface{}, 1+len(keys)) args[0] = "pfcount" for i, key := range keys { @@ -1383,7 +1383,7 @@ func (c cmdable) PFCount(keys ...string) *IntCmd { return cmd } -func (c cmdable) PFMerge(dest string, keys ...string) *StatusCmd { +func (c *cmdable) PFMerge(dest string, keys ...string) *StatusCmd { args := make([]interface{}, 2+len(keys)) args[0] = "pfmerge" args[1] = dest @@ -1397,38 +1397,38 @@ func (c cmdable) PFMerge(dest string, keys ...string) *StatusCmd { //------------------------------------------------------------------------------ -func (c cmdable) BgRewriteAOF() *StatusCmd { +func (c *cmdable) BgRewriteAOF() *StatusCmd { cmd := NewStatusCmd("bgrewriteaof") c.process(cmd) return cmd } -func (c cmdable) BgSave() *StatusCmd { +func (c *cmdable) BgSave() *StatusCmd { cmd := NewStatusCmd("bgsave") c.process(cmd) return cmd } -func (c cmdable) ClientKill(ipPort string) *StatusCmd { +func (c *cmdable) ClientKill(ipPort string) *StatusCmd { cmd := NewStatusCmd("client", "kill", ipPort) c.process(cmd) return cmd } -func (c cmdable) ClientList() *StringCmd { +func (c *cmdable) ClientList() *StringCmd { cmd := NewStringCmd("client", "list") c.process(cmd) return cmd } -func (c cmdable) ClientPause(dur time.Duration) *BoolCmd { +func (c *cmdable) ClientPause(dur time.Duration) *BoolCmd { cmd := NewBoolCmd("client", "pause", formatMs(dur)) c.process(cmd) return cmd } // ClientSetName assigns a name to the one of many connections in the pool. -func (c cmdable) ClientSetName(name string) *BoolCmd { +func (c *cmdable) ClientSetName(name string) *BoolCmd { cmd := NewBoolCmd("client", "setname", name) c.process(cmd) return cmd @@ -1441,43 +1441,43 @@ func (c *Client) ClientGetName() *StringCmd { return cmd } -func (c cmdable) ConfigGet(parameter string) *SliceCmd { +func (c *cmdable) ConfigGet(parameter string) *SliceCmd { cmd := NewSliceCmd("config", "get", parameter) c.process(cmd) return cmd } -func (c cmdable) ConfigResetStat() *StatusCmd { +func (c *cmdable) ConfigResetStat() *StatusCmd { cmd := NewStatusCmd("config", "resetstat") c.process(cmd) return cmd } -func (c cmdable) ConfigSet(parameter, value string) *StatusCmd { +func (c *cmdable) ConfigSet(parameter, value string) *StatusCmd { cmd := NewStatusCmd("config", "set", parameter, value) c.process(cmd) return cmd } -func (c cmdable) DbSize() *IntCmd { +func (c *cmdable) DbSize() *IntCmd { cmd := NewIntCmd("dbsize") c.process(cmd) return cmd } -func (c cmdable) FlushAll() *StatusCmd { +func (c *cmdable) FlushAll() *StatusCmd { cmd := NewStatusCmd("flushall") c.process(cmd) return cmd } -func (c cmdable) FlushDb() *StatusCmd { +func (c *cmdable) FlushDb() *StatusCmd { cmd := NewStatusCmd("flushdb") c.process(cmd) return cmd } -func (c cmdable) Info(section ...string) *StringCmd { +func (c *cmdable) Info(section ...string) *StringCmd { args := []interface{}{"info"} if len(section) > 0 { args = append(args, section[0]) @@ -1487,19 +1487,19 @@ func (c cmdable) Info(section ...string) *StringCmd { return cmd } -func (c cmdable) LastSave() *IntCmd { +func (c *cmdable) LastSave() *IntCmd { cmd := NewIntCmd("lastsave") c.process(cmd) return cmd } -func (c cmdable) Save() *StatusCmd { +func (c *cmdable) Save() *StatusCmd { cmd := NewStatusCmd("save") c.process(cmd) return cmd } -func (c cmdable) shutdown(modifier string) *StatusCmd { +func (c *cmdable) shutdown(modifier string) *StatusCmd { var args []interface{} if modifier == "" { args = []interface{}{"shutdown"} @@ -1521,33 +1521,33 @@ func (c cmdable) shutdown(modifier string) *StatusCmd { return cmd } -func (c cmdable) Shutdown() *StatusCmd { +func (c *cmdable) Shutdown() *StatusCmd { return c.shutdown("") } -func (c cmdable) ShutdownSave() *StatusCmd { +func (c *cmdable) ShutdownSave() *StatusCmd { return c.shutdown("save") } -func (c cmdable) ShutdownNoSave() *StatusCmd { +func (c *cmdable) ShutdownNoSave() *StatusCmd { return c.shutdown("nosave") } -func (c cmdable) SlaveOf(host, port string) *StatusCmd { +func (c *cmdable) SlaveOf(host, port string) *StatusCmd { cmd := NewStatusCmd("slaveof", host, port) c.process(cmd) return cmd } -func (c cmdable) SlowLog() { +func (c *cmdable) SlowLog() { panic("not implemented") } -func (c cmdable) Sync() { +func (c *cmdable) Sync() { panic("not implemented") } -func (c cmdable) Time() *StringSliceCmd { +func (c *cmdable) Time() *StringSliceCmd { cmd := NewStringSliceCmd("time") c.process(cmd) return cmd @@ -1555,7 +1555,7 @@ func (c cmdable) Time() *StringSliceCmd { //------------------------------------------------------------------------------ -func (c cmdable) Eval(script string, keys []string, args ...interface{}) *Cmd { +func (c *cmdable) Eval(script string, keys []string, args ...interface{}) *Cmd { cmdArgs := make([]interface{}, 3+len(keys)+len(args)) cmdArgs[0] = "eval" cmdArgs[1] = script @@ -1572,7 +1572,7 @@ func (c cmdable) Eval(script string, keys []string, args ...interface{}) *Cmd { return cmd } -func (c cmdable) EvalSha(sha1 string, keys []string, args ...interface{}) *Cmd { +func (c *cmdable) EvalSha(sha1 string, keys []string, args ...interface{}) *Cmd { cmdArgs := make([]interface{}, 3+len(keys)+len(args)) cmdArgs[0] = "evalsha" cmdArgs[1] = sha1 @@ -1589,7 +1589,7 @@ func (c cmdable) EvalSha(sha1 string, keys []string, args ...interface{}) *Cmd { return cmd } -func (c cmdable) ScriptExists(scripts ...string) *BoolSliceCmd { +func (c *cmdable) ScriptExists(scripts ...string) *BoolSliceCmd { args := make([]interface{}, 2+len(scripts)) args[0] = "script" args[1] = "exists" @@ -1601,19 +1601,19 @@ func (c cmdable) ScriptExists(scripts ...string) *BoolSliceCmd { return cmd } -func (c cmdable) ScriptFlush() *StatusCmd { +func (c *cmdable) ScriptFlush() *StatusCmd { cmd := NewStatusCmd("script", "flush") c.process(cmd) return cmd } -func (c cmdable) ScriptKill() *StatusCmd { +func (c *cmdable) ScriptKill() *StatusCmd { cmd := NewStatusCmd("script", "kill") c.process(cmd) return cmd } -func (c cmdable) ScriptLoad(script string) *StringCmd { +func (c *cmdable) ScriptLoad(script string) *StringCmd { cmd := NewStringCmd("script", "load", script) c.process(cmd) return cmd @@ -1621,7 +1621,7 @@ func (c cmdable) ScriptLoad(script string) *StringCmd { //------------------------------------------------------------------------------ -func (c cmdable) DebugObject(key string) *StringCmd { +func (c *cmdable) DebugObject(key string) *StringCmd { cmd := NewStringCmd("debug", "object", key) c.process(cmd) return cmd @@ -1629,7 +1629,7 @@ func (c cmdable) DebugObject(key string) *StringCmd { //------------------------------------------------------------------------------ -func (c cmdable) PubSubChannels(pattern string) *StringSliceCmd { +func (c *cmdable) PubSubChannels(pattern string) *StringSliceCmd { args := []interface{}{"pubsub", "channels"} if pattern != "*" { args = append(args, pattern) @@ -1639,7 +1639,7 @@ func (c cmdable) PubSubChannels(pattern string) *StringSliceCmd { return cmd } -func (c cmdable) PubSubNumSub(channels ...string) *StringIntMapCmd { +func (c *cmdable) PubSubNumSub(channels ...string) *StringIntMapCmd { args := make([]interface{}, 2+len(channels)) args[0] = "pubsub" args[1] = "numsub" @@ -1651,7 +1651,7 @@ func (c cmdable) PubSubNumSub(channels ...string) *StringIntMapCmd { return cmd } -func (c cmdable) PubSubNumPat() *IntCmd { +func (c *cmdable) PubSubNumPat() *IntCmd { cmd := NewIntCmd("pubsub", "numpat") c.process(cmd) return cmd @@ -1659,73 +1659,73 @@ func (c cmdable) PubSubNumPat() *IntCmd { //------------------------------------------------------------------------------ -func (c cmdable) ClusterSlots() *ClusterSlotsCmd { +func (c *cmdable) ClusterSlots() *ClusterSlotsCmd { cmd := NewClusterSlotsCmd("cluster", "slots") c.process(cmd) return cmd } -func (c cmdable) ClusterNodes() *StringCmd { +func (c *cmdable) ClusterNodes() *StringCmd { cmd := NewStringCmd("cluster", "nodes") c.process(cmd) return cmd } -func (c cmdable) ClusterMeet(host, port string) *StatusCmd { +func (c *cmdable) ClusterMeet(host, port string) *StatusCmd { cmd := NewStatusCmd("cluster", "meet", host, port) c.process(cmd) return cmd } -func (c cmdable) ClusterForget(nodeID string) *StatusCmd { +func (c *cmdable) ClusterForget(nodeID string) *StatusCmd { cmd := NewStatusCmd("cluster", "forget", nodeID) c.process(cmd) return cmd } -func (c cmdable) ClusterReplicate(nodeID string) *StatusCmd { +func (c *cmdable) ClusterReplicate(nodeID string) *StatusCmd { cmd := NewStatusCmd("cluster", "replicate", nodeID) c.process(cmd) return cmd } -func (c cmdable) ClusterResetSoft() *StatusCmd { +func (c *cmdable) ClusterResetSoft() *StatusCmd { cmd := NewStatusCmd("cluster", "reset", "soft") c.process(cmd) return cmd } -func (c cmdable) ClusterResetHard() *StatusCmd { +func (c *cmdable) ClusterResetHard() *StatusCmd { cmd := NewStatusCmd("cluster", "reset", "hard") c.process(cmd) return cmd } -func (c cmdable) ClusterInfo() *StringCmd { +func (c *cmdable) ClusterInfo() *StringCmd { cmd := NewStringCmd("cluster", "info") c.process(cmd) return cmd } -func (c cmdable) ClusterKeySlot(key string) *IntCmd { +func (c *cmdable) ClusterKeySlot(key string) *IntCmd { cmd := NewIntCmd("cluster", "keyslot", key) c.process(cmd) return cmd } -func (c cmdable) ClusterCountFailureReports(nodeID string) *IntCmd { +func (c *cmdable) ClusterCountFailureReports(nodeID string) *IntCmd { cmd := NewIntCmd("cluster", "count-failure-reports", nodeID) c.process(cmd) return cmd } -func (c cmdable) ClusterCountKeysInSlot(slot int) *IntCmd { +func (c *cmdable) ClusterCountKeysInSlot(slot int) *IntCmd { cmd := NewIntCmd("cluster", "countkeysinslot", slot) c.process(cmd) return cmd } -func (c cmdable) ClusterDelSlots(slots ...int) *StatusCmd { +func (c *cmdable) ClusterDelSlots(slots ...int) *StatusCmd { args := make([]interface{}, 2+len(slots)) args[0] = "cluster" args[1] = "delslots" @@ -1737,7 +1737,7 @@ func (c cmdable) ClusterDelSlots(slots ...int) *StatusCmd { return cmd } -func (c cmdable) ClusterDelSlotsRange(min, max int) *StatusCmd { +func (c *cmdable) ClusterDelSlotsRange(min, max int) *StatusCmd { size := max - min + 1 slots := make([]int, size) for i := 0; i < size; i++ { @@ -1746,37 +1746,37 @@ func (c cmdable) ClusterDelSlotsRange(min, max int) *StatusCmd { return c.ClusterDelSlots(slots...) } -func (c cmdable) ClusterSaveConfig() *StatusCmd { +func (c *cmdable) ClusterSaveConfig() *StatusCmd { cmd := NewStatusCmd("cluster", "saveconfig") c.process(cmd) return cmd } -func (c cmdable) ClusterSlaves(nodeID string) *StringSliceCmd { +func (c *cmdable) ClusterSlaves(nodeID string) *StringSliceCmd { cmd := NewStringSliceCmd("cluster", "slaves", nodeID) c.process(cmd) return cmd } -func (c statefulCmdable) ReadOnly() *StatusCmd { +func (c *statefulCmdable) ReadOnly() *StatusCmd { cmd := NewStatusCmd("readonly") c.process(cmd) return cmd } -func (c statefulCmdable) ReadWrite() *StatusCmd { +func (c *statefulCmdable) ReadWrite() *StatusCmd { cmd := NewStatusCmd("readwrite") c.process(cmd) return cmd } -func (c cmdable) ClusterFailover() *StatusCmd { +func (c *cmdable) ClusterFailover() *StatusCmd { cmd := NewStatusCmd("cluster", "failover") c.process(cmd) return cmd } -func (c cmdable) ClusterAddSlots(slots ...int) *StatusCmd { +func (c *cmdable) ClusterAddSlots(slots ...int) *StatusCmd { args := make([]interface{}, 2+len(slots)) args[0] = "cluster" args[1] = "addslots" @@ -1788,7 +1788,7 @@ func (c cmdable) ClusterAddSlots(slots ...int) *StatusCmd { return cmd } -func (c cmdable) ClusterAddSlotsRange(min, max int) *StatusCmd { +func (c *cmdable) ClusterAddSlotsRange(min, max int) *StatusCmd { size := max - min + 1 slots := make([]int, size) for i := 0; i < size; i++ { @@ -1799,7 +1799,7 @@ func (c cmdable) ClusterAddSlotsRange(min, max int) *StatusCmd { //------------------------------------------------------------------------------ -func (c cmdable) GeoAdd(key string, geoLocation ...*GeoLocation) *IntCmd { +func (c *cmdable) GeoAdd(key string, geoLocation ...*GeoLocation) *IntCmd { args := make([]interface{}, 2+3*len(geoLocation)) args[0] = "geoadd" args[1] = key @@ -1813,19 +1813,19 @@ func (c cmdable) GeoAdd(key string, geoLocation ...*GeoLocation) *IntCmd { return cmd } -func (c cmdable) GeoRadius(key string, longitude, latitude float64, query *GeoRadiusQuery) *GeoLocationCmd { +func (c *cmdable) GeoRadius(key string, longitude, latitude float64, query *GeoRadiusQuery) *GeoLocationCmd { cmd := NewGeoLocationCmd(query, "georadius", key, longitude, latitude) c.process(cmd) return cmd } -func (c cmdable) GeoRadiusByMember(key, member string, query *GeoRadiusQuery) *GeoLocationCmd { +func (c *cmdable) GeoRadiusByMember(key, member string, query *GeoRadiusQuery) *GeoLocationCmd { cmd := NewGeoLocationCmd(query, "georadiusbymember", key, member) c.process(cmd) return cmd } -func (c cmdable) GeoDist(key string, member1, member2, unit string) *FloatCmd { +func (c *cmdable) GeoDist(key string, member1, member2, unit string) *FloatCmd { if unit == "" { unit = "km" } @@ -1834,7 +1834,7 @@ func (c cmdable) GeoDist(key string, member1, member2, unit string) *FloatCmd { return cmd } -func (c cmdable) GeoHash(key string, members ...string) *StringSliceCmd { +func (c *cmdable) GeoHash(key string, members ...string) *StringSliceCmd { args := make([]interface{}, 2+len(members)) args[0] = "geohash" args[1] = key @@ -1848,7 +1848,7 @@ func (c cmdable) GeoHash(key string, members ...string) *StringSliceCmd { //------------------------------------------------------------------------------ -func (c cmdable) Command() *CommandsInfoCmd { +func (c *cmdable) Command() *CommandsInfoCmd { cmd := NewCommandsInfoCmd("command") c.process(cmd) return cmd diff --git a/iterator.go b/iterator.go index 0219ab45..e9dfbad9 100644 --- a/iterator.go +++ b/iterator.go @@ -3,7 +3,7 @@ package redis import "sync" type Scanner struct { - client cmdable + client *cmdable *ScanCmd } diff --git a/pipeline.go b/pipeline.go index e946b9e9..fed6e0c1 100644 --- a/pipeline.go +++ b/pipeline.go @@ -22,32 +22,32 @@ type Pipeline struct { closed int32 } -func (pipe *Pipeline) Process(cmd Cmder) error { - pipe.mu.Lock() - pipe.cmds = append(pipe.cmds, cmd) - pipe.mu.Unlock() +func (c *Pipeline) Process(cmd Cmder) error { + c.mu.Lock() + c.cmds = append(c.cmds, cmd) + c.mu.Unlock() return nil } // Close closes the pipeline, releasing any open resources. -func (pipe *Pipeline) Close() error { - atomic.StoreInt32(&pipe.closed, 1) - pipe.Discard() +func (c *Pipeline) Close() error { + atomic.StoreInt32(&c.closed, 1) + c.Discard() return nil } -func (pipe *Pipeline) isClosed() bool { - return atomic.LoadInt32(&pipe.closed) == 1 +func (c *Pipeline) isClosed() bool { + return atomic.LoadInt32(&c.closed) == 1 } // Discard resets the pipeline and discards queued commands. -func (pipe *Pipeline) Discard() error { - defer pipe.mu.Unlock() - pipe.mu.Lock() - if pipe.isClosed() { +func (c *Pipeline) Discard() error { + defer c.mu.Unlock() + c.mu.Lock() + if c.isClosed() { return pool.ErrClosed } - pipe.cmds = pipe.cmds[:0] + c.cmds = c.cmds[:0] return nil } @@ -56,30 +56,30 @@ func (pipe *Pipeline) Discard() error { // // Exec always returns list of commands and error of the first failed // command if any. -func (pipe *Pipeline) Exec() ([]Cmder, error) { - if pipe.isClosed() { +func (c *Pipeline) Exec() ([]Cmder, error) { + if c.isClosed() { return nil, pool.ErrClosed } - defer pipe.mu.Unlock() - pipe.mu.Lock() + defer c.mu.Unlock() + c.mu.Lock() - if len(pipe.cmds) == 0 { - return pipe.cmds, nil + if len(c.cmds) == 0 { + return c.cmds, nil } - cmds := pipe.cmds - pipe.cmds = nil + cmds := c.cmds + c.cmds = nil - return cmds, pipe.exec(cmds) + return cmds, c.exec(cmds) } -func (pipe *Pipeline) pipelined(fn func(*Pipeline) error) ([]Cmder, error) { - if err := fn(pipe); err != nil { +func (c *Pipeline) pipelined(fn func(*Pipeline) error) ([]Cmder, error) { + if err := fn(c); err != nil { return nil, err } - cmds, err := pipe.Exec() - _ = pipe.Close() + cmds, err := c.Exec() + _ = c.Close() return cmds, err } diff --git a/ring.go b/ring.go index 50476fa8..8aba07e2 100644 --- a/ring.go +++ b/ring.go @@ -102,7 +102,7 @@ func (shard *ringShard) Vote(up bool) bool { // concurrent use by multiple goroutines. // // Ring monitors the state of each shard and removes dead shards from -// the ring. When shard comes online it is added back to the ring. This +// the c. When shard comes online it is added back to the c. This // gives you maximum availability and partition tolerance, but no // consistency between different shards or even clients. Each client // uses shards that are available to the client and does not do any @@ -149,58 +149,58 @@ func NewRing(opt *RingOptions) *Ring { return ring } -func (ring *Ring) cmdInfo(name string) *CommandInfo { - ring.cmdsInfoOnce.Do(func() { - for _, shard := range ring.shards { +func (c *Ring) cmdInfo(name string) *CommandInfo { + c.cmdsInfoOnce.Do(func() { + for _, shard := range c.shards { cmdsInfo, err := shard.Client.Command().Result() if err == nil { - ring.cmdsInfo = cmdsInfo + c.cmdsInfo = cmdsInfo return } } - ring.cmdsInfoOnce = &sync.Once{} + c.cmdsInfoOnce = &sync.Once{} }) - if ring.cmdsInfo == nil { + if c.cmdsInfo == nil { return nil } - return ring.cmdsInfo[name] + return c.cmdsInfo[name] } -func (ring *Ring) cmdFirstKey(cmd Cmder) string { - cmdInfo := ring.cmdInfo(cmd.arg(0)) +func (c *Ring) cmdFirstKey(cmd Cmder) string { + cmdInfo := c.cmdInfo(cmd.arg(0)) if cmdInfo == nil { return "" } return cmd.arg(int(cmdInfo.FirstKeyPos)) } -func (ring *Ring) addClient(name string, cl *Client) { - ring.mu.Lock() - ring.hash.Add(name) - ring.shards[name] = &ringShard{Client: cl} - ring.mu.Unlock() +func (c *Ring) addClient(name string, cl *Client) { + c.mu.Lock() + c.hash.Add(name) + c.shards[name] = &ringShard{Client: cl} + c.mu.Unlock() } -func (ring *Ring) getClient(key string) (*Client, error) { - ring.mu.RLock() +func (c *Ring) getClient(key string) (*Client, error) { + c.mu.RLock() - if ring.closed { + if c.closed { return nil, pool.ErrClosed } - name := ring.hash.Get(hashtag.Key(key)) + name := c.hash.Get(hashtag.Key(key)) if name == "" { - ring.mu.RUnlock() + c.mu.RUnlock() return nil, errRingShardsDown } - cl := ring.shards[name].Client - ring.mu.RUnlock() + cl := c.shards[name].Client + c.mu.RUnlock() return cl, nil } -func (ring *Ring) Process(cmd Cmder) error { - cl, err := ring.getClient(ring.cmdFirstKey(cmd)) +func (c *Ring) Process(cmd Cmder) error { + cl, err := c.getClient(c.cmdFirstKey(cmd)) if err != nil { cmd.setErr(err) return err @@ -208,34 +208,34 @@ func (ring *Ring) Process(cmd Cmder) error { return cl.baseClient.Process(cmd) } -// rebalance removes dead shards from the ring. -func (ring *Ring) rebalance() { - defer ring.mu.Unlock() - ring.mu.Lock() +// rebalance removes dead shards from the c. +func (c *Ring) rebalance() { + defer c.mu.Unlock() + c.mu.Lock() - ring.hash = consistenthash.New(ring.nreplicas, nil) - for name, shard := range ring.shards { + c.hash = consistenthash.New(c.nreplicas, nil) + for name, shard := range c.shards { if shard.IsUp() { - ring.hash.Add(name) + c.hash.Add(name) } } } -// heartbeat monitors state of each shard in the ring. -func (ring *Ring) heartbeat() { +// heartbeat monitors state of each shard in the c. +func (c *Ring) heartbeat() { ticker := time.NewTicker(100 * time.Millisecond) defer ticker.Stop() for _ = range ticker.C { var rebalance bool - ring.mu.RLock() + c.mu.RLock() - if ring.closed { - ring.mu.RUnlock() + if c.closed { + c.mu.RUnlock() break } - for _, shard := range ring.shards { + for _, shard := range c.shards { err := shard.Client.Ping().Err() if shard.Vote(err == nil || err == pool.ErrPoolTimeout) { internal.Logf("ring shard state changed: %s", shard) @@ -243,10 +243,10 @@ func (ring *Ring) heartbeat() { } } - ring.mu.RUnlock() + c.mu.RUnlock() if rebalance { - ring.rebalance() + c.rebalance() } } } @@ -255,45 +255,45 @@ func (ring *Ring) heartbeat() { // // It is rare to Close a Ring, as the Ring is meant to be long-lived // and shared between many goroutines. -func (ring *Ring) Close() (retErr error) { - defer ring.mu.Unlock() - ring.mu.Lock() +func (c *Ring) Close() (retErr error) { + defer c.mu.Unlock() + c.mu.Lock() - if ring.closed { + if c.closed { return nil } - ring.closed = true + c.closed = true - for _, shard := range ring.shards { + for _, shard := range c.shards { if err := shard.Client.Close(); err != nil { retErr = err } } - ring.hash = nil - ring.shards = nil + c.hash = nil + c.shards = nil return retErr } -func (ring *Ring) Pipeline() *Pipeline { +func (c *Ring) Pipeline() *Pipeline { pipe := Pipeline{ - exec: ring.pipelineExec, + exec: c.pipelineExec, } pipe.cmdable.process = pipe.Process pipe.statefulCmdable.process = pipe.Process return &pipe } -func (ring *Ring) Pipelined(fn func(*Pipeline) error) ([]Cmder, error) { - return ring.Pipeline().pipelined(fn) +func (c *Ring) Pipelined(fn func(*Pipeline) error) ([]Cmder, error) { + return c.Pipeline().pipelined(fn) } -func (ring *Ring) pipelineExec(cmds []Cmder) error { +func (c *Ring) pipelineExec(cmds []Cmder) error { var retErr error cmdsMap := make(map[string][]Cmder) for _, cmd := range cmds { - name := ring.hash.Get(hashtag.Key(ring.cmdFirstKey(cmd))) + name := c.hash.Get(hashtag.Key(c.cmdFirstKey(cmd))) if name == "" { cmd.setErr(errRingShardsDown) if retErr == nil { @@ -304,11 +304,11 @@ func (ring *Ring) pipelineExec(cmds []Cmder) error { cmdsMap[name] = append(cmdsMap[name], cmd) } - for i := 0; i <= ring.opt.MaxRetries; i++ { + for i := 0; i <= c.opt.MaxRetries; i++ { failedCmdsMap := make(map[string][]Cmder) for name, cmds := range cmdsMap { - client := ring.shards[name].Client + client := c.shards[name].Client cn, err := client.conn() if err != nil { setCmdsErr(cmds, err) diff --git a/tx.go b/tx.go index 4f85cc8d..5ed223c0 100644 --- a/tx.go +++ b/tx.go @@ -39,7 +39,7 @@ func (c *Client) Watch(fn func(*Tx) error, keys ...string) error { tx := c.newTx() if len(keys) > 0 { if err := tx.Watch(keys...).Err(); err != nil { - tx.close() + _ = tx.close() return err } } @@ -50,57 +50,57 @@ func (c *Client) Watch(fn func(*Tx) error, keys ...string) error { return retErr } -func (tx *Tx) Process(cmd Cmder) error { - if tx.cmds == nil { - return tx.baseClient.Process(cmd) +func (c *Tx) Process(cmd Cmder) error { + if c.cmds == nil { + return c.baseClient.Process(cmd) } - tx.cmds = append(tx.cmds, cmd) + c.cmds = append(c.cmds, cmd) return nil } // close closes the transaction, releasing any open resources. -func (tx *Tx) close() error { - if tx.closed { +func (c *Tx) close() error { + if c.closed { return nil } - tx.closed = true - if err := tx.Unwatch().Err(); err != nil { + c.closed = true + if err := c.Unwatch().Err(); err != nil { internal.Logf("Unwatch failed: %s", err) } - return tx.baseClient.Close() + return c.baseClient.Close() } // Watch marks the keys to be watched for conditional execution // of a transaction. -func (tx *Tx) Watch(keys ...string) *StatusCmd { +func (c *Tx) Watch(keys ...string) *StatusCmd { args := make([]interface{}, 1+len(keys)) args[0] = "WATCH" for i, key := range keys { args[1+i] = key } cmd := NewStatusCmd(args...) - tx.Process(cmd) + c.Process(cmd) return cmd } // Unwatch flushes all the previously watched keys for a transaction. -func (tx *Tx) Unwatch(keys ...string) *StatusCmd { +func (c *Tx) Unwatch(keys ...string) *StatusCmd { args := make([]interface{}, 1+len(keys)) args[0] = "UNWATCH" for i, key := range keys { args[1+i] = key } cmd := NewStatusCmd(args...) - tx.Process(cmd) + c.Process(cmd) return cmd } // Discard discards queued commands. -func (tx *Tx) Discard() error { - if tx.cmds == nil { +func (c *Tx) Discard() error { + if c.cmds == nil { return errDiscard } - tx.cmds = tx.cmds[:1] + c.cmds = c.cmds[:1] return nil } @@ -113,19 +113,19 @@ func (tx *Tx) Discard() error { // Exec always returns list of commands. If transaction fails // TxFailedErr is returned. Otherwise Exec returns error of the first // failed command or nil. -func (tx *Tx) MultiExec(fn func() error) ([]Cmder, error) { - if tx.closed { +func (c *Tx) MultiExec(fn func() error) ([]Cmder, error) { + if c.closed { return nil, pool.ErrClosed } - tx.cmds = []Cmder{NewStatusCmd("MULTI")} + c.cmds = []Cmder{NewStatusCmd("MULTI")} if err := fn(); err != nil { return nil, err } - tx.cmds = append(tx.cmds, NewSliceCmd("EXEC")) + c.cmds = append(c.cmds, NewSliceCmd("EXEC")) - cmds := tx.cmds - tx.cmds = nil + cmds := c.cmds + c.cmds = nil if len(cmds) == 2 { return []Cmder{}, nil @@ -134,18 +134,18 @@ func (tx *Tx) MultiExec(fn func() error) ([]Cmder, error) { // Strip MULTI and EXEC commands. retCmds := cmds[1 : len(cmds)-1] - cn, err := tx.conn() + cn, err := c.conn() if err != nil { setCmdsErr(retCmds, err) return retCmds, err } - err = tx.execCmds(cn, cmds) - tx.putConn(cn, err, false) + err = c.execCmds(cn, cmds) + c.putConn(cn, err, false) return retCmds, err } -func (tx *Tx) execCmds(cn *pool.Conn, cmds []Cmder) error { +func (c *Tx) execCmds(cn *pool.Conn, cmds []Cmder) error { err := writeCmd(cn, cmds...) if err != nil { setCmdsErr(cmds[1:len(cmds)-1], err)