import "github.com/go-redis/redis"
Package redis implements a Redis client.
Code:
Get := func(client *redis.Client, key string) *redis.StringCmd {
cmd := redis.NewStringCmd("get", key)
client.Process(cmd)
return cmd
}
v, err := Get(client, "key_does_not_exist").Result()
fmt.Printf("%q %s", v, err)
Output:
"" redis: nil
Code:
cl := redis.NewClient(&redis.Options{
Addr: ":6379",
})
cl.WrapProcess(func(old func(cmd redis.Cmder) error) func(cmd redis.Cmder) error {
return func(cmd redis.Cmder) error {
fmt.Printf("starting processing: <%s>\n", cmd)
err := old(cmd)
fmt.Printf("finished processing: <%s>\n", cmd)
return err
}
})
cl.Ping()
Output:
starting processing: <ping: > finished processing: <ping: PONG>
cluster.go cluster_commands.go command.go commands.go doc.go iterator.go options.go parser.go pipeline.go pubsub.go redis.go result.go ring.go script.go sentinel.go tx.go universal.go
Nil reply Redis returns when key does not exist.
const TxFailedErr = proto.RedisError("redis: transaction failed")
TxFailedErr transaction redis failed.
type BoolCmd struct {
// contains filtered or unexported fields
}NewBoolResult returns a BoolCmd initialised with val and err for testing
func (cmd *BoolCmd) Args() []interface{}type BoolSliceCmd struct {
// contains filtered or unexported fields
}func NewBoolSliceCmd(args ...interface{}) *BoolSliceCmdfunc NewBoolSliceResult(val []bool, err error) *BoolSliceCmd
NewBoolSliceResult returns a BoolSliceCmd initialised with val and err for testing
func (cmd *BoolSliceCmd) Args() []interface{}func (cmd *BoolSliceCmd) Result() ([]bool, error)
func (cmd *BoolSliceCmd) String() string
func (cmd *BoolSliceCmd) Val() []bool
type Client struct {
// contains filtered or unexported fields
}Client is a Redis client representing a pool of zero or more underlying connections. It's safe for concurrent use by multiple goroutines.
Code:
err := client.Set("key", "value", 0).Err()
if err != nil {
panic(err)
}
val, err := client.Get("key").Result()
if err != nil {
panic(err)
}
fmt.Println("key", val)
val2, err := client.Get("key2").Result()
if err == redis.Nil {
fmt.Println("key2 does not exist")
} else if err != nil {
panic(err)
} else {
fmt.Println("key2", val2)
}
Output:
key value key2 does not exist
NewClient returns a client to the Redis Server specified by Options.
Code:
client := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "", // no password set
DB: 0, // use default DB
})
pong, err := client.Ping().Result()
fmt.Println(pong, err)
Output:
PONG <nil>
func NewFailoverClient(failoverOpt *FailoverOptions) *Client
NewFailoverClient returns a Redis client that uses Redis Sentinel for automatic failover. It's safe for concurrent use by multiple goroutines.
Code:
// See http://redis.io/topics/sentinel for instructions how to
// setup Redis Sentinel.
client := redis.NewFailoverClient(&redis.FailoverOptions{
MasterName: "master",
SentinelAddrs: []string{":26379"},
})
client.Ping()
func (c *Client) BLPop(timeout time.Duration, keys ...string) *StringSliceCmd
Code:
if err := client.RPush("queue", "message").Err(); err != nil {
panic(err)
}
// use `client.BLPop(0, "queue")` for infinite waiting time
result, err := client.BLPop(1*time.Second, "queue").Result()
if err != nil {
panic(err)
}
fmt.Println(result[0], result[1])
Output:
queue message
func (c *Client) BRPop(timeout time.Duration, keys ...string) *StringSliceCmd
ClientGetName returns the name of the connection.
Close closes the client, releasing any open resources.
It is rare to Close a Client, as the Client is meant to be long-lived and shared between many goroutines.
func (c *Client) ClusterSlaves(nodeID string) *StringSliceCmd
func (c *Client) ClusterSlots() *ClusterSlotsCmd
func (c *Client) Command() *CommandsInfoCmd
Deperecated. Use DBSize instead.
Deprecated. Use FlushDB instead.
func (c *Client) GeoAdd(key string, geoLocation ...*GeoLocation) *IntCmd
func (c *Client) GeoHash(key string, members ...string) *StringSliceCmd
func (c *Client) GeoRadius(key string, longitude, latitude float64, query *GeoRadiusQuery) *GeoLocationCmd
func (c *Client) GeoRadiusByMember(key, member string, query *GeoRadiusQuery) *GeoLocationCmd
func (c *Client) GeoRadiusByMemberRO(key, member string, query *GeoRadiusQuery) *GeoLocationCmd
func (c *Client) GeoRadiusRO(key string, longitude, latitude float64, query *GeoRadiusQuery) *GeoLocationCmd
Redis `GET key` command. It returns redis.Nil error when key does not exist.
func (c *Client) HGetAll(key string) *StringStringMapCmd
func (c *Client) HKeys(key string) *StringSliceCmd
func (c *Client) HVals(key string) *StringSliceCmd
Code:
result, err := client.Incr("counter").Result()
if err != nil {
panic(err)
}
fmt.Println(result)
Output:
1
func (c *Client) Keys(pattern string) *StringSliceCmd
func (c *Client) LRange(key string, start, stop int64) *StringSliceCmd
func (c *Client) ObjectIdleTime(key string) *DurationCmd
Options returns read-only Options that were used to create the client.
PSubscribe subscribes the client to the given patterns. Patterns can be omitted to create empty subscription.
func (c *Client) PTTL(key string) *DurationCmd
Code:
pipe := client.Pipeline()
incr := pipe.Incr("pipeline_counter")
pipe.Expire("pipeline_counter", time.Hour)
// Execute
//
// INCR pipeline_counter
// EXPIRE pipeline_counts 3600
//
// using one client-server roundtrip.
_, err := pipe.Exec()
fmt.Println(incr.Val(), err)
Output:
1 <nil>
Code:
var incr *redis.IntCmd
_, err := client.Pipelined(func(pipe redis.Pipeliner) error {
incr = pipe.Incr("pipelined_counter")
pipe.Expire("pipelined_counter", time.Hour)
return nil
})
fmt.Println(incr.Val(), err)
Output:
1 <nil>
PoolStats returns connection pool stats.
func (c *Client) PubSubChannels(pattern string) *StringSliceCmd
func (c *Client) PubSubNumSub(channels ...string) *StringIntMapCmd
Publish posts the message to the channel.
func (c *Client) SDiff(keys ...string) *StringSliceCmd
func (c *Client) SInter(keys ...string) *StringSliceCmd
func (c *Client) SMembers(key string) *StringSliceCmd
Redis `SMEMBERS key` command output as a slice
func (c *Client) SMembersMap(key string) *StringStructMapCmd
Redis `SMEMBERS key` command output as a map
Redis `SPOP key` command.
func (c *Client) SPopN(key string, count int64) *StringSliceCmd
Redis `SPOP key count` command.
Redis `SRANDMEMBER key` command.
func (c *Client) SRandMemberN(key string, count int64) *StringSliceCmd
Redis `SRANDMEMBER key count` command.
func (c *Client) SUnion(keys ...string) *StringSliceCmd
Code:
client.FlushDB()
for i := 0; i < 33; i++ {
err := client.Set(fmt.Sprintf("key%d", i), "value", 0).Err()
if err != nil {
panic(err)
}
}
var cursor uint64
var n int
for {
var keys []string
var err error
keys, cursor, err = client.Scan(cursor, "", 10).Result()
if err != nil {
panic(err)
}
n += len(keys)
if cursor == 0 {
break
}
}
fmt.Printf("found %d keys\n", n)
Output:
found 33 keys
func (c *Client) ScriptExists(hashes ...string) *BoolSliceCmd
Redis `SET key value [expiration]` command.
Use expiration for `SETEX`-like behavior. Zero expiration means the key has no expiration time.
Code:
// Last argument is expiration. Zero means the key has no // expiration time. err := client.Set("key", "value", 0).Err() if err != nil { panic(err) } // key2 will expire in an hour. err = client.Set("key2", "value", time.Hour).Err() if err != nil { panic(err) }
Redis `SET key value [expiration] NX` command.
Zero expiration means the key has no expiration time.
Redis `SET key value [expiration] XX` command.
Zero expiration means the key has no expiration time.
func (c *Client) SlowLog()
func (c *Client) Sort(key string, sort *Sort) *StringSliceCmd
Subscribe subscribes the client to the specified channels. Channels can be omitted to create empty subscription.
func (c *Client) Sync()
func (c *Client) TTL(key string) *DurationCmd
TxPipeline acts like Pipeline, but wraps queued commands with MULTI/EXEC.
Code:
pipe := client.TxPipeline()
incr := pipe.Incr("tx_pipeline_counter")
pipe.Expire("tx_pipeline_counter", time.Hour)
// Execute
//
// MULTI
// INCR pipeline_counter
// EXPIRE pipeline_counts 3600
// EXEC
//
// using one client-server roundtrip.
_, err := pipe.Exec()
fmt.Println(incr.Val(), err)
Output:
1 <nil>
Code:
var incr *redis.IntCmd
_, err := client.TxPipelined(func(pipe redis.Pipeliner) error {
incr = pipe.Incr("tx_pipelined_counter")
pipe.Expire("tx_pipelined_counter", time.Hour)
return nil
})
fmt.Println(incr.Val(), err)
Output:
1 <nil>
Code:
var incr func(string) error
// Transactionally increments key using GET and SET commands.
incr = func(key string) error {
err := client.Watch(func(tx *redis.Tx) error {
n, err := tx.Get(key).Int64()
if err != nil && err != redis.Nil {
return err
}
_, err = tx.Pipelined(func(pipe redis.Pipeliner) error {
pipe.Set(key, strconv.FormatInt(n+1, 10), 0)
return nil
})
return err
}, key)
if err == redis.TxFailedErr {
return incr(key)
}
return err
}
var wg sync.WaitGroup
for i := 0; i < 100; i++ {
wg.Add(1)
go func() {
defer wg.Done()
err := incr("counter3")
if err != nil {
panic(err)
}
}()
}
wg.Wait()
n, err := client.Get("counter3").Int64()
fmt.Println(n, err)
Output:
100 <nil>
WrapProcess wraps function that processes Redis commands.
func (c *Client) WrapProcessPipeline(
fn func(oldProcess func([]Cmder) error) func([]Cmder) error,
)Redis `ZADD key score member [score member ...]` command.
Redis `ZADD key CH score member [score member ...]` command.
Redis `ZADD key NX score member [score member ...]` command.
Redis `ZADD key NX CH score member [score member ...]` command.
Redis `ZADD key XX score member [score member ...]` command.
Redis `ZADD key XX CH score member [score member ...]` command.
Redis `ZADD key INCR score member` command.
Redis `ZADD key NX INCR score member` command.
Redis `ZADD key XX INCR score member` command.
func (c *Client) ZRange(key string, start, stop int64) *StringSliceCmd
func (c *Client) ZRangeByLex(key string, opt ZRangeBy) *StringSliceCmd
func (c *Client) ZRangeByScore(key string, opt ZRangeBy) *StringSliceCmd
func (c *Client) ZRevRange(key string, start, stop int64) *StringSliceCmd
func (c *Client) ZRevRangeByLex(key string, opt ZRangeBy) *StringSliceCmd
func (c *Client) ZRevRangeByScore(key string, opt ZRangeBy) *StringSliceCmd
type ClusterClient struct {
// contains filtered or unexported fields
}ClusterClient is a Redis Cluster client representing a pool of zero or more underlying connections. It's safe for concurrent use by multiple goroutines.
func NewClusterClient(opt *ClusterOptions) *ClusterClient
NewClusterClient returns a Redis Cluster client as described in http://redis.io/topics/cluster-spec.
Code:
// See http://redis.io/topics/cluster-tutorial for instructions
// how to setup Redis Cluster.
client := redis.NewClusterClient(&redis.ClusterOptions{
Addrs: []string{":7000", ":7001", ":7002", ":7003", ":7004", ":7005"},
})
client.Ping()
func (c *ClusterClient) BLPop(timeout time.Duration, keys ...string) *StringSliceCmd
func (c *ClusterClient) BRPop(timeout time.Duration, keys ...string) *StringSliceCmd
ClientGetName returns the name of the connection.
func (c *ClusterClient) Close() error
Close closes the cluster client, releasing any open resources.
It is rare to Close a ClusterClient, as the ClusterClient is meant to be long-lived and shared between many goroutines.
func (c *ClusterClient) ClusterSlaves(nodeID string) *StringSliceCmd
func (c *ClusterClient) ClusterSlots() *ClusterSlotsCmd
func (c *ClusterClient) Command() *CommandsInfoCmd
func (c *ClusterClient) Context() context.Context
func (c *ClusterClient) DBSize() *IntCmd
Deperecated. Use DBSize instead.
Deprecated. Use FlushDB instead.
func (c *ClusterClient) ForEachMaster(fn func(client *Client) error) error
ForEachMaster concurrently calls the fn on each master node in the cluster. It returns the first error if any.
func (c *ClusterClient) ForEachNode(fn func(client *Client) error) error
ForEachNode concurrently calls the fn on each known node in the cluster. It returns the first error if any.
func (c *ClusterClient) ForEachSlave(fn func(client *Client) error) error
ForEachSlave concurrently calls the fn on each slave node in the cluster. It returns the first error if any.
func (c *ClusterClient) GeoAdd(key string, geoLocation ...*GeoLocation) *IntCmd
func (c *ClusterClient) GeoHash(key string, members ...string) *StringSliceCmd
func (c *ClusterClient) GeoRadius(key string, longitude, latitude float64, query *GeoRadiusQuery) *GeoLocationCmd
func (c *ClusterClient) GeoRadiusByMember(key, member string, query *GeoRadiusQuery) *GeoLocationCmd
func (c *ClusterClient) GeoRadiusByMemberRO(key, member string, query *GeoRadiusQuery) *GeoLocationCmd
func (c *ClusterClient) GeoRadiusRO(key string, longitude, latitude float64, query *GeoRadiusQuery) *GeoLocationCmd
Redis `GET key` command. It returns redis.Nil error when key does not exist.
func (c *ClusterClient) HGetAll(key string) *StringStringMapCmd
func (c *ClusterClient) HKeys(key string) *StringSliceCmd
func (c *ClusterClient) HVals(key string) *StringSliceCmd
func (c *ClusterClient) Keys(pattern string) *StringSliceCmd
func (c *ClusterClient) LRange(key string, start, stop int64) *StringSliceCmd
func (c *ClusterClient) Migrate(host, port, key string, db int64, timeout time.Duration) *StatusCmd
func (c *ClusterClient) ObjectIdleTime(key string) *DurationCmd
func (c *ClusterClient) Options() *ClusterOptions
Options returns read-only Options that were used to create the client.
func (c *ClusterClient) PSubscribe(channels ...string) *PubSub
PSubscribe subscribes the client to the given patterns. Patterns can be omitted to create empty subscription.
func (c *ClusterClient) PTTL(key string) *DurationCmd
func (c *ClusterClient) Pipeline() Pipeliner
func (c *ClusterClient) PoolStats() *PoolStats
PoolStats returns accumulated connection pool stats.
func (c *ClusterClient) Process(cmd Cmder) error
func (c *ClusterClient) PubSubChannels(pattern string) *StringSliceCmd
func (c *ClusterClient) PubSubNumSub(channels ...string) *StringIntMapCmd
Publish posts the message to the channel.
func (c *ClusterClient) SDiff(keys ...string) *StringSliceCmd
func (c *ClusterClient) SInter(keys ...string) *StringSliceCmd
func (c *ClusterClient) SMembers(key string) *StringSliceCmd
Redis `SMEMBERS key` command output as a slice
func (c *ClusterClient) SMembersMap(key string) *StringStructMapCmd
Redis `SMEMBERS key` command output as a map
Redis `SPOP key` command.
func (c *ClusterClient) SPopN(key string, count int64) *StringSliceCmd
Redis `SPOP key count` command.
Redis `SRANDMEMBER key` command.
func (c *ClusterClient) SRandMemberN(key string, count int64) *StringSliceCmd
Redis `SRANDMEMBER key count` command.
func (c *ClusterClient) SUnion(keys ...string) *StringSliceCmd
func (c *ClusterClient) ScriptExists(hashes ...string) *BoolSliceCmd
Redis `SET key value [expiration]` command.
Use expiration for `SETEX`-like behavior. Zero expiration means the key has no expiration time.
Redis `SET key value [expiration] NX` command.
Zero expiration means the key has no expiration time.
Redis `SET key value [expiration] XX` command.
Zero expiration means the key has no expiration time.
func (c *ClusterClient) SlowLog()
func (c *ClusterClient) Sort(key string, sort *Sort) *StringSliceCmd
func (c *ClusterClient) Subscribe(channels ...string) *PubSub
Subscribe subscribes the client to the specified channels. Channels can be omitted to create empty subscription.
func (c *ClusterClient) Sync()
func (c *ClusterClient) TTL(key string) *DurationCmd
func (c *ClusterClient) TxPipeline() Pipeliner
TxPipeline acts like Pipeline, but wraps queued commands with MULTI/EXEC.
func (c *ClusterClient) WithContext(ctx context.Context) *ClusterClient
func (c *ClusterClient) WrapProcessPipeline( fn func(oldProcess func([]Cmder) error) func([]Cmder) error, )
Redis `ZADD key score member [score member ...]` command.
Redis `ZADD key CH score member [score member ...]` command.
Redis `ZADD key NX score member [score member ...]` command.
Redis `ZADD key NX CH score member [score member ...]` command.
Redis `ZADD key XX score member [score member ...]` command.
Redis `ZADD key XX CH score member [score member ...]` command.
Redis `ZADD key INCR score member` command.
Redis `ZADD key NX INCR score member` command.
Redis `ZADD key XX INCR score member` command.
func (c *ClusterClient) ZRange(key string, start, stop int64) *StringSliceCmd
func (c *ClusterClient) ZRangeByLex(key string, opt ZRangeBy) *StringSliceCmd
func (c *ClusterClient) ZRangeByScore(key string, opt ZRangeBy) *StringSliceCmd
func (c *ClusterClient) ZRevRange(key string, start, stop int64) *StringSliceCmd
func (c *ClusterClient) ZRevRangeByLex(key string, opt ZRangeBy) *StringSliceCmd
func (c *ClusterClient) ZRevRangeByScore(key string, opt ZRangeBy) *StringSliceCmd
type ClusterOptions struct {
// A seed list of host:port addresses of cluster nodes.
Addrs []string
// The maximum number of retries before giving up. Command is retried
// on network errors and MOVED/ASK redirects.
// Default is 8.
MaxRedirects int
// Enables read-only commands on slave nodes.
ReadOnly bool
// Allows routing read-only commands to the closest master or slave node.
RouteByLatency bool
// Allows routing read-only commands to the random master or slave node.
RouteRandomly bool
OnConnect func(*Conn) error
MaxRetries int
MinRetryBackoff time.Duration
MaxRetryBackoff time.Duration
Password string
DialTimeout time.Duration
ReadTimeout time.Duration
WriteTimeout time.Duration
// PoolSize applies per cluster node and not for the whole cluster.
PoolSize int
PoolTimeout time.Duration
IdleTimeout time.Duration
IdleCheckFrequency time.Duration
}ClusterOptions are used to configure a cluster client and should be passed to NewClusterClient.
type ClusterSlot struct {
Start int
End int
Nodes []ClusterNode
}type ClusterSlotsCmd struct {
// contains filtered or unexported fields
}func NewClusterSlotsCmd(args ...interface{}) *ClusterSlotsCmdfunc NewClusterSlotsCmdResult(val []ClusterSlot, err error) *ClusterSlotsCmd
NewClusterSlotsCmdResult returns a ClusterSlotsCmd initialised with val and err for testing
func (cmd *ClusterSlotsCmd) Args() []interface{}func (cmd *ClusterSlotsCmd) Result() ([]ClusterSlot, error)
func (cmd *ClusterSlotsCmd) String() string
func (cmd *ClusterSlotsCmd) Val() []ClusterSlot
type Cmd struct {
// contains filtered or unexported fields
}NewCmdResult returns a Cmd initialised with val and err for testing
func (cmd *Cmd) Args() []interface{}type Cmdable interface {
Pipeline() Pipeliner
Pipelined(fn func(Pipeliner) error) ([]Cmder, error)
TxPipelined(fn func(Pipeliner) error) ([]Cmder, error)
TxPipeline() Pipeliner
ClientGetName() *StringCmd
Echo(message interface{}) *StringCmd
Ping() *StatusCmd
Quit() *StatusCmd
Del(keys ...string) *IntCmd
Unlink(keys ...string) *IntCmd
Dump(key string) *StringCmd
Exists(keys ...string) *IntCmd
Expire(key string, expiration time.Duration) *BoolCmd
ExpireAt(key string, tm time.Time) *BoolCmd
Keys(pattern string) *StringSliceCmd
Migrate(host, port, key string, db int64, timeout time.Duration) *StatusCmd
Move(key string, db int64) *BoolCmd
ObjectRefCount(key string) *IntCmd
ObjectEncoding(key string) *StringCmd
ObjectIdleTime(key string) *DurationCmd
Persist(key string) *BoolCmd
PExpire(key string, expiration time.Duration) *BoolCmd
PExpireAt(key string, tm time.Time) *BoolCmd
PTTL(key string) *DurationCmd
RandomKey() *StringCmd
Rename(key, newkey string) *StatusCmd
RenameNX(key, newkey string) *BoolCmd
Restore(key string, ttl time.Duration, value string) *StatusCmd
RestoreReplace(key string, ttl time.Duration, value string) *StatusCmd
Sort(key string, sort *Sort) *StringSliceCmd
SortStore(key, store string, sort *Sort) *IntCmd
SortInterfaces(key string, sort *Sort) *SliceCmd
Touch(keys ...string) *IntCmd
TTL(key string) *DurationCmd
Type(key string) *StatusCmd
Scan(cursor uint64, match string, count int64) *ScanCmd
SScan(key string, cursor uint64, match string, count int64) *ScanCmd
HScan(key string, cursor uint64, match string, count int64) *ScanCmd
ZScan(key string, cursor uint64, match string, count int64) *ScanCmd
Append(key, value string) *IntCmd
BitCount(key string, bitCount *BitCount) *IntCmd
BitOpAnd(destKey string, keys ...string) *IntCmd
BitOpOr(destKey string, keys ...string) *IntCmd
BitOpXor(destKey string, keys ...string) *IntCmd
BitOpNot(destKey string, key string) *IntCmd
BitPos(key string, bit int64, pos ...int64) *IntCmd
Decr(key string) *IntCmd
DecrBy(key string, decrement int64) *IntCmd
Get(key string) *StringCmd
GetBit(key string, offset int64) *IntCmd
GetRange(key string, start, end int64) *StringCmd
GetSet(key string, value interface{}) *StringCmd
Incr(key string) *IntCmd
IncrBy(key string, value int64) *IntCmd
IncrByFloat(key string, value float64) *FloatCmd
MGet(keys ...string) *SliceCmd
MSet(pairs ...interface{}) *StatusCmd
MSetNX(pairs ...interface{}) *BoolCmd
Set(key string, value interface{}, expiration time.Duration) *StatusCmd
SetBit(key string, offset int64, value int) *IntCmd
SetNX(key string, value interface{}, expiration time.Duration) *BoolCmd
SetXX(key string, value interface{}, expiration time.Duration) *BoolCmd
SetRange(key string, offset int64, value string) *IntCmd
StrLen(key string) *IntCmd
HDel(key string, fields ...string) *IntCmd
HExists(key, field string) *BoolCmd
HGet(key, field string) *StringCmd
HGetAll(key string) *StringStringMapCmd
HIncrBy(key, field string, incr int64) *IntCmd
HIncrByFloat(key, field string, incr float64) *FloatCmd
HKeys(key string) *StringSliceCmd
HLen(key string) *IntCmd
HMGet(key string, fields ...string) *SliceCmd
HMSet(key string, fields map[string]interface{}) *StatusCmd
HSet(key, field string, value interface{}) *BoolCmd
HSetNX(key, field string, value interface{}) *BoolCmd
HVals(key string) *StringSliceCmd
BLPop(timeout time.Duration, keys ...string) *StringSliceCmd
BRPop(timeout time.Duration, keys ...string) *StringSliceCmd
BRPopLPush(source, destination string, timeout time.Duration) *StringCmd
LIndex(key string, index int64) *StringCmd
LInsert(key, op string, pivot, value interface{}) *IntCmd
LInsertBefore(key string, pivot, value interface{}) *IntCmd
LInsertAfter(key string, pivot, value interface{}) *IntCmd
LLen(key string) *IntCmd
LPop(key string) *StringCmd
LPush(key string, values ...interface{}) *IntCmd
LPushX(key string, value interface{}) *IntCmd
LRange(key string, start, stop int64) *StringSliceCmd
LRem(key string, count int64, value interface{}) *IntCmd
LSet(key string, index int64, value interface{}) *StatusCmd
LTrim(key string, start, stop int64) *StatusCmd
RPop(key string) *StringCmd
RPopLPush(source, destination string) *StringCmd
RPush(key string, values ...interface{}) *IntCmd
RPushX(key string, value interface{}) *IntCmd
SAdd(key string, members ...interface{}) *IntCmd
SCard(key string) *IntCmd
SDiff(keys ...string) *StringSliceCmd
SDiffStore(destination string, keys ...string) *IntCmd
SInter(keys ...string) *StringSliceCmd
SInterStore(destination string, keys ...string) *IntCmd
SIsMember(key string, member interface{}) *BoolCmd
SMembers(key string) *StringSliceCmd
SMembersMap(key string) *StringStructMapCmd
SMove(source, destination string, member interface{}) *BoolCmd
SPop(key string) *StringCmd
SPopN(key string, count int64) *StringSliceCmd
SRandMember(key string) *StringCmd
SRandMemberN(key string, count int64) *StringSliceCmd
SRem(key string, members ...interface{}) *IntCmd
SUnion(keys ...string) *StringSliceCmd
SUnionStore(destination string, keys ...string) *IntCmd
ZAdd(key string, members ...Z) *IntCmd
ZAddNX(key string, members ...Z) *IntCmd
ZAddXX(key string, members ...Z) *IntCmd
ZAddCh(key string, members ...Z) *IntCmd
ZAddNXCh(key string, members ...Z) *IntCmd
ZAddXXCh(key string, members ...Z) *IntCmd
ZIncr(key string, member Z) *FloatCmd
ZIncrNX(key string, member Z) *FloatCmd
ZIncrXX(key string, member Z) *FloatCmd
ZCard(key string) *IntCmd
ZCount(key, min, max string) *IntCmd
ZLexCount(key, min, max string) *IntCmd
ZIncrBy(key string, increment float64, member string) *FloatCmd
ZInterStore(destination string, store ZStore, keys ...string) *IntCmd
ZRange(key string, start, stop int64) *StringSliceCmd
ZRangeWithScores(key string, start, stop int64) *ZSliceCmd
ZRangeByScore(key string, opt ZRangeBy) *StringSliceCmd
ZRangeByLex(key string, opt ZRangeBy) *StringSliceCmd
ZRangeByScoreWithScores(key string, opt ZRangeBy) *ZSliceCmd
ZRank(key, member string) *IntCmd
ZRem(key string, members ...interface{}) *IntCmd
ZRemRangeByRank(key string, start, stop int64) *IntCmd
ZRemRangeByScore(key, min, max string) *IntCmd
ZRemRangeByLex(key, min, max string) *IntCmd
ZRevRange(key string, start, stop int64) *StringSliceCmd
ZRevRangeWithScores(key string, start, stop int64) *ZSliceCmd
ZRevRangeByScore(key string, opt ZRangeBy) *StringSliceCmd
ZRevRangeByLex(key string, opt ZRangeBy) *StringSliceCmd
ZRevRangeByScoreWithScores(key string, opt ZRangeBy) *ZSliceCmd
ZRevRank(key, member string) *IntCmd
ZScore(key, member string) *FloatCmd
ZUnionStore(dest string, store ZStore, keys ...string) *IntCmd
PFAdd(key string, els ...interface{}) *IntCmd
PFCount(keys ...string) *IntCmd
PFMerge(dest string, keys ...string) *StatusCmd
BgRewriteAOF() *StatusCmd
BgSave() *StatusCmd
ClientKill(ipPort string) *StatusCmd
ClientList() *StringCmd
ClientPause(dur time.Duration) *BoolCmd
ConfigGet(parameter string) *SliceCmd
ConfigResetStat() *StatusCmd
ConfigSet(parameter, value string) *StatusCmd
ConfigRewrite() *StatusCmd
DBSize() *IntCmd
FlushAll() *StatusCmd
FlushAllAsync() *StatusCmd
FlushDB() *StatusCmd
FlushDBAsync() *StatusCmd
Info(section ...string) *StringCmd
LastSave() *IntCmd
Save() *StatusCmd
Shutdown() *StatusCmd
ShutdownSave() *StatusCmd
ShutdownNoSave() *StatusCmd
SlaveOf(host, port string) *StatusCmd
Time() *TimeCmd
Eval(script string, keys []string, args ...interface{}) *Cmd
EvalSha(sha1 string, keys []string, args ...interface{}) *Cmd
ScriptExists(hashes ...string) *BoolSliceCmd
ScriptFlush() *StatusCmd
ScriptKill() *StatusCmd
ScriptLoad(script string) *StringCmd
DebugObject(key string) *StringCmd
Publish(channel string, message interface{}) *IntCmd
PubSubChannels(pattern string) *StringSliceCmd
PubSubNumSub(channels ...string) *StringIntMapCmd
PubSubNumPat() *IntCmd
ClusterSlots() *ClusterSlotsCmd
ClusterNodes() *StringCmd
ClusterMeet(host, port string) *StatusCmd
ClusterForget(nodeID string) *StatusCmd
ClusterReplicate(nodeID string) *StatusCmd
ClusterResetSoft() *StatusCmd
ClusterResetHard() *StatusCmd
ClusterInfo() *StringCmd
ClusterKeySlot(key string) *IntCmd
ClusterCountFailureReports(nodeID string) *IntCmd
ClusterCountKeysInSlot(slot int) *IntCmd
ClusterDelSlots(slots ...int) *StatusCmd
ClusterDelSlotsRange(min, max int) *StatusCmd
ClusterSaveConfig() *StatusCmd
ClusterSlaves(nodeID string) *StringSliceCmd
ClusterFailover() *StatusCmd
ClusterAddSlots(slots ...int) *StatusCmd
ClusterAddSlotsRange(min, max int) *StatusCmd
GeoAdd(key string, geoLocation ...*GeoLocation) *IntCmd
GeoPos(key string, members ...string) *GeoPosCmd
GeoRadius(key string, longitude, latitude float64, query *GeoRadiusQuery) *GeoLocationCmd
GeoRadiusRO(key string, longitude, latitude float64, query *GeoRadiusQuery) *GeoLocationCmd
GeoRadiusByMember(key, member string, query *GeoRadiusQuery) *GeoLocationCmd
GeoRadiusByMemberRO(key, member string, query *GeoRadiusQuery) *GeoLocationCmd
GeoDist(key string, member1, member2, unit string) *FloatCmd
GeoHash(key string, members ...string) *StringSliceCmd
Command() *CommandsInfoCmd
}type Cmder interface {
Name() string
Args() []interface{}
Err() error
fmt.Stringer
// contains filtered or unexported methods
}type CommandInfo struct {
Name string
Arity int8
Flags []string
FirstKeyPos int8
LastKeyPos int8
StepCount int8
ReadOnly bool
}type CommandsInfoCmd struct {
// contains filtered or unexported fields
}func NewCommandsInfoCmd(args ...interface{}) *CommandsInfoCmdfunc NewCommandsInfoCmdResult(val map[string]*CommandInfo, err error) *CommandsInfoCmd
NewCommandsInfoCmdResult returns a CommandsInfoCmd initialised with val and err for testing
func (cmd *CommandsInfoCmd) Args() []interface{}func (cmd *CommandsInfoCmd) Result() (map[string]*CommandInfo, error)
func (cmd *CommandsInfoCmd) String() string
func (cmd *CommandsInfoCmd) Val() map[string]*CommandInfo
type Conn struct {
// contains filtered or unexported fields
}Conn is like Client, but its pool contains single connection.
ClientSetName assigns a name to the connection.
Close closes the client, releasing any open resources.
It is rare to Close a Client, as the Client is meant to be long-lived and shared between many goroutines.
TxPipeline acts like Pipeline, but wraps queued commands with MULTI/EXEC.
WrapProcess wraps function that processes Redis commands.
type DurationCmd struct {
// contains filtered or unexported fields
}func NewDurationCmd(precision time.Duration, args ...interface{}) *DurationCmd
func NewDurationResult(val time.Duration, err error) *DurationCmd
NewDurationResult returns a DurationCmd initialised with val and err for testing
func (cmd *DurationCmd) Args() []interface{}func (cmd *DurationCmd) Result() (time.Duration, error)
func (cmd *DurationCmd) String() string
func (cmd *DurationCmd) Val() time.Duration
type FailoverOptions struct {
// The master name.
MasterName string
// A seed list of host:port addresses of sentinel nodes.
SentinelAddrs []string
OnConnect func(*Conn) error
Password string
DB int
MaxRetries int
DialTimeout time.Duration
ReadTimeout time.Duration
WriteTimeout time.Duration
PoolSize int
PoolTimeout time.Duration
IdleTimeout time.Duration
IdleCheckFrequency time.Duration
}FailoverOptions are used to configure a failover client and should be passed to NewFailoverClient.
type FloatCmd struct {
// contains filtered or unexported fields
}NewFloatResult returns a FloatCmd initialised with val and err for testing
func (cmd *FloatCmd) Args() []interface{}GeoLocation is used with GeoAdd to add geospatial location.
type GeoLocationCmd struct {
// contains filtered or unexported fields
}func NewGeoLocationCmd(q *GeoRadiusQuery, args ...interface{}) *GeoLocationCmd
func NewGeoLocationCmdResult(val []GeoLocation, err error) *GeoLocationCmd
NewGeoLocationCmdResult returns a GeoLocationCmd initialised with val and err for testing
func (cmd *GeoLocationCmd) Args() []interface{}func (cmd *GeoLocationCmd) Result() ([]GeoLocation, error)
func (cmd *GeoLocationCmd) String() string
func (cmd *GeoLocationCmd) Val() []GeoLocation
type GeoPosCmd struct {
// contains filtered or unexported fields
}func (cmd *GeoPosCmd) Args() []interface{}type GeoRadiusQuery struct {
Radius float64
// Can be m, km, ft, or mi. Default is km.
Unit string
WithCoord bool
WithDist bool
WithGeoHash bool
Count int
// Can be ASC or DESC. Default is no sort order.
Sort string
Store string
StoreDist string
}GeoRadiusQuery is used with GeoRadius to query geospatial index.
type IntCmd struct {
// contains filtered or unexported fields
}NewIntResult returns an IntCmd initialised with val and err for testing
func (cmd *IntCmd) Args() []interface{}Message received as result of a PUBLISH command issued by another client.
type Options struct {
// The network type, either tcp or unix.
// Default is tcp.
Network string
// host:port address.
Addr string
// Dialer creates new network connection and has priority over
// Network and Addr options.
Dialer func() (net.Conn, error)
// Hook that is called when new connection is established.
OnConnect func(*Conn) error
// Optional password. Must match the password specified in the
// requirepass server configuration option.
Password string
// Database to be selected after connecting to the server.
DB int
// Maximum number of retries before giving up.
// Default is to not retry failed commands.
MaxRetries int
// Minimum backoff between each retry.
// Default is 8 milliseconds; -1 disables backoff.
MinRetryBackoff time.Duration
// Maximum backoff between each retry.
// Default is 512 milliseconds; -1 disables backoff.
MaxRetryBackoff time.Duration
// Dial timeout for establishing new connections.
// Default is 5 seconds.
DialTimeout time.Duration
// Timeout for socket reads. If reached, commands will fail
// with a timeout instead of blocking.
// Default is 3 seconds.
ReadTimeout time.Duration
// Timeout for socket writes. If reached, commands will fail
// with a timeout instead of blocking.
// Default is ReadTimeout.
WriteTimeout time.Duration
// Maximum number of socket connections.
// Default is 10 connections per every CPU as reported by runtime.NumCPU.
PoolSize int
// Amount of time client waits for connection if all connections
// are busy before returning an error.
// Default is ReadTimeout + 1 second.
PoolTimeout time.Duration
// Amount of time after which client closes idle connections.
// Should be less than server's timeout.
// Default is 5 minutes.
IdleTimeout time.Duration
// Frequency of idle checks.
// Default is 1 minute.
// When minus value is set, then idle check is disabled.
IdleCheckFrequency time.Duration
// TLS Config to use. When set TLS will be negotiated.
TLSConfig *tls.Config
// contains filtered or unexported fields
}ParseURL parses an URL into Options that can be used to connect to Redis.
Code:
opt, err := redis.ParseURL("redis://:qwerty@localhost:6379/1")
if err != nil {
panic(err)
}
fmt.Println("addr is", opt.Addr)
fmt.Println("db is", opt.DB)
fmt.Println("password is", opt.Password)
// Create client as usually.
_ = redis.NewClient(opt)
Output:
addr is localhost:6379 db is 1 password is qwerty
type Pipeline struct {
// contains filtered or unexported fields
}Pipeline implements pipelining as described in http://redis.io/topics/pipelining. It's safe for concurrent use by multiple goroutines.
Code:
client := redis.NewClient(&redis.Options{
Addr: ":6379",
})
client.WrapProcessPipeline(func(old func([]redis.Cmder) error) func([]redis.Cmder) error {
return func(cmds []redis.Cmder) error {
fmt.Printf("pipeline starting processing: %v\n", cmds)
err := old(cmds)
fmt.Printf("pipeline finished processing: %v\n", cmds)
return err
}
})
client.Pipelined(func(pipe redis.Pipeliner) error {
pipe.Ping()
pipe.Ping()
return nil
})
Output:
pipeline starting processing: [ping: ping: ] pipeline finished processing: [ping: PONG ping: PONG]
ClientSetName assigns a name to the connection.
Close closes the pipeline, releasing any open resources.
Discard resets the pipeline and discards queued commands.
Exec executes all previously queued commands using one client-server roundtrip.
Exec always returns list of commands and error of the first failed command if any.
type Pipeliner interface {
StatefulCmdable
Process(cmd Cmder) error
Close() error
Discard() error
Exec() ([]Cmder, error)
}Pong received as result of a PING command issued by another client.
type PubSub struct {
// contains filtered or unexported fields
}PubSub implements Pub/Sub commands as described in http://redis.io/topics/pubsub. It's NOT safe for concurrent use by multiple goroutines.
PubSub automatically resubscribes to the channels and patterns when Redis becomes unavailable.
Code:
pubsub := client.Subscribe("mychannel1")
defer pubsub.Close()
// Wait for subscription to be created before publishing message.
subscr, err := pubsub.ReceiveTimeout(time.Second)
if err != nil {
panic(err)
}
fmt.Println(subscr)
err = client.Publish("mychannel1", "hello").Err()
if err != nil {
panic(err)
}
msg, err := pubsub.ReceiveMessage()
if err != nil {
panic(err)
}
fmt.Println(msg.Channel, msg.Payload)
Output:
subscribe: mychannel1 mychannel1 hello
Channel returns a Go channel for concurrently receiving messages. The channel is closed with PubSub. Receive or ReceiveMessage APIs can not be used after channel is created.
PSubscribe the client to the given patterns. It returns empty subscription if there are no patterns.
PUnsubscribe the client from the given patterns, or from all of them if none is given.
Receive returns a message as a Subscription, Message, Pong or error. See PubSub example for details. This is low-level API and most clients should use ReceiveMessage.
Code:
pubsub := client.Subscribe("mychannel2")
defer pubsub.Close()
for i := 0; i < 2; i++ {
// ReceiveTimeout is a low level API. Use ReceiveMessage instead.
msgi, err := pubsub.ReceiveTimeout(time.Second)
if err != nil {
break
}
switch msg := msgi.(type) {
case *redis.Subscription:
fmt.Println("subscribed to", msg.Channel)
_, err := client.Publish("mychannel2", "hello").Result()
if err != nil {
panic(err)
}
case *redis.Message:
fmt.Println("received", msg.Payload, "from", msg.Channel)
default:
panic("unreached")
}
}
// sent message to 1 client
// received hello from mychannel2
ReceiveMessage returns a Message or error ignoring Subscription or Pong messages. It automatically reconnects to Redis Server and resubscribes to channels in case of network errors.
ReceiveTimeout acts like Receive but returns an error if message is not received in time. This is low-level API and most clients should use ReceiveMessage.
Subscribe the client to the specified channels. It returns empty subscription if there are no channels.
Unsubscribe the client from the given channels, or from all of them if none is given.
type Ring struct {
// contains filtered or unexported fields
}Ring is a Redis client that uses constistent hashing to distribute keys across multiple Redis servers (shards). It's safe for 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 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 coordination when shard state is changed.
Ring should be used when you need multiple Redis servers for caching and can tolerate losing data when one of the servers dies. Otherwise you should use Redis Cluster.
func NewRing(opt *RingOptions) *Ring
Code:
client := redis.NewRing(&redis.RingOptions{
Addrs: map[string]string{
"shard1": ":7000",
"shard2": ":7001",
"shard3": ":7002",
},
})
client.Ping()
func (c *Ring) BLPop(timeout time.Duration, keys ...string) *StringSliceCmd
func (c *Ring) BRPop(timeout time.Duration, keys ...string) *StringSliceCmd
ClientGetName returns the name of the connection.
Close closes the ring client, releasing any open resources.
It is rare to Close a Ring, as the Ring is meant to be long-lived and shared between many goroutines.
func (c *Ring) ClusterSlaves(nodeID string) *StringSliceCmd
func (c *Ring) ClusterSlots() *ClusterSlotsCmd
func (c *Ring) Command() *CommandsInfoCmd
Deperecated. Use DBSize instead.
Deprecated. Use FlushDB instead.
ForEachShard concurrently calls the fn on each live shard in the ring. It returns the first error if any.
func (c *Ring) GeoAdd(key string, geoLocation ...*GeoLocation) *IntCmd
func (c *Ring) GeoHash(key string, members ...string) *StringSliceCmd
func (c *Ring) GeoRadius(key string, longitude, latitude float64, query *GeoRadiusQuery) *GeoLocationCmd
func (c *Ring) GeoRadiusByMember(key, member string, query *GeoRadiusQuery) *GeoLocationCmd
func (c *Ring) GeoRadiusByMemberRO(key, member string, query *GeoRadiusQuery) *GeoLocationCmd
func (c *Ring) GeoRadiusRO(key string, longitude, latitude float64, query *GeoRadiusQuery) *GeoLocationCmd
Redis `GET key` command. It returns redis.Nil error when key does not exist.
func (c *Ring) HGetAll(key string) *StringStringMapCmd
func (c *Ring) HKeys(key string) *StringSliceCmd
func (c *Ring) HVals(key string) *StringSliceCmd
func (c *Ring) Keys(pattern string) *StringSliceCmd
func (c *Ring) LRange(key string, start, stop int64) *StringSliceCmd
func (c *Ring) ObjectIdleTime(key string) *DurationCmd
func (c *Ring) Options() *RingOptions
Options returns read-only Options that were used to create the client.
PSubscribe subscribes the client to the given patterns.
func (c *Ring) PTTL(key string) *DurationCmd
PoolStats returns accumulated connection pool stats.
func (c *Ring) PubSubChannels(pattern string) *StringSliceCmd
func (c *Ring) PubSubNumSub(channels ...string) *StringIntMapCmd
Publish posts the message to the channel.
func (c *Ring) SDiff(keys ...string) *StringSliceCmd
func (c *Ring) SInter(keys ...string) *StringSliceCmd
func (c *Ring) SMembers(key string) *StringSliceCmd
Redis `SMEMBERS key` command output as a slice
func (c *Ring) SMembersMap(key string) *StringStructMapCmd
Redis `SMEMBERS key` command output as a map
Redis `SPOP key` command.
func (c *Ring) SPopN(key string, count int64) *StringSliceCmd
Redis `SPOP key count` command.
Redis `SRANDMEMBER key` command.
func (c *Ring) SRandMemberN(key string, count int64) *StringSliceCmd
Redis `SRANDMEMBER key count` command.
func (c *Ring) SUnion(keys ...string) *StringSliceCmd
func (c *Ring) ScriptExists(hashes ...string) *BoolSliceCmd
Redis `SET key value [expiration]` command.
Use expiration for `SETEX`-like behavior. Zero expiration means the key has no expiration time.
Redis `SET key value [expiration] NX` command.
Zero expiration means the key has no expiration time.
Redis `SET key value [expiration] XX` command.
Zero expiration means the key has no expiration time.
func (c *Ring) SlowLog()
func (c *Ring) Sort(key string, sort *Sort) *StringSliceCmd
Subscribe subscribes the client to the specified channels.
func (c *Ring) Sync()
func (c *Ring) TTL(key string) *DurationCmd
Redis `ZADD key score member [score member ...]` command.
Redis `ZADD key CH score member [score member ...]` command.
Redis `ZADD key NX score member [score member ...]` command.
Redis `ZADD key NX CH score member [score member ...]` command.
Redis `ZADD key XX score member [score member ...]` command.
Redis `ZADD key XX CH score member [score member ...]` command.
Redis `ZADD key INCR score member` command.
Redis `ZADD key NX INCR score member` command.
Redis `ZADD key XX INCR score member` command.
func (c *Ring) ZRange(key string, start, stop int64) *StringSliceCmd
func (c *Ring) ZRangeByLex(key string, opt ZRangeBy) *StringSliceCmd
func (c *Ring) ZRangeByScore(key string, opt ZRangeBy) *StringSliceCmd
func (c *Ring) ZRevRange(key string, start, stop int64) *StringSliceCmd
func (c *Ring) ZRevRangeByLex(key string, opt ZRangeBy) *StringSliceCmd
func (c *Ring) ZRevRangeByScore(key string, opt ZRangeBy) *StringSliceCmd
type RingOptions struct {
// Map of name => host:port addresses of ring shards.
Addrs map[string]string
// Frequency of PING commands sent to check shards availability.
// Shard is considered down after 3 subsequent failed checks.
HeartbeatFrequency time.Duration
OnConnect func(*Conn) error
DB int
Password string
MaxRetries int
MinRetryBackoff time.Duration
MaxRetryBackoff time.Duration
DialTimeout time.Duration
ReadTimeout time.Duration
WriteTimeout time.Duration
PoolSize int
PoolTimeout time.Duration
IdleTimeout time.Duration
IdleCheckFrequency time.Duration
}RingOptions are used to configure a ring client and should be passed to NewRing.
type ScanCmd struct {
// contains filtered or unexported fields
}NewScanCmdResult returns a ScanCmd initialised with val and err for testing
func (cmd *ScanCmd) Args() []interface{}func (cmd *ScanCmd) Iterator() *ScanIterator
Iterator creates a new ScanIterator.
Code:
iter := client.Scan(0, "", 0).Iterator()
for iter.Next() {
fmt.Println(iter.Val())
}
if err := iter.Err(); err != nil {
panic(err)
}
type ScanIterator struct {
// contains filtered or unexported fields
}ScanIterator is used to incrementally iterate over a collection of elements. It's safe for concurrent use by multiple goroutines.
Code:
iter := client.Scan(0, "", 0).Iterator()
for iter.Next() {
fmt.Println(iter.Val())
}
if err := iter.Err(); err != nil {
panic(err)
}
func (it *ScanIterator) Err() error
Err returns the last iterator error, if any.
func (it *ScanIterator) Next() bool
Next advances the cursor and returns true if more values can be read.
func (it *ScanIterator) Val() string
Val returns the key/field at the current cursor position.
type Script struct {
// contains filtered or unexported fields
}Code:
IncrByXX := redis.NewScript(`
if redis.call("GET", KEYS[1]) ~= false then
return redis.call("INCRBY", KEYS[1], ARGV[1])
end
return false
`)
n, err := IncrByXX.Run(client, []string{"xx_counter"}, 2).Result()
fmt.Println(n, err)
err = client.Set("xx_counter", "40", 0).Err()
if err != nil {
panic(err)
}
n, err = IncrByXX.Run(client, []string{"xx_counter"}, 2).Result()
fmt.Println(n, err)
Output:
<nil> redis: nil 42 <nil>
func (s *Script) Exists(c scripter) *BoolSliceCmd
Run optimistically uses EVALSHA to run the script. If script does not exist it is retried using EVAL.
type SliceCmd struct {
// contains filtered or unexported fields
}NewSliceResult returns a SliceCmd initialised with val and err for testing
func (cmd *SliceCmd) Args() []interface{}type StatefulCmdable interface {
Cmdable
Auth(password string) *StatusCmd
Select(index int) *StatusCmd
SwapDB(index1, index2 int) *StatusCmd
ClientSetName(name string) *BoolCmd
ReadOnly() *StatusCmd
ReadWrite() *StatusCmd
}type StatusCmd struct {
// contains filtered or unexported fields
}NewStatusResult returns a StatusCmd initialised with val and err for testing
func (cmd *StatusCmd) Args() []interface{}type StringCmd struct {
// contains filtered or unexported fields
}NewStringResult returns a StringCmd initialised with val and err for testing
func (cmd *StringCmd) Args() []interface{}type StringIntMapCmd struct {
// contains filtered or unexported fields
}func NewStringIntMapCmd(args ...interface{}) *StringIntMapCmdfunc NewStringIntMapCmdResult(val map[string]int64, err error) *StringIntMapCmd
NewStringIntMapCmdResult returns a StringIntMapCmd initialised with val and err for testing
func (cmd *StringIntMapCmd) Args() []interface{}func (cmd *StringIntMapCmd) Result() (map[string]int64, error)
func (cmd *StringIntMapCmd) String() string
func (cmd *StringIntMapCmd) Val() map[string]int64
type StringSliceCmd struct {
// contains filtered or unexported fields
}func NewStringSliceCmd(args ...interface{}) *StringSliceCmdfunc NewStringSliceResult(val []string, err error) *StringSliceCmd
NewStringSliceResult returns a StringSliceCmd initialised with val and err for testing
func (cmd *StringSliceCmd) Args() []interface{}func (cmd *StringSliceCmd) Result() ([]string, error)
func (cmd *StringSliceCmd) ScanSlice(container interface{}) error
func (cmd *StringSliceCmd) String() string
func (cmd *StringSliceCmd) Val() []string
type StringStringMapCmd struct {
// contains filtered or unexported fields
}func NewStringStringMapCmd(args ...interface{}) *StringStringMapCmdfunc NewStringStringMapResult(val map[string]string, err error) *StringStringMapCmd
NewStringStringMapResult returns a StringStringMapCmd initialised with val and err for testing
func (cmd *StringStringMapCmd) Args() []interface{}func (cmd *StringStringMapCmd) Result() (map[string]string, error)
func (cmd *StringStringMapCmd) String() string
func (cmd *StringStringMapCmd) Val() map[string]string
type StringStructMapCmd struct {
// contains filtered or unexported fields
}func NewStringStructMapCmd(args ...interface{}) *StringStructMapCmdfunc (cmd *StringStructMapCmd) Args() []interface{}func (cmd *StringStructMapCmd) Result() (map[string]struct{}, error)
func (cmd *StringStructMapCmd) String() string
func (cmd *StringStructMapCmd) Val() map[string]struct{}
type Subscription struct {
// Can be "subscribe", "unsubscribe", "psubscribe" or "punsubscribe".
Kind string
// Channel name we have subscribed to.
Channel string
// Number of channels we are currently subscribed to.
Count int
}Subscription received after a successful subscription to channel.
func (m *Subscription) String() string
type TimeCmd struct {
// contains filtered or unexported fields
}func (cmd *TimeCmd) Args() []interface{}type Tx struct {
// contains filtered or unexported fields
}Tx implements Redis transactions as described in http://redis.io/topics/transactions. It's NOT safe for concurrent use by multiple goroutines, because Exec resets list of watched keys. If you don't need WATCH it is better to use Pipeline.
ClientSetName assigns a name to the connection.
Close closes the transaction, releasing any open resources.
Pipelined executes commands queued in the fn in a transaction and restores the connection state to normal.
When using WATCH, EXEC will execute commands only if the watched keys were not modified, allowing for a check-and-set mechanism.
Exec always returns list of commands. If transaction fails TxFailedErr is returned. Otherwise Exec returns error of the first failed command or nil.
Unwatch flushes all the previously watched keys for a transaction.
Watch marks the keys to be watched for conditional execution of a transaction.
WrapProcess wraps function that processes Redis commands.
type UniversalClient interface {
Cmdable
Process(cmd Cmder) error
WrapProcess(fn func(oldProcess func(cmd Cmder) error) func(cmd Cmder) error)
Subscribe(channels ...string) *PubSub
PSubscribe(channels ...string) *PubSub
Close() error
}UniversalClient is an abstract client which - based on the provided options - can connect to either clusters, or sentinel-backed failover instances or simple single-instance servers. This can be useful for testing cluster-specific applications locally.
func NewUniversalClient(opts *UniversalOptions) UniversalClient
NewUniversalClient returns a new multi client. The type of client returned depends on the following three conditions:
1. if a MasterName is passed a sentinel-backed FailoverClient will be returned 2. if the number of Addrs is two or more, a ClusterClient will be returned 3. otherwise, a single-node redis Client will be returned.
Code:
client := redis.NewUniversalClient(&redis.UniversalOptions{
Addrs: []string{":7000", ":7001", ":7002", ":7003", ":7004", ":7005"},
})
defer client.Close()
client.Ping()
Code:
client := redis.NewUniversalClient(&redis.UniversalOptions{
MasterName: "master",
Addrs: []string{":26379"},
})
defer client.Close()
client.Ping()
Code:
client := redis.NewUniversalClient(&redis.UniversalOptions{
Addrs: []string{":6379"},
})
defer client.Close()
client.Ping()
type UniversalOptions struct {
// Either a single address or a seed list of host:port addresses
// of cluster/sentinel nodes.
Addrs []string
// The sentinel master name.
// Only failover clients.
MasterName string
// Database to be selected after connecting to the server.
// Only single-node and failover clients.
DB int
// Enables read only queries on slave nodes.
ReadOnly bool
MaxRedirects int
RouteByLatency bool
OnConnect func(*Conn) error
MaxRetries int
Password string
DialTimeout time.Duration
ReadTimeout time.Duration
WriteTimeout time.Duration
PoolSize int
PoolTimeout time.Duration
IdleTimeout time.Duration
IdleCheckFrequency time.Duration
}UniversalOptions information is required by UniversalClient to establish connections.
Z represents sorted set member.
type ZSliceCmd struct {
// contains filtered or unexported fields
}NewZSliceCmdResult returns a ZSliceCmd initialised with val and err for testing
func (cmd *ZSliceCmd) Args() []interface{}ZStore is used as an arg to ZInterStore and ZUnionStore.
| Path | Synopsis |
|---|---|
| internal | |
| internal/consistenthash | Package consistenthash provides an implementation of a ring hash. |
| internal/hashtag | |
| internal/pool | |
| internal/proto | |
| internal/singleflight | Package singleflight provides a duplicate function call suppression mechanism. |
| internal/util |
Package redis imports 27 packages (graph) and is imported by 184 packages. Updated 2018-04-17. Refresh now. Tools for package owners.