redis

package module
Version: v7.4.1 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Jul 16, 2021 License: BSD-2-Clause Imports: 25 Imported by: 823

README

Redis client for Golang

Build Status GoDoc Airbrake

Supports:

API docs: https://godoc.org/github.com/go-redis/redis. Examples: https://godoc.org/github.com/go-redis/redis#pkg-examples.

Installation

go-redis requires a Go version with Modules support and uses import versioning. So please make sure to initialize a Go module before installing go-redis:

go mod init github.com/my/repo
go get github.com/go-redis/redis/v7

Import:

import "github.com/go-redis/redis/v7"

Quickstart

func ExampleNewClient() {
	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 ExampleClient() {
	client := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "", // no password set
		DB:       0,  // use default DB
	})
	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
}

Howto

Please go through examples to get an idea how to use this package.

Look and feel

Some corner cases:

// SET key value EX 10 NX
set, err := client.SetNX("key", "value", 10*time.Second).Result()

// SORT list LIMIT 0 2 ASC
vals, err := client.Sort("list", &redis.Sort{Offset: 0, Count: 2, Order: "ASC"}).Result()

// ZRANGEBYSCORE zset -inf +inf WITHSCORES LIMIT 0 2
vals, err := client.ZRangeByScoreWithScores("zset", &redis.ZRangeBy{
	Min: "-inf",
	Max: "+inf",
	Offset: 0,
	Count: 2,
}).Result()

// ZINTERSTORE out 2 zset1 zset2 WEIGHTS 2 3 AGGREGATE SUM
vals, err := client.ZInterStore("out", &redis.ZStore{
	Keys: []string{"zset1", "zset2"},
	Weights: []int64{2, 3}
}).Result()

// EVAL "return {KEYS[1],ARGV[1]}" 1 "key" "hello"
vals, err := client.Eval("return {KEYS[1],ARGV[1]}", []string{"key"}, "hello").Result()

// custom command
res, err := client.Do("set", "key", "value").Result()

See also

Documentation

Overview

Package redis implements a Redis client.

Example (CustomCommand)
Get := func(rdb *redis.Client, key string) *redis.StringCmd {
	cmd := redis.NewStringCmd("get", key)
	rdb.Process(cmd)
	return cmd
}

v, err := Get(rdb, "key_does_not_exist").Result()
fmt.Printf("%q %s", v, err)
Output:

"" redis: nil
Example (CustomCommand2)
v, err := rdb.Do("get", "key_does_not_exist").Text()
fmt.Printf("%q %s", v, err)
Output:

"" redis: nil
Example (Instrumentation)
rdb := redis.NewClient(&redis.Options{
	Addr: ":6379",
})
rdb.AddHook(redisHook{})

rdb.Ping()
Output:

starting processing: <ping: >
finished processing: <ping: PONG>

Index

Examples

Constants

View Source
const Nil = proto.Nil

Nil reply returned by Redis when key does not exist.

View Source
const TxFailedErr = proto.RedisError("redis: transaction failed")

TxFailedErr transaction redis failed.

Variables

View Source
var ErrClosed = pool.ErrClosed

Functions

func SetLogger

func SetLogger(logger *log.Logger)

Types

type BitCount

type BitCount struct {
	Start, End int64
}

type BoolCmd

type BoolCmd struct {
	// contains filtered or unexported fields
}

func NewBoolCmd

func NewBoolCmd(args ...interface{}) *BoolCmd

func NewBoolResult

func NewBoolResult(val bool, err error) *BoolCmd

NewBoolResult returns a BoolCmd initialised with val and err for testing

func (*BoolCmd) Args

func (cmd *BoolCmd) Args() []interface{}

func (*BoolCmd) Err

func (cmd *BoolCmd) Err() error

func (*BoolCmd) Name

func (cmd *BoolCmd) Name() string

func (*BoolCmd) Result

func (cmd *BoolCmd) Result() (bool, error)

func (*BoolCmd) SetErr

func (cmd *BoolCmd) SetErr(e error)

func (*BoolCmd) String

func (cmd *BoolCmd) String() string

func (*BoolCmd) Val

func (cmd *BoolCmd) Val() bool

type BoolSliceCmd

type BoolSliceCmd struct {
	// contains filtered or unexported fields
}

func NewBoolSliceCmd

func NewBoolSliceCmd(args ...interface{}) *BoolSliceCmd

func NewBoolSliceResult

func NewBoolSliceResult(val []bool, err error) *BoolSliceCmd

NewBoolSliceResult returns a BoolSliceCmd initialised with val and err for testing

func (*BoolSliceCmd) Args

func (cmd *BoolSliceCmd) Args() []interface{}

func (*BoolSliceCmd) Err

func (cmd *BoolSliceCmd) Err() error

func (*BoolSliceCmd) Name

func (cmd *BoolSliceCmd) Name() string

func (*BoolSliceCmd) Result

func (cmd *BoolSliceCmd) Result() ([]bool, error)

func (*BoolSliceCmd) SetErr

func (cmd *BoolSliceCmd) SetErr(e error)

func (*BoolSliceCmd) String

func (cmd *BoolSliceCmd) String() string

func (*BoolSliceCmd) Val

func (cmd *BoolSliceCmd) Val() []bool

type Client

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.

Example
err := rdb.Set("key", "value", 0).Err()
if err != nil {
	panic(err)
}

val, err := rdb.Get("key").Result()
if err != nil {
	panic(err)
}
fmt.Println("key", val)

val2, err := rdb.Get("missing_key").Result()
if err == redis.Nil {
	fmt.Println("missing_key does not exist")
} else if err != nil {
	panic(err)
} else {
	fmt.Println("missing_key", val2)
}
Output:

key value
missing_key does not exist

func NewClient

func NewClient(opt *Options) *Client

NewClient returns a client to the Redis Server specified by Options.

Example
rdb := redis.NewClient(&redis.Options{
	Addr:     "localhost:6379", // use default Addr
	Password: "",               // no password set
	DB:       0,                // use default DB
})

pong, err := rdb.Ping().Result()
fmt.Println(pong, err)
Output:

PONG <nil>

func NewFailoverClient

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.

Example
// See http://redis.io/topics/sentinel for instructions how to
// setup Redis Sentinel.
rdb := redis.NewFailoverClient(&redis.FailoverOptions{
	MasterName:    "master",
	SentinelAddrs: []string{":26379"},
})
rdb.Ping()
Output:

func (*Client) AddHook

func (hs *Client) AddHook(hook Hook)

func (Client) Append

func (c Client) Append(key, value string) *IntCmd

func (Client) BLPop

func (c Client) BLPop(timeout time.Duration, keys ...string) *StringSliceCmd
Example
if err := rdb.RPush("queue", "message").Err(); err != nil {
	panic(err)
}

// use `rdb.BLPop(0, "queue")` for infinite waiting time
result, err := rdb.BLPop(1*time.Second, "queue").Result()
if err != nil {
	panic(err)
}

fmt.Println(result[0], result[1])
Output:

queue message

func (Client) BRPop

func (c Client) BRPop(timeout time.Duration, keys ...string) *StringSliceCmd

func (Client) BRPopLPush

func (c Client) BRPopLPush(source, destination string, timeout time.Duration) *StringCmd

func (Client) BZPopMax

func (c Client) BZPopMax(timeout time.Duration, keys ...string) *ZWithKeyCmd

Redis `BZPOPMAX key [key ...] timeout` command.

func (Client) BZPopMin

func (c Client) BZPopMin(timeout time.Duration, keys ...string) *ZWithKeyCmd

Redis `BZPOPMIN key [key ...] timeout` command.

func (Client) BgRewriteAOF

func (c Client) BgRewriteAOF() *StatusCmd

func (Client) BgSave

func (c Client) BgSave() *StatusCmd

func (Client) BitCount

func (c Client) BitCount(key string, bitCount *BitCount) *IntCmd

func (Client) BitField

func (c Client) BitField(key string, args ...interface{}) *IntSliceCmd

func (Client) BitOpAnd

func (c Client) BitOpAnd(destKey string, keys ...string) *IntCmd

func (Client) BitOpNot

func (c Client) BitOpNot(destKey string, key string) *IntCmd

func (Client) BitOpOr

func (c Client) BitOpOr(destKey string, keys ...string) *IntCmd

func (Client) BitOpXor

func (c Client) BitOpXor(destKey string, keys ...string) *IntCmd

func (Client) BitPos

func (c Client) BitPos(key string, bit int64, pos ...int64) *IntCmd

func (Client) ClientGetName

func (c Client) ClientGetName() *StringCmd

ClientGetName returns the name of the connection.

func (Client) ClientID

func (c Client) ClientID() *IntCmd

func (Client) ClientKill

func (c Client) ClientKill(ipPort string) *StatusCmd

func (Client) ClientKillByFilter

func (c Client) ClientKillByFilter(keys ...string) *IntCmd

ClientKillByFilter is new style synx, while the ClientKill is old CLIENT KILL <option> [value] ... <option> [value]

func (Client) ClientList

func (c Client) ClientList() *StringCmd

func (Client) ClientPause

func (c Client) ClientPause(dur time.Duration) *BoolCmd

func (Client) ClientUnblock

func (c Client) ClientUnblock(id int64) *IntCmd

func (Client) ClientUnblockWithError

func (c Client) ClientUnblockWithError(id int64) *IntCmd

func (Client) Close

func (c Client) Close() error

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 (Client) ClusterAddSlots

func (c Client) ClusterAddSlots(slots ...int) *StatusCmd

func (Client) ClusterAddSlotsRange

func (c Client) ClusterAddSlotsRange(min, max int) *StatusCmd

func (Client) ClusterCountFailureReports

func (c Client) ClusterCountFailureReports(nodeID string) *IntCmd

func (Client) ClusterCountKeysInSlot

func (c Client) ClusterCountKeysInSlot(slot int) *IntCmd

func (Client) ClusterDelSlots

func (c Client) ClusterDelSlots(slots ...int) *StatusCmd

func (Client) ClusterDelSlotsRange

func (c Client) ClusterDelSlotsRange(min, max int) *StatusCmd

func (Client) ClusterFailover

func (c Client) ClusterFailover() *StatusCmd

func (Client) ClusterForget

func (c Client) ClusterForget(nodeID string) *StatusCmd

func (Client) ClusterGetKeysInSlot

func (c Client) ClusterGetKeysInSlot(slot int, count int) *StringSliceCmd

func (Client) ClusterInfo

func (c Client) ClusterInfo() *StringCmd

func (Client) ClusterKeySlot

func (c Client) ClusterKeySlot(key string) *IntCmd

func (Client) ClusterMeet

func (c Client) ClusterMeet(host, port string) *StatusCmd

func (Client) ClusterNodes

func (c Client) ClusterNodes() *StringCmd

func (Client) ClusterReplicate

func (c Client) ClusterReplicate(nodeID string) *StatusCmd

func (Client) ClusterResetHard

func (c Client) ClusterResetHard() *StatusCmd

func (Client) ClusterResetSoft

func (c Client) ClusterResetSoft() *StatusCmd

func (Client) ClusterSaveConfig

func (c Client) ClusterSaveConfig() *StatusCmd

func (Client) ClusterSlaves

func (c Client) ClusterSlaves(nodeID string) *StringSliceCmd

func (Client) ClusterSlots

func (c Client) ClusterSlots() *ClusterSlotsCmd

func (Client) Command

func (c Client) Command() *CommandsInfoCmd

func (Client) ConfigGet

func (c Client) ConfigGet(parameter string) *SliceCmd

func (Client) ConfigResetStat

func (c Client) ConfigResetStat() *StatusCmd

func (Client) ConfigRewrite

func (c Client) ConfigRewrite() *StatusCmd

func (Client) ConfigSet

func (c Client) ConfigSet(parameter, value string) *StatusCmd

func (*Client) Conn

func (c *Client) Conn() *Conn

func (*Client) Context

func (c *Client) Context() context.Context

func (Client) DBSize

func (c Client) DBSize() *IntCmd

func (Client) DbSize

func (c Client) DbSize() *IntCmd

Deperecated. Use DBSize instead.

func (Client) DebugObject

func (c Client) DebugObject(key string) *StringCmd

func (Client) Decr

func (c Client) Decr(key string) *IntCmd

func (Client) DecrBy

func (c Client) DecrBy(key string, decrement int64) *IntCmd

func (Client) Del

func (c Client) Del(keys ...string) *IntCmd

func (*Client) Do

func (c *Client) Do(args ...interface{}) *Cmd

Do creates a Cmd from the args and processes the cmd.

func (*Client) DoContext

func (c *Client) DoContext(ctx context.Context, args ...interface{}) *Cmd

func (Client) Dump

func (c Client) Dump(key string) *StringCmd

func (Client) Echo

func (c Client) Echo(message interface{}) *StringCmd

func (Client) Eval

func (c Client) Eval(script string, keys []string, args ...interface{}) *Cmd

func (Client) EvalSha

func (c Client) EvalSha(sha1 string, keys []string, args ...interface{}) *Cmd

func (Client) Exists

func (c Client) Exists(keys ...string) *IntCmd

func (Client) Expire

func (c Client) Expire(key string, expiration time.Duration) *BoolCmd

func (Client) ExpireAt

func (c Client) ExpireAt(key string, tm time.Time) *BoolCmd

func (Client) FlushAll

func (c Client) FlushAll() *StatusCmd

func (Client) FlushAllAsync

func (c Client) FlushAllAsync() *StatusCmd

func (Client) FlushDB

func (c Client) FlushDB() *StatusCmd

func (Client) FlushDBAsync

func (c Client) FlushDBAsync() *StatusCmd

func (Client) GeoAdd

func (c Client) GeoAdd(key string, geoLocation ...*GeoLocation) *IntCmd

func (Client) GeoDist

func (c Client) GeoDist(key string, member1, member2, unit string) *FloatCmd

func (Client) GeoHash

func (c Client) GeoHash(key string, members ...string) *StringSliceCmd

func (Client) GeoPos

func (c Client) GeoPos(key string, members ...string) *GeoPosCmd

func (Client) GeoRadius

func (c Client) GeoRadius(key string, longitude, latitude float64, query *GeoRadiusQuery) *GeoLocationCmd

GeoRadius is a read-only GEORADIUS_RO command.

func (Client) GeoRadiusByMember

func (c Client) GeoRadiusByMember(key, member string, query *GeoRadiusQuery) *GeoLocationCmd

GeoRadius is a read-only GEORADIUSBYMEMBER_RO command.

func (Client) GeoRadiusByMemberStore

func (c Client) GeoRadiusByMemberStore(key, member string, query *GeoRadiusQuery) *IntCmd

GeoRadiusByMemberStore is a writing GEORADIUSBYMEMBER command.

func (Client) GeoRadiusStore

func (c Client) GeoRadiusStore(key string, longitude, latitude float64, query *GeoRadiusQuery) *IntCmd

GeoRadiusStore is a writing GEORADIUS command.

func (Client) Get

func (c Client) Get(key string) *StringCmd

Redis `GET key` command. It returns redis.Nil error when key does not exist.

func (Client) GetBit

func (c Client) GetBit(key string, offset int64) *IntCmd

func (Client) GetRange

func (c Client) GetRange(key string, start, end int64) *StringCmd

func (Client) GetSet

func (c Client) GetSet(key string, value interface{}) *StringCmd

func (Client) HDel

func (c Client) HDel(key string, fields ...string) *IntCmd

func (Client) HExists

func (c Client) HExists(key, field string) *BoolCmd

func (Client) HGet

func (c Client) HGet(key, field string) *StringCmd

func (Client) HGetAll

func (c Client) HGetAll(key string) *StringStringMapCmd

func (Client) HIncrBy

func (c Client) HIncrBy(key, field string, incr int64) *IntCmd

func (Client) HIncrByFloat

func (c Client) HIncrByFloat(key, field string, incr float64) *FloatCmd

func (Client) HKeys

func (c Client) HKeys(key string) *StringSliceCmd

func (Client) HLen

func (c Client) HLen(key string) *IntCmd

func (Client) HMGet

func (c Client) HMGet(key string, fields ...string) *SliceCmd

HMGet returns the values for the specified fields in the hash stored at key. It returns an interface{} to distinguish between empty string and nil value.

func (Client) HMSet

func (c Client) HMSet(key string, values ...interface{}) *BoolCmd

HMSet is a deprecated version of HSet left for compatibility with Redis 3.

func (Client) HScan

func (c Client) HScan(key string, cursor uint64, match string, count int64) *ScanCmd

func (Client) HSet

func (c Client) HSet(key string, values ...interface{}) *IntCmd

HSet accepts values in following formats:

- HMSet("myhash", "key1", "value1", "key2", "value2")
- HMSet("myhash", []string{"key1", "value1", "key2", "value2"})
- HMSet("myhash", map[string]interface{}{"key1": "value1", "key2": "value2"})

Note that it requires Redis v4 for multiple field/value pairs support.

func (Client) HSetNX

func (c Client) HSetNX(key, field string, value interface{}) *BoolCmd

func (Client) HVals

func (c Client) HVals(key string) *StringSliceCmd

func (Client) Incr

func (c Client) Incr(key string) *IntCmd
Example
result, err := rdb.Incr("counter").Result()
if err != nil {
	panic(err)
}

fmt.Println(result)
Output:

1

func (Client) IncrBy

func (c Client) IncrBy(key string, value int64) *IntCmd

func (Client) IncrByFloat

func (c Client) IncrByFloat(key string, value float64) *FloatCmd

func (Client) Info

func (c Client) Info(section ...string) *StringCmd

func (Client) Keys

func (c Client) Keys(pattern string) *StringSliceCmd

func (Client) LIndex

func (c Client) LIndex(key string, index int64) *StringCmd

func (Client) LInsert

func (c Client) LInsert(key, op string, pivot, value interface{}) *IntCmd

func (Client) LInsertAfter

func (c Client) LInsertAfter(key string, pivot, value interface{}) *IntCmd

func (Client) LInsertBefore

func (c Client) LInsertBefore(key string, pivot, value interface{}) *IntCmd

func (Client) LLen

func (c Client) LLen(key string) *IntCmd

func (Client) LPop

func (c Client) LPop(key string) *StringCmd

func (Client) LPush

func (c Client) LPush(key string, values ...interface{}) *IntCmd

func (Client) LPushX

func (c Client) LPushX(key string, values ...interface{}) *IntCmd

func (Client) LRange

func (c Client) LRange(key string, start, stop int64) *StringSliceCmd

func (Client) LRem

func (c Client) LRem(key string, count int64, value interface{}) *IntCmd

func (Client) LSet

func (c Client) LSet(key string, index int64, value interface{}) *StatusCmd

func (Client) LTrim

func (c Client) LTrim(key string, start, stop int64) *StatusCmd

func (Client) LastSave

func (c Client) LastSave() *IntCmd

func (Client) MGet

func (c Client) MGet(keys ...string) *SliceCmd

func (Client) MSet

func (c Client) MSet(values ...interface{}) *StatusCmd

MSet is like Set but accepts multiple values:

- MSet("key1", "value1", "key2", "value2")
- MSet([]string{"key1", "value1", "key2", "value2"})
- MSet(map[string]interface{}{"key1": "value1", "key2": "value2"})

func (Client) MSetNX

func (c Client) MSetNX(values ...interface{}) *BoolCmd

MSetNX is like SetNX but accepts multiple values:

- MSetNX("key1", "value1", "key2", "value2")
- MSetNX([]string{"key1", "value1", "key2", "value2"})
- MSetNX(map[string]interface{}{"key1": "value1", "key2": "value2"})

func (Client) MemoryUsage

func (c Client) MemoryUsage(key string, samples ...int) *IntCmd

func (Client) Migrate

func (c Client) Migrate(host, port, key string, db int, timeout time.Duration) *StatusCmd

func (Client) Move

func (c Client) Move(key string, db int) *BoolCmd

func (Client) ObjectEncoding

func (c Client) ObjectEncoding(key string) *StringCmd

func (Client) ObjectIdleTime

func (c Client) ObjectIdleTime(key string) *DurationCmd

func (Client) ObjectRefCount

func (c Client) ObjectRefCount(key string) *IntCmd

func (*Client) Options

func (c *Client) Options() *Options

Options returns read-only Options that were used to create the client.

func (Client) PExpire

func (c Client) PExpire(key string, expiration time.Duration) *BoolCmd

func (Client) PExpireAt

func (c Client) PExpireAt(key string, tm time.Time) *BoolCmd

func (Client) PFAdd

func (c Client) PFAdd(key string, els ...interface{}) *IntCmd

func (Client) PFCount

func (c Client) PFCount(keys ...string) *IntCmd

func (Client) PFMerge

func (c Client) PFMerge(dest string, keys ...string) *StatusCmd

func (*Client) PSubscribe

func (c *Client) PSubscribe(channels ...string) *PubSub

PSubscribe subscribes the client to the given patterns. Patterns can be omitted to create empty subscription.

func (Client) PTTL

func (c Client) PTTL(key string) *DurationCmd

func (Client) Persist

func (c Client) Persist(key string) *BoolCmd

func (Client) Ping

func (c Client) Ping() *StatusCmd

func (*Client) Pipeline

func (c *Client) Pipeline() Pipeliner
Example
pipe := rdb.Pipeline()

incr := pipe.Incr("pipeline_counter")
pipe.Expire("pipeline_counter", time.Hour)

// Execute
//
//     INCR pipeline_counter
//     EXPIRE pipeline_counts 3600
//
// using one rdb-server roundtrip.
_, err := pipe.Exec()
fmt.Println(incr.Val(), err)
Output:

1 <nil>

func (*Client) Pipelined

func (c *Client) Pipelined(fn func(Pipeliner) error) ([]Cmder, error)
Example
var incr *redis.IntCmd
_, err := rdb.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>

func (*Client) PoolStats

func (c *Client) PoolStats() *PoolStats

PoolStats returns connection pool stats.

func (*Client) Process

func (c *Client) Process(cmd Cmder) error

func (*Client) ProcessContext

func (c *Client) ProcessContext(ctx context.Context, cmd Cmder) error

func (Client) PubSubChannels

func (c Client) PubSubChannels(pattern string) *StringSliceCmd

func (Client) PubSubNumPat

func (c Client) PubSubNumPat() *IntCmd

func (Client) PubSubNumSub

func (c Client) PubSubNumSub(channels ...string) *StringIntMapCmd

func (Client) Publish

func (c Client) Publish(channel string, message interface{}) *IntCmd

Publish posts the message to the channel.

func (Client) Quit

func (c Client) Quit() *StatusCmd

func (Client) RPop

func (c Client) RPop(key string) *StringCmd

func (Client) RPopLPush

func (c Client) RPopLPush(source, destination string) *StringCmd

func (Client) RPush

func (c Client) RPush(key string, values ...interface{}) *IntCmd

func (Client) RPushX

func (c Client) RPushX(key string, values ...interface{}) *IntCmd

func (Client) RandomKey

func (c Client) RandomKey() *StringCmd

func (Client) ReadOnly

func (c Client) ReadOnly() *StatusCmd

func (Client) ReadWrite

func (c Client) ReadWrite() *StatusCmd

func (Client) Rename

func (c Client) Rename(key, newkey string) *StatusCmd

func (Client) RenameNX

func (c Client) RenameNX(key, newkey string) *BoolCmd

func (Client) Restore

func (c Client) Restore(key string, ttl time.Duration, value string) *StatusCmd

func (Client) RestoreReplace

func (c Client) RestoreReplace(key string, ttl time.Duration, value string) *StatusCmd

func (Client) SAdd

func (c Client) SAdd(key string, members ...interface{}) *IntCmd

func (Client) SCard

func (c Client) SCard(key string) *IntCmd

func (Client) SDiff

func (c Client) SDiff(keys ...string) *StringSliceCmd

func (Client) SDiffStore

func (c Client) SDiffStore(destination string, keys ...string) *IntCmd

func (Client) SInter

func (c Client) SInter(keys ...string) *StringSliceCmd

func (Client) SInterStore

func (c Client) SInterStore(destination string, keys ...string) *IntCmd

func (Client) SIsMember

func (c Client) SIsMember(key string, member interface{}) *BoolCmd

func (Client) SMembers

func (c Client) SMembers(key string) *StringSliceCmd

Redis `SMEMBERS key` command output as a slice

func (Client) SMembersMap

func (c Client) SMembersMap(key string) *StringStructMapCmd

Redis `SMEMBERS key` command output as a map

func (Client) SMove

func (c Client) SMove(source, destination string, member interface{}) *BoolCmd

func (Client) SPop

func (c Client) SPop(key string) *StringCmd

Redis `SPOP key` command.

func (Client) SPopN

func (c Client) SPopN(key string, count int64) *StringSliceCmd

Redis `SPOP key count` command.

func (Client) SRandMember

func (c Client) SRandMember(key string) *StringCmd

Redis `SRANDMEMBER key` command.

func (Client) SRandMemberN

func (c Client) SRandMemberN(key string, count int64) *StringSliceCmd

Redis `SRANDMEMBER key count` command.

func (Client) SRem

func (c Client) SRem(key string, members ...interface{}) *IntCmd

func (Client) SScan

func (c Client) SScan(key string, cursor uint64, match string, count int64) *ScanCmd

func (Client) SUnion

func (c Client) SUnion(keys ...string) *StringSliceCmd

func (Client) SUnionStore

func (c Client) SUnionStore(destination string, keys ...string) *IntCmd

func (Client) Save

func (c Client) Save() *StatusCmd

func (Client) Scan

func (c Client) Scan(cursor uint64, match string, count int64) *ScanCmd
Example
rdb.FlushDB()
for i := 0; i < 33; i++ {
	err := rdb.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 = rdb.Scan(cursor, "key*", 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 (Client) ScriptExists

func (c Client) ScriptExists(hashes ...string) *BoolSliceCmd

func (Client) ScriptFlush

func (c Client) ScriptFlush() *StatusCmd

func (Client) ScriptKill

func (c Client) ScriptKill() *StatusCmd

func (Client) ScriptLoad

func (c Client) ScriptLoad(script string) *StringCmd

func (Client) Set

func (c Client) Set(key string, value interface{}, expiration time.Duration) *StatusCmd

Redis `SET key value [expiration]` command.

Use expiration for `SETEX`-like behavior. Zero expiration means the key has no expiration time.

Example
// Last argument is expiration. Zero means the key has no
// expiration time.
err := rdb.Set("key", "value", 0).Err()
if err != nil {
	panic(err)
}

// key2 will expire in an hour.
err = rdb.Set("key2", "value", time.Hour).Err()
if err != nil {
	panic(err)
}
Output:

func (Client) SetBit

func (c Client) SetBit(key string, offset int64, value int) *IntCmd

func (Client) SetNX

func (c Client) SetNX(key string, value interface{}, expiration time.Duration) *BoolCmd

Redis `SET key value [expiration] NX` command.

Zero expiration means the key has no expiration time.

func (Client) SetRange

func (c Client) SetRange(key string, offset int64, value string) *IntCmd

func (Client) SetXX

func (c Client) SetXX(key string, value interface{}, expiration time.Duration) *BoolCmd

Redis `SET key value [expiration] XX` command.

Zero expiration means the key has no expiration time.

func (Client) Shutdown

func (c Client) Shutdown() *StatusCmd

func (Client) ShutdownNoSave

func (c Client) ShutdownNoSave() *StatusCmd

func (Client) ShutdownSave

func (c Client) ShutdownSave() *StatusCmd

func (Client) SlaveOf

func (c Client) SlaveOf(host, port string) *StatusCmd

func (Client) SlowLog

func (c Client) SlowLog()

func (Client) Sort

func (c Client) Sort(key string, sort *Sort) *StringSliceCmd

func (Client) SortInterfaces

func (c Client) SortInterfaces(key string, sort *Sort) *SliceCmd

func (Client) SortStore

func (c Client) SortStore(key, store string, sort *Sort) *IntCmd

func (Client) StrLen

func (c Client) StrLen(key string) *IntCmd

func (Client) String

func (c Client) String() string

func (*Client) Subscribe

func (c *Client) Subscribe(channels ...string) *PubSub

Subscribe subscribes the client to the specified channels. Channels can be omitted to create empty subscription. Note that this method does not wait on a response from Redis, so the subscription may not be active immediately. To force the connection to wait, you may call the Receive() method on the returned *PubSub like so:

sub := client.Subscribe(queryResp)
iface, err := sub.Receive()
if err != nil {
    // handle error
}

// Should be *Subscription, but others are possible if other actions have been
// taken on sub since it was created.
switch iface.(type) {
case *Subscription:
    // subscribe succeeded
case *Message:
    // received first message
case *Pong:
    // pong received
default:
    // handle error
}

ch := sub.Channel()

func (Client) Sync

func (c Client) Sync()

func (Client) TTL

func (c Client) TTL(key string) *DurationCmd

func (Client) Time

func (c Client) Time() *TimeCmd

func (Client) Touch

func (c Client) Touch(keys ...string) *IntCmd

func (*Client) TxPipeline

func (c *Client) TxPipeline() Pipeliner

TxPipeline acts like Pipeline, but wraps queued commands with MULTI/EXEC.

Example
pipe := rdb.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 rdb-server roundtrip.
_, err := pipe.Exec()
fmt.Println(incr.Val(), err)
Output:

1 <nil>

func (*Client) TxPipelined

func (c *Client) TxPipelined(fn func(Pipeliner) error) ([]Cmder, error)
Example
var incr *redis.IntCmd
_, err := rdb.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>

func (Client) Type

func (c Client) Type(key string) *StatusCmd
func (c Client) Unlink(keys ...string) *IntCmd

func (Client) Wait

func (c Client) Wait(numSlaves int, timeout time.Duration) *IntCmd

func (*Client) Watch

func (c *Client) Watch(fn func(*Tx) error, keys ...string) error

Watch prepares a transaction and marks the keys to be watched for conditional execution if there are any keys.

The transaction is automatically closed when fn exits.

Example
const routineCount = 100

// Transactionally increments key using GET and SET commands.
increment := func(key string) error {
	txf := func(tx *redis.Tx) error {
		// get current value or zero
		n, err := tx.Get(key).Int()
		if err != nil && err != redis.Nil {
			return err
		}

		// actual opperation (local in optimistic lock)
		n++

		// runs only if the watched keys remain unchanged
		_, err = tx.TxPipelined(func(pipe redis.Pipeliner) error {
			// pipe handles the error case
			pipe.Set(key, n, 0)
			return nil
		})
		return err
	}

	for retries := routineCount; retries > 0; retries-- {
		err := rdb.Watch(txf, key)
		if err != redis.TxFailedErr {
			return err
		}
		// optimistic lock lost
	}
	return errors.New("increment reached maximum number of retries")
}

var wg sync.WaitGroup
wg.Add(routineCount)
for i := 0; i < routineCount; i++ {
	go func() {
		defer wg.Done()

		if err := increment("counter3"); err != nil {
			fmt.Println("increment error:", err)
		}
	}()
}
wg.Wait()

n, err := rdb.Get("counter3").Int()
fmt.Println("ended with", n, err)
Output:

ended with 100 <nil>

func (*Client) WatchContext

func (c *Client) WatchContext(ctx context.Context, fn func(*Tx) error, keys ...string) error

func (*Client) WithContext

func (c *Client) WithContext(ctx context.Context) *Client

func (*Client) WithTimeout

func (c *Client) WithTimeout(timeout time.Duration) *Client

func (Client) XAck

func (c Client) XAck(stream, group string, ids ...string) *IntCmd

func (Client) XAdd

func (c Client) XAdd(a *XAddArgs) *StringCmd

func (Client) XClaim

func (c Client) XClaim(a *XClaimArgs) *XMessageSliceCmd

func (Client) XClaimJustID

func (c Client) XClaimJustID(a *XClaimArgs) *StringSliceCmd

func (Client) XDel

func (c Client) XDel(stream string, ids ...string) *IntCmd

func (Client) XGroupCreate

func (c Client) XGroupCreate(stream, group, start string) *StatusCmd

func (Client) XGroupCreateMkStream

func (c Client) XGroupCreateMkStream(stream, group, start string) *StatusCmd

func (Client) XGroupDelConsumer

func (c Client) XGroupDelConsumer(stream, group, consumer string) *IntCmd

func (Client) XGroupDestroy

func (c Client) XGroupDestroy(stream, group string) *IntCmd

func (Client) XGroupSetID

func (c Client) XGroupSetID(stream, group, start string) *StatusCmd

func (Client) XInfoGroups

func (c Client) XInfoGroups(key string) *XInfoGroupsCmd

func (Client) XLen

func (c Client) XLen(stream string) *IntCmd

func (Client) XPending

func (c Client) XPending(stream, group string) *XPendingCmd

func (Client) XPendingExt

func (c Client) XPendingExt(a *XPendingExtArgs) *XPendingExtCmd

func (Client) XRange

func (c Client) XRange(stream, start, stop string) *XMessageSliceCmd

func (Client) XRangeN

func (c Client) XRangeN(stream, start, stop string, count int64) *XMessageSliceCmd

func (Client) XRead

func (c Client) XRead(a *XReadArgs) *XStreamSliceCmd

func (Client) XReadGroup

func (c Client) XReadGroup(a *XReadGroupArgs) *XStreamSliceCmd

func (Client) XReadStreams

func (c Client) XReadStreams(streams ...string) *XStreamSliceCmd

func (Client) XRevRange

func (c Client) XRevRange(stream, start, stop string) *XMessageSliceCmd

func (Client) XRevRangeN

func (c Client) XRevRangeN(stream, start, stop string, count int64) *XMessageSliceCmd

func (Client) XTrim

func (c Client) XTrim(key string, maxLen int64) *IntCmd

func (Client) XTrimApprox

func (c Client) XTrimApprox(key string, maxLen int64) *IntCmd

func (Client) ZAdd

func (c Client) ZAdd(key string, members ...*Z) *IntCmd

Redis `ZADD key score member [score member ...]` command.

func (Client) ZAddCh

func (c Client) ZAddCh(key string, members ...*Z) *IntCmd

Redis `ZADD key CH score member [score member ...]` command.

func (Client) ZAddNX

func (c Client) ZAddNX(key string, members ...*Z) *IntCmd

Redis `ZADD key NX score member [score member ...]` command.

func (Client) ZAddNXCh

func (c Client) ZAddNXCh(key string, members ...*Z) *IntCmd

Redis `ZADD key NX CH score member [score member ...]` command.

func (Client) ZAddXX

func (c Client) ZAddXX(key string, members ...*Z) *IntCmd

Redis `ZADD key XX score member [score member ...]` command.

func (Client) ZAddXXCh

func (c Client) ZAddXXCh(key string, members ...*Z) *IntCmd

Redis `ZADD key XX CH score member [score member ...]` command.

func (Client) ZCard

func (c Client) ZCard(key string) *IntCmd

func (Client) ZCount

func (c Client) ZCount(key, min, max string) *IntCmd

func (Client) ZIncr

func (c Client) ZIncr(key string, member *Z) *FloatCmd

Redis `ZADD key INCR score member` command.

func (Client) ZIncrBy

func (c Client) ZIncrBy(key string, increment float64, member string) *FloatCmd

func (Client) ZIncrNX

func (c Client) ZIncrNX(key string, member *Z) *FloatCmd

Redis `ZADD key NX INCR score member` command.

func (Client) ZIncrXX

func (c Client) ZIncrXX(key string, member *Z) *FloatCmd

Redis `ZADD key XX INCR score member` command.

func (Client) ZInterStore

func (c Client) ZInterStore(destination string, store *ZStore) *IntCmd

func (Client) ZLexCount

func (c Client) ZLexCount(key, min, max string) *IntCmd

func (Client) ZPopMax

func (c Client) ZPopMax(key string, count ...int64) *ZSliceCmd

func (Client) ZPopMin

func (c Client) ZPopMin(key string, count ...int64) *ZSliceCmd

func (Client) ZRange

func (c Client) ZRange(key string, start, stop int64) *StringSliceCmd

func (Client) ZRangeByLex

func (c Client) ZRangeByLex(key string, opt *ZRangeBy) *StringSliceCmd

func (Client) ZRangeByScore

func (c Client) ZRangeByScore(key string, opt *ZRangeBy) *StringSliceCmd

func (Client) ZRangeByScoreWithScores

func (c Client) ZRangeByScoreWithScores(key string, opt *ZRangeBy) *ZSliceCmd

func (Client) ZRangeWithScores

func (c Client) ZRangeWithScores(key string, start, stop int64) *ZSliceCmd

func (Client) ZRank

func (c Client) ZRank(key, member string) *IntCmd

func (Client) ZRem

func (c Client) ZRem(key string, members ...interface{}) *IntCmd

func (Client) ZRemRangeByLex

func (c Client) ZRemRangeByLex(key, min, max string) *IntCmd

func (Client) ZRemRangeByRank

func (c Client) ZRemRangeByRank(key string, start, stop int64) *IntCmd

func (Client) ZRemRangeByScore

func (c Client) ZRemRangeByScore(key, min, max string) *IntCmd

func (Client) ZRevRange

func (c Client) ZRevRange(key string, start, stop int64) *StringSliceCmd

func (Client) ZRevRangeByLex

func (c Client) ZRevRangeByLex(key string, opt *ZRangeBy) *StringSliceCmd

func (Client) ZRevRangeByScore

func (c Client) ZRevRangeByScore(key string, opt *ZRangeBy) *StringSliceCmd

func (Client) ZRevRangeByScoreWithScores

func (c Client) ZRevRangeByScoreWithScores(key string, opt *ZRangeBy) *ZSliceCmd

func (Client) ZRevRangeWithScores

func (c Client) ZRevRangeWithScores(key string, start, stop int64) *ZSliceCmd

func (Client) ZRevRank

func (c Client) ZRevRank(key, member string) *IntCmd

func (Client) ZScan

func (c Client) ZScan(key string, cursor uint64, match string, count int64) *ScanCmd

func (Client) ZScore

func (c Client) ZScore(key, member string) *FloatCmd

func (Client) ZUnionStore

func (c Client) ZUnionStore(dest string, store *ZStore) *IntCmd

type ClusterClient

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

func NewClusterClient(opt *ClusterOptions) *ClusterClient

NewClusterClient returns a Redis Cluster client as described in http://redis.io/topics/cluster-spec.

Example
// See http://redis.io/topics/cluster-tutorial for instructions
// how to setup Redis Cluster.
rdb := redis.NewClusterClient(&redis.ClusterOptions{
	Addrs: []string{":7000", ":7001", ":7002", ":7003", ":7004", ":7005"},
})
rdb.Ping()
Output:

Example (ManualSetup)

Following example creates a cluster from 2 master nodes and 2 slave nodes without using cluster mode or Redis Sentinel.

// clusterSlots returns cluster slots information.
// It can use service like ZooKeeper to maintain configuration information
// and Cluster.ReloadState to manually trigger state reloading.
clusterSlots := func() ([]redis.ClusterSlot, error) {
	slots := []redis.ClusterSlot{
		// First node with 1 master and 1 slave.
		{
			Start: 0,
			End:   8191,
			Nodes: []redis.ClusterNode{{
				Addr: ":7000", // master
			}, {
				Addr: ":8000", // 1st slave
			}},
		},
		// Second node with 1 master and 1 slave.
		{
			Start: 8192,
			End:   16383,
			Nodes: []redis.ClusterNode{{
				Addr: ":7001", // master
			}, {
				Addr: ":8001", // 1st slave
			}},
		},
	}
	return slots, nil
}

rdb := redis.NewClusterClient(&redis.ClusterOptions{
	ClusterSlots:  clusterSlots,
	RouteRandomly: true,
})
rdb.Ping()

// ReloadState reloads cluster state. It calls ClusterSlots func
// to get cluster slots information.
err := rdb.ReloadState()
if err != nil {
	panic(err)
}
Output:

func (*ClusterClient) AddHook

func (hs *ClusterClient) AddHook(hook Hook)

func (ClusterClient) Append

func (c ClusterClient) Append(key, value string) *IntCmd

func (ClusterClient) BLPop

func (c ClusterClient) BLPop(timeout time.Duration, keys ...string) *StringSliceCmd

func (ClusterClient) BRPop

func (c ClusterClient) BRPop(timeout time.Duration, keys ...string) *StringSliceCmd

func (ClusterClient) BRPopLPush

func (c ClusterClient) BRPopLPush(source, destination string, timeout time.Duration) *StringCmd

func (ClusterClient) BZPopMax

func (c ClusterClient) BZPopMax(timeout time.Duration, keys ...string) *ZWithKeyCmd

Redis `BZPOPMAX key [key ...] timeout` command.

func (ClusterClient) BZPopMin

func (c ClusterClient) BZPopMin(timeout time.Duration, keys ...string) *ZWithKeyCmd

Redis `BZPOPMIN key [key ...] timeout` command.

func (ClusterClient) BgRewriteAOF

func (c ClusterClient) BgRewriteAOF() *StatusCmd

func (ClusterClient) BgSave

func (c ClusterClient) BgSave() *StatusCmd

func (ClusterClient) BitCount

func (c ClusterClient) BitCount(key string, bitCount *BitCount) *IntCmd

func (ClusterClient) BitField

func (c ClusterClient) BitField(key string, args ...interface{}) *IntSliceCmd

func (ClusterClient) BitOpAnd

func (c ClusterClient) BitOpAnd(destKey string, keys ...string) *IntCmd

func (ClusterClient) BitOpNot

func (c ClusterClient) BitOpNot(destKey string, key string) *IntCmd

func (ClusterClient) BitOpOr

func (c ClusterClient) BitOpOr(destKey string, keys ...string) *IntCmd

func (ClusterClient) BitOpXor

func (c ClusterClient) BitOpXor(destKey string, keys ...string) *IntCmd

func (ClusterClient) BitPos

func (c ClusterClient) BitPos(key string, bit int64, pos ...int64) *IntCmd

func (ClusterClient) ClientGetName

func (c ClusterClient) ClientGetName() *StringCmd

ClientGetName returns the name of the connection.

func (ClusterClient) ClientID

func (c ClusterClient) ClientID() *IntCmd

func (ClusterClient) ClientKill

func (c ClusterClient) ClientKill(ipPort string) *StatusCmd

func (ClusterClient) ClientKillByFilter

func (c ClusterClient) ClientKillByFilter(keys ...string) *IntCmd

ClientKillByFilter is new style synx, while the ClientKill is old CLIENT KILL <option> [value] ... <option> [value]

func (ClusterClient) ClientList

func (c ClusterClient) ClientList() *StringCmd

func (ClusterClient) ClientPause

func (c ClusterClient) ClientPause(dur time.Duration) *BoolCmd

func (ClusterClient) ClientUnblock

func (c ClusterClient) ClientUnblock(id int64) *IntCmd

func (ClusterClient) ClientUnblockWithError

func (c ClusterClient) ClientUnblockWithError(id int64) *IntCmd

func (*ClusterClient) Close

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 (ClusterClient) ClusterAddSlots

func (c ClusterClient) ClusterAddSlots(slots ...int) *StatusCmd

func (ClusterClient) ClusterAddSlotsRange

func (c ClusterClient) ClusterAddSlotsRange(min, max int) *StatusCmd

func (ClusterClient) ClusterCountFailureReports

func (c ClusterClient) ClusterCountFailureReports(nodeID string) *IntCmd

func (ClusterClient) ClusterCountKeysInSlot

func (c ClusterClient) ClusterCountKeysInSlot(slot int) *IntCmd

func (ClusterClient) ClusterDelSlots

func (c ClusterClient) ClusterDelSlots(slots ...int) *StatusCmd

func (ClusterClient) ClusterDelSlotsRange

func (c ClusterClient) ClusterDelSlotsRange(min, max int) *StatusCmd

func (ClusterClient) ClusterFailover

func (c ClusterClient) ClusterFailover() *StatusCmd

func (ClusterClient) ClusterForget

func (c ClusterClient) ClusterForget(nodeID string) *StatusCmd

func (ClusterClient) ClusterGetKeysInSlot

func (c ClusterClient) ClusterGetKeysInSlot(slot int, count int) *StringSliceCmd

func (ClusterClient) ClusterInfo

func (c ClusterClient) ClusterInfo() *StringCmd

func (ClusterClient) ClusterKeySlot

func (c ClusterClient) ClusterKeySlot(key string) *IntCmd

func (ClusterClient) ClusterMeet

func (c ClusterClient) ClusterMeet(host, port string) *StatusCmd

func (ClusterClient) ClusterNodes

func (c ClusterClient) ClusterNodes() *StringCmd

func (ClusterClient) ClusterReplicate

func (c ClusterClient) ClusterReplicate(nodeID string) *StatusCmd

func (ClusterClient) ClusterResetHard

func (c ClusterClient) ClusterResetHard() *StatusCmd

func (ClusterClient) ClusterResetSoft

func (c ClusterClient) ClusterResetSoft() *StatusCmd

func (ClusterClient) ClusterSaveConfig

func (c ClusterClient) ClusterSaveConfig() *StatusCmd

func (ClusterClient) ClusterSlaves

func (c ClusterClient) ClusterSlaves(nodeID string) *StringSliceCmd

func (ClusterClient) ClusterSlots

func (c ClusterClient) ClusterSlots() *ClusterSlotsCmd

func (ClusterClient) Command

func (c ClusterClient) Command() *CommandsInfoCmd

func (ClusterClient) ConfigGet

func (c ClusterClient) ConfigGet(parameter string) *SliceCmd

func (ClusterClient) ConfigResetStat

func (c ClusterClient) ConfigResetStat() *StatusCmd

func (ClusterClient) ConfigRewrite

func (c ClusterClient) ConfigRewrite() *StatusCmd

func (ClusterClient) ConfigSet

func (c ClusterClient) ConfigSet(parameter, value string) *StatusCmd

func (*ClusterClient) Context

func (c *ClusterClient) Context() context.Context

func (*ClusterClient) DBSize

func (c *ClusterClient) DBSize() *IntCmd

func (ClusterClient) DbSize

func (c ClusterClient) DbSize() *IntCmd

Deperecated. Use DBSize instead.

func (ClusterClient) DebugObject

func (c ClusterClient) DebugObject(key string) *StringCmd

func (ClusterClient) Decr

func (c ClusterClient) Decr(key string) *IntCmd

func (ClusterClient) DecrBy

func (c ClusterClient) DecrBy(key string, decrement int64) *IntCmd

func (ClusterClient) Del

func (c ClusterClient) Del(keys ...string) *IntCmd

func (*ClusterClient) Do

func (c *ClusterClient) Do(args ...interface{}) *Cmd

Do creates a Cmd from the args and processes the cmd.

func (*ClusterClient) DoContext

func (c *ClusterClient) DoContext(ctx context.Context, args ...interface{}) *Cmd

func (ClusterClient) Dump

func (c ClusterClient) Dump(key string) *StringCmd

func (ClusterClient) Echo

func (c ClusterClient) Echo(message interface{}) *StringCmd

func (ClusterClient) Eval

func (c ClusterClient) Eval(script string, keys []string, args ...interface{}) *Cmd

func (ClusterClient) EvalSha

func (c ClusterClient) EvalSha(sha1 string, keys []string, args ...interface{}) *Cmd

func (ClusterClient) Exists

func (c ClusterClient) Exists(keys ...string) *IntCmd

func (ClusterClient) Expire

func (c ClusterClient) Expire(key string, expiration time.Duration) *BoolCmd

func (ClusterClient) ExpireAt

func (c ClusterClient) ExpireAt(key string, tm time.Time) *BoolCmd

func (ClusterClient) FlushAll

func (c ClusterClient) FlushAll() *StatusCmd

func (ClusterClient) FlushAllAsync

func (c ClusterClient) FlushAllAsync() *StatusCmd

func (ClusterClient) FlushDB

func (c ClusterClient) FlushDB() *StatusCmd

func (ClusterClient) FlushDBAsync

func (c ClusterClient) FlushDBAsync() *StatusCmd

func (*ClusterClient) ForEachMaster

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 (*ClusterClient) ForEachNode

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 (*ClusterClient) ForEachSlave

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 (ClusterClient) GeoAdd

func (c ClusterClient) GeoAdd(key string, geoLocation ...*GeoLocation) *IntCmd

func (ClusterClient) GeoDist

func (c ClusterClient) GeoDist(key string, member1, member2, unit string) *FloatCmd

func (ClusterClient) GeoHash

func (c ClusterClient) GeoHash(key string, members ...string) *StringSliceCmd

func (ClusterClient) GeoPos

func (c ClusterClient) GeoPos(key string, members ...string) *GeoPosCmd

func (ClusterClient) GeoRadius

func (c ClusterClient) GeoRadius(key string, longitude, latitude