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

Expand ▾ Collapse ▴

Documentation

Overview

    Package redis implements a Redis client.

    Example (CustomCommand)
    Output:
    
    "" redis: nil
    
    Example (CustomCommand2)
    Output:
    
    "" redis: nil
    
    Example (Instrumentation)
    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
              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
                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
                  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
                  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
                                                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
                                                        Output:
                                                        
                                                        1 <nil>
                                                        

                                                        func (*Client) Pipelined

                                                        func (c *Client) Pipelined(fn func(Pipeliner) error) ([]Cmder, error)
                                                        Example
                                                        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
                                                                        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
                                                                          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
                                                                                  Output:
                                                                                  
                                                                                  1 <nil>
                                                                                  

                                                                                  func (*Client) TxPipelined

                                                                                  func (c *Client) TxPipelined(fn func(Pipeliner) error) ([]Cmder, error)
                                                                                  Example
                                                                                  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
                                                                                    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
                                                                                                          Output:
                                                                                                          
                                                                                                          
                                                                                                          Example (ManualSetup)

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