redis: github.com/go-redis/redis Index | Examples | Files | Directories

package redis

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

Package redis implements a Redis client.

Example (CustomCommand)

Code: 

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)

Code: 

v, err := rdb.Do("get", "key_does_not_exist").Text()
fmt.Printf("%q %s", v, err)

Output:

"" redis: nil
Example (Instrumentation)

Code: 

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

rdb.Ping()

Output:

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

Index

Examples

Package Files

cluster.go cluster_commands.go command.go commands.go doc.go error.go iterator.go options.go pipeline.go pubsub.go redis.go result.go ring.go script.go sentinel.go tx.go universal.go

Constants

❖
const Nil = proto.Nil

Nil reply returned by Redis when key does not exist.

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

TxFailedErr transaction redis failed.

func SetLogger Uses

❖
func SetLogger(logger *log.Logger)

type BitCount Uses

❖
type BitCount struct {
    Start, End int64
}

type BoolCmd Uses

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

func NewBoolCmd Uses

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

func NewBoolResult Uses

❖
func NewBoolResult(val bool, err error) *BoolCmd

NewBoolResult returns a BoolCmd initialised with val and err for testing

func (*BoolCmd) Args Uses

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

func (*BoolCmd) Err Uses

❖
func (cmd *BoolCmd) Err() error

func (*BoolCmd) Name Uses

❖
func (cmd *BoolCmd) Name() string

func (*BoolCmd) Result Uses

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

func (*BoolCmd) SetErr Uses

❖
func (cmd *BoolCmd) SetErr(e error)

func (*BoolCmd) String Uses

❖
func (cmd *BoolCmd) String() string

func (*BoolCmd) Val Uses

❖
func (cmd *BoolCmd) Val() bool

type BoolSliceCmd Uses

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

func NewBoolSliceCmd Uses

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

func NewBoolSliceResult Uses

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

NewBoolSliceResult returns a BoolSliceCmd initialised with val and err for testing

func (*BoolSliceCmd) Args Uses

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

func (*BoolSliceCmd) Err Uses

❖
func (cmd *BoolSliceCmd) Err() error

func (*BoolSliceCmd) Name Uses

❖
func (cmd *BoolSliceCmd) Name() string

func (*BoolSliceCmd) Result Uses

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

func (*BoolSliceCmd) SetErr Uses

❖
func (cmd *BoolSliceCmd) SetErr(e error)

func (*BoolSliceCmd) String Uses

❖
func (cmd *BoolSliceCmd) String() string

func (*BoolSliceCmd) Val Uses

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

type Client Uses

❖
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

Code: 

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 Uses

❖
func NewClient(opt *Options) *Client

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

Example

Code: 

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 Uses

❖
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

Code: 

// 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()

func (*Client) AddHook Uses

❖
func (hs *Client) AddHook(hook Hook)

func (Client) Append Uses

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

func (Client) BLPop Uses

❖
func (c Client) BLPop(timeout time.Duration, keys ...string) *StringSliceCmd
Example

Code: 

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 Uses

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

func (Client) BRPopLPush Uses

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

func (Client) BZPopMax Uses

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

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

func (Client) BZPopMin Uses

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

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

func (Client) BgRewriteAOF Uses

❖
func (c Client) BgRewriteAOF() *StatusCmd

func (Client) BgSave Uses

❖
func (c Client) BgSave() *StatusCmd

func (Client) BitCount Uses

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

func (Client) BitField Uses

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

func (Client) BitOpAnd Uses

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

func (Client) BitOpNot Uses

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

func (Client) BitOpOr Uses

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

func (Client) BitOpXor Uses

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

func (Client) BitPos Uses

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

func (Client) ClientGetName Uses

❖
func (c Client) ClientGetName() *StringCmd

ClientGetName returns the name of the connection.

func (Client) ClientID Uses

❖
func (c Client) ClientID() *IntCmd

func (Client) ClientKill Uses

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

func (Client) ClientKillByFilter Uses

❖
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 Uses

❖
func (c Client) ClientList() *StringCmd

func (Client) ClientPause Uses

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

func (Client) ClientUnblock Uses

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

func (Client) ClientUnblockWithError Uses

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

func (Client) Close Uses

❖
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 Uses

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

func (Client) ClusterAddSlotsRange Uses

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

func (Client) ClusterCountFailureReports Uses

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

func (Client) ClusterCountKeysInSlot Uses

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

func (Client) ClusterDelSlots Uses

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

func (Client) ClusterDelSlotsRange Uses

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

func (Client) ClusterFailover Uses

❖
func (c Client) ClusterFailover() *StatusCmd

func (Client) ClusterForget Uses

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

func (Client) ClusterGetKeysInSlot Uses

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

func (Client) ClusterInfo Uses

❖
func (c Client) ClusterInfo() *StringCmd

func (Client) ClusterKeySlot Uses

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

func (Client) ClusterMeet Uses

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

func (Client) ClusterNodes Uses

❖
func (c Client) ClusterNodes() *StringCmd

func (Client) ClusterReplicate Uses

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

func (Client) ClusterResetHard Uses

❖
func (c Client) ClusterResetHard() *StatusCmd

func (Client) ClusterResetSoft Uses

❖
func (c Client) ClusterResetSoft() *StatusCmd

func (Client) ClusterSaveConfig Uses

❖
func (c Client) ClusterSaveConfig() *StatusCmd

func (Client) ClusterSlaves Uses

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

func (Client) ClusterSlots Uses

❖
func (c Client) ClusterSlots() *ClusterSlotsCmd

func (Client) Command Uses

❖
func (c Client) Command() *CommandsInfoCmd

func (Client) ConfigGet Uses

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

func (Client) ConfigResetStat Uses

❖
func (c Client) ConfigResetStat() *StatusCmd

func (Client) ConfigRewrite Uses

❖
func (c Client) ConfigRewrite() *StatusCmd

func (Client) ConfigSet Uses

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

func (*Client) Conn Uses

❖
func (c *Client) Conn() *Conn

func (*Client) Context Uses

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

func (Client) DBSize Uses

❖
func (c Client) DBSize() *IntCmd

func (Client) DbSize Uses

❖
func (c Client) DbSize() *IntCmd

Deperecated. Use DBSize instead.

func (Client) DebugObject Uses

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

func (Client) Decr Uses

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

func (Client) DecrBy Uses

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

func (Client) Del Uses

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

func (*Client) Do Uses

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

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

func (*Client) DoContext Uses

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

func (Client) Dump Uses

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

func (Client) Echo Uses

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

func (Client) Eval Uses

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

func (Client) EvalSha Uses

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

func (Client) Exists Uses

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

func (Client) Expire Uses

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

func (Client) ExpireAt Uses

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

func (Client) FlushAll Uses

❖
func (c Client) FlushAll() *StatusCmd

func (Client) FlushAllAsync Uses

❖
func (c Client) FlushAllAsync() *StatusCmd

func (Client) FlushDB Uses

❖
func (c Client) FlushDB() *StatusCmd

func (Client) FlushDBAsync Uses

❖
func (c Client) FlushDBAsync() *StatusCmd

func (Client) GeoAdd Uses

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

func (Client) GeoDist Uses

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

func (Client) GeoHash Uses

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

func (Client) GeoPos Uses

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

func (Client) GeoRadius Uses

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

GeoRadius is a read-only GEORADIUS_RO command.

func (Client) GeoRadiusByMember Uses

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

GeoRadius is a read-only GEORADIUSBYMEMBER_RO command.

func (Client) GeoRadiusByMemberStore Uses

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

GeoRadiusByMemberStore is a writing GEORADIUSBYMEMBER command.

func (Client) GeoRadiusStore Uses

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

GeoRadiusStore is a writing GEORADIUS command.

func (Client) Get Uses

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

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

func (Client) GetBit Uses

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

func (Client) GetRange Uses

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

func (Client) GetSet Uses

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

func (Client) HDel Uses

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

func (Client) HExists Uses

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

func (Client) HGet Uses

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

func (Client) HGetAll Uses

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

func (Client) HIncrBy Uses

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

func (Client) HIncrByFloat Uses

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

func (Client) HKeys Uses

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

func (Client) HLen Uses

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

func (Client) HMGet Uses

❖
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 Uses

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

HMSet is like HSet, but accepts multiple values: 

- 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 uses HSET Redis command underneath because HMSET is deprecated.

func (Client) HScan Uses

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

func (Client) HSet Uses

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

func (Client) HSetNX Uses

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

func (Client) HVals Uses

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

func (Client) Incr Uses

❖
func (c Client) Incr(key string) *IntCmd
Example

Code: 

result, err := rdb.Incr("counter").Result()
if err != nil {
    panic(err)
}

fmt.Println(result)

Output:

1

func (Client) IncrBy Uses

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

func (Client) IncrByFloat Uses

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

func (Client) Info Uses

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

func (Client) Keys Uses

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

func (Client) LIndex Uses

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

func (Client) LInsert Uses

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

func (Client) LInsertAfter Uses

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

func (Client) LInsertBefore Uses

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

func (Client) LLen Uses

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

func (Client) LPop Uses

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

func (Client) LPush Uses

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

func (Client) LPushX Uses

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

func (Client) LRange Uses

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

func (Client) LRem Uses

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

func (Client) LSet Uses

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

func (Client) LTrim Uses

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

func (Client) LastSave Uses

❖
func (c Client) LastSave() *IntCmd

func (Client) MGet Uses

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

func (Client) MSet Uses

❖
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 Uses

❖
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 Uses

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

func (Client) Migrate Uses

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

func (Client) Move Uses

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

func (Client) ObjectEncoding Uses

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

func (Client) ObjectIdleTime Uses

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

func (Client) ObjectRefCount Uses

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

func (*Client) Options Uses

❖
func (c *Client) Options() *Options

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

func (Client) PExpire Uses

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

func (Client) PExpireAt Uses

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

func (Client) PFAdd Uses

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

func (Client) PFCount Uses

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

func (Client) PFMerge Uses

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

func (*Client) PSubscribe Uses

❖
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 Uses

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

func (Client) Persist Uses

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

func (Client) Ping Uses

❖
func (c Client) Ping() *StatusCmd

func (*Client) Pipeline Uses

❖
func (c *Client) Pipeline() Pipeliner
Example

Code: 

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 Uses

❖
func (c *Client) Pipelined(fn func(Pipeliner) error) ([]Cmder, error)
Example

Code: 

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 Uses

❖
func (c *Client) PoolStats() *PoolStats

PoolStats returns connection pool stats.

func (*Client) Process Uses

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

func (*Client) ProcessContext Uses

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

func (Client) PubSubChannels Uses

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

func (Client) PubSubNumPat Uses

❖
func (c Client) PubSubNumPat() *IntCmd

func (Client) PubSubNumSub Uses

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

func (Client) Publish Uses

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

Publish posts the message to the channel.

func (Client) Quit Uses

❖
func (c Client) Quit() *StatusCmd

func (Client) RPop Uses

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

func (Client) RPopLPush Uses

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

func (Client) RPush Uses

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

func (Client) RPushX Uses

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

func (Client) RandomKey Uses

❖
func (c Client) RandomKey() *StringCmd

func (Client) ReadOnly Uses

❖
func (c Client) ReadOnly() *StatusCmd

func (Client) ReadWrite Uses

❖
func (c Client) ReadWrite() *StatusCmd

func (Client) Rename Uses

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

func (Client) RenameNX Uses

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

func (Client) Restore Uses

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

func (Client) RestoreReplace Uses

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

func (Client) SAdd Uses

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

func (Client) SCard Uses

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

func (Client) SDiff Uses

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

func (Client) SDiffStore Uses

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

func (Client) SInter Uses

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

func (Client) SInterStore Uses

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

func (Client) SIsMember Uses

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

func (Client) SMembers Uses

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

Redis `SMEMBERS key` command output as a slice

func (Client) SMembersMap Uses

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

Redis `SMEMBERS key` command output as a map

func (Client) SMove Uses

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

func (Client) SPop Uses

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

Redis `SPOP key` command.

func (Client) SPopN Uses

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

Redis `SPOP key count` command.

func (Client) SRandMember Uses

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

Redis `SRANDMEMBER key` command.

func (Client) SRandMemberN Uses

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

Redis `SRANDMEMBER key count` command.

func (Client) SRem Uses

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

func (Client) SScan Uses

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

func (Client) SUnion Uses

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

func (Client) SUnionStore Uses

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

func (Client) Save Uses

❖
func (c Client) Save() *StatusCmd

func (Client) Scan Uses

❖
func (c Client) Scan(cursor uint64, match string, count int64) *ScanCmd
Example

Code: 

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 Uses

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

func (Client) ScriptFlush Uses

❖
func (c Client) ScriptFlush() *StatusCmd

func (Client) ScriptKill Uses

❖
func (c Client) ScriptKill() *StatusCmd

func (Client) ScriptLoad Uses

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

func (Client) Set Uses

❖
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

Code: 

// 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)
}

func (Client) SetBit Uses

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

func (Client) SetNX Uses

❖
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 Uses

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

func (Client) SetXX Uses

❖
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 Uses

❖
func (c Client) Shutdown() *StatusCmd

func (Client) ShutdownNoSave Uses

❖
func (c Client) ShutdownNoSave() *StatusCmd

func (Client) ShutdownSave Uses

❖
func (c Client) ShutdownSave() *StatusCmd

func (Client) SlaveOf Uses

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

func (Client) SlowLog Uses

❖
func (c Client) SlowLog()

func (Client) Sort Uses

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

func (Client) SortInterfaces Uses

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

func (Client) SortStore Uses

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

func (Client) StrLen Uses

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

func (Client) String Uses

❖
func (c Client) String() string

func (*Client) Subscribe Uses

❖
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 Uses

❖
func (c Client) Sync()

func (Client) TTL Uses

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

func (Client) Time Uses

❖
func (c Client) Time() *TimeCmd

func (Client) Touch Uses

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

func (*Client) TxPipeline Uses

❖
func (c *Client) TxPipeline() Pipeliner

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

Example

Code: 

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 Uses

❖
func (c *Client) TxPipelined(fn func(Pipeliner) error) ([]Cmder, error)
Example

Code: 

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 Uses

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

func (Client) Wait Uses

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

func (*Client) Watch Uses

❖
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

Code: 

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 Uses

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

func (*Client) WithContext Uses

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

func (*Client) WithTimeout Uses

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

func (Client) XAck Uses

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

func (Client) XAdd Uses

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

func (Client) XClaim Uses

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

func (Client) XClaimJustID Uses

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

func (Client) XDel Uses

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

func (Client) XGroupCreate Uses

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

func (Client) XGroupCreateMkStream Uses

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

func (Client) XGroupDelConsumer Uses

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

func (Client) XGroupDestroy Uses

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

func (Client) XGroupSetID Uses

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

func (Client) XInfoGroups Uses

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

func (Client) XLen Uses

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

func (Client) XPending Uses

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

func (Client) XPendingExt Uses

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

func (Client) XRange Uses

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

func (Client) XRangeN Uses

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

func (Client) XRead Uses

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

func (Client) XReadGroup Uses

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

func (Client) XReadStreams Uses

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

func (Client) XRevRange Uses

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

func (Client) XRevRangeN Uses

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

func (Client) XTrim Uses

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

func (Client) XTrimApprox Uses

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

func (Client) ZAdd Uses

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

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

func (Client) ZAddCh Uses

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

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

func (Client) ZAddNX Uses

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

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

func (Client) ZAddNXCh Uses

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

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

func (Client) ZAddXX Uses

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

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

func (Client) ZAddXXCh Uses

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

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

func (Client) ZCard Uses

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

func (Client) ZCount Uses

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

func (Client) ZIncr Uses

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

Redis `ZADD key INCR score member` command.

func (Client) ZIncrBy Uses

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

func (Client) ZIncrNX Uses

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

Redis `ZADD key NX INCR score member` command.

func (Client) ZIncrXX Uses

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

Redis `ZADD key XX INCR score member` command.

func (Client) ZInterStore Uses

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

func (Client) ZLexCount Uses

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

func (Client) ZPopMax Uses

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

func (Client) ZPopMin Uses

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

func (Client) ZRange Uses

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

func (Client) ZRangeByLex Uses

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

func (Client) ZRangeByScore Uses

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

func (Client) ZRangeByScoreWithScores Uses

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

func (Client) ZRangeWithScores Uses

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

func (Client) ZRank Uses

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

func (Client) ZRem Uses

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

func (Client) ZRemRangeByLex Uses

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

func (Client) ZRemRangeByRank Uses

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

func (Client) ZRemRangeByScore Uses

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

func (Client) ZRevRange Uses

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

func (Client) ZRevRangeByLex Uses

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

func (Client) ZRevRangeByScore Uses

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

func (Client) ZRevRangeByScoreWithScores Uses

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

func (Client) ZRevRangeWithScores Uses

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

func (Client) ZRevRank Uses

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

func (Client) ZScan Uses

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

func (Client) ZScore Uses

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

func (Client) ZUnionStore Uses

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

type ClusterClient Uses

❖
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 Uses

❖
func NewClusterClient(opt *ClusterOptions) *ClusterClient

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

Example

Code: 

// 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()
Example (ManualSetup)

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

Code: 

// 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)
}

func (*ClusterClient) AddHook Uses

❖
func (hs *ClusterClient) AddHook(hook Hook)

func (ClusterClient) Append Uses

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

func (ClusterClient) BLPop Uses

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

func (ClusterClient) BRPop Uses

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

func (ClusterClient) BRPopLPush Uses

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

func (ClusterClient) BZPopMax Uses

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

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

func (ClusterClient) BZPopMin Uses

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

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

func (ClusterClient) BgRewriteAOF Uses

❖
func (c ClusterClient) BgRewriteAOF() *StatusCmd

func (ClusterClient) BgSave Uses

❖
func (c ClusterClient) BgSave() *StatusCmd

func (ClusterClient) BitCount Uses

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

func (ClusterClient) BitField Uses

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

func (ClusterClient) BitOpAnd Uses

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

func (ClusterClient) BitOpNot Uses

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

func (ClusterClient) BitOpOr Uses

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

func (ClusterClient) BitOpXor Uses

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

func (ClusterClient) BitPos Uses

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

func (ClusterClient) ClientGetName Uses

❖
func (c ClusterClient) ClientGetName() *StringCmd

ClientGetName returns the name of the connection.

func (ClusterClient) ClientID Uses

❖
func (c ClusterClient) ClientID() *IntCmd

func (ClusterClient) ClientKill Uses

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

func (ClusterClient) ClientKillByFilter Uses

❖
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 Uses

❖
func (c ClusterClient) ClientList() *StringCmd

func (ClusterClient) ClientPause Uses

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

func (ClusterClient) ClientUnblock Uses

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

func (ClusterClient) ClientUnblockWithError Uses

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

func (*ClusterClient) Close Uses

❖
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 Uses

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

func (ClusterClient) ClusterAddSlotsRange Uses

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

func (ClusterClient) ClusterCountFailureReports Uses

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

func (ClusterClient) ClusterCountKeysInSlot Uses

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

func (ClusterClient) ClusterDelSlots Uses

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

func (ClusterClient) ClusterDelSlotsRange Uses

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

func (ClusterClient) ClusterFailover Uses

❖
func (c ClusterClient) ClusterFailover() *StatusCmd

func (ClusterClient) ClusterForget Uses

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

func (ClusterClient) ClusterGetKeysInSlot Uses

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

func (ClusterClient) ClusterInfo Uses

❖
func (c ClusterClient) ClusterInfo() *StringCmd

func (ClusterClient) ClusterKeySlot Uses

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

func (ClusterClient) ClusterMeet Uses

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

func (ClusterClient) ClusterNodes Uses

❖
func (c ClusterClient) ClusterNodes() *StringCmd

func (ClusterClient) ClusterReplicate Uses

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

func (ClusterClient) ClusterResetHard Uses

❖
func (c ClusterClient) ClusterResetHard() *StatusCmd

func (ClusterClient) ClusterResetSoft Uses

❖
func (c ClusterClient) ClusterResetSoft() *StatusCmd

func (ClusterClient) ClusterSaveConfig Uses

❖
func (c ClusterClient) ClusterSaveConfig() *StatusCmd

func (ClusterClient) ClusterSlaves Uses

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

func (ClusterClient) ClusterSlots Uses

❖
func (c ClusterClient) ClusterSlots() *ClusterSlotsCmd

func (ClusterClient) Command Uses

❖
func (c ClusterClient) Command() *CommandsInfoCmd

func (ClusterClient) ConfigGet Uses

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

func (ClusterClient) ConfigResetStat Uses

❖
func (c ClusterClient) ConfigResetStat() *StatusCmd

func (ClusterClient) ConfigRewrite Uses

❖
func (c ClusterClient) ConfigRewrite() *StatusCmd

func (ClusterClient) ConfigSet Uses

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

func (*ClusterClient) Context Uses

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

func (*ClusterClient) DBSize Uses

❖
func (c *ClusterClient) DBSize() *IntCmd

func (ClusterClient) DbSize Uses

❖
func (c ClusterClient) DbSize() *IntCmd

Deperecated. Use DBSize instead.

func (ClusterClient) DebugObject Uses

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

func (ClusterClient) Decr Uses

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

func (ClusterClient) DecrBy Uses

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

func (ClusterClient) Del Uses

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

func (*ClusterClient) Do Uses

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

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

func (*ClusterClient) DoContext Uses

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

func (ClusterClient) Dump Uses

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

func (ClusterClient) Echo Uses

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

func (ClusterClient) Eval Uses

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

func (ClusterClient) EvalSha Uses

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

func (ClusterClient) Exists Uses

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

func (ClusterClient) Expire Uses

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

func (ClusterClient) ExpireAt Uses

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

func (ClusterClient) FlushAll Uses

❖
func (c ClusterClient) FlushAll() *StatusCmd

func (ClusterClient) FlushAllAsync Uses

❖
func (c ClusterClient) FlushAllAsync() *StatusCmd

func (ClusterClient) FlushDB Uses

❖
func (c ClusterClient) FlushDB() *StatusCmd

func (ClusterClient) FlushDBAsync Uses

❖
func (c ClusterClient) FlushDBAsync() *StatusCmd

func (*ClusterClient) ForEachMaster Uses

❖
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 Uses

❖
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 Uses

❖
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 Uses

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

func (ClusterClient) GeoDist Uses

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

func (ClusterClient) GeoHash Uses

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

func (ClusterClient) GeoPos Uses

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

func (ClusterClient) GeoRadius Uses

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

GeoRadius is a read-only GEORADIUS_RO command.

func (ClusterClient) GeoRadiusByMember Uses

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

GeoRadius is a read-only GEORADIUSBYMEMBER_RO command.

func (ClusterClient) GeoRadiusByMemberStore Uses

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

GeoRadiusByMemberStore is a writing GEORADIUSBYMEMBER command.

func (ClusterClient) GeoRadiusStore Uses

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

GeoRadiusStore is a writing GEORADIUS command.

func (ClusterClient) Get Uses

❖
func (c ClusterClient) Get(key string) *StringCmd

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

func (ClusterClient) GetBit Uses

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

func (ClusterClient) GetRange Uses

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

func (ClusterClient) GetSet Uses

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

func (ClusterClient) HDel Uses

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

func (ClusterClient) HExists Uses

❖
func (c ClusterClient) HExists(key, field string) *BoolCmd

func (ClusterClient) HGet Uses

❖
func (c ClusterClient) HGet(key, field string) *StringCmd

func (ClusterClient) HGetAll Uses

❖
func (c ClusterClient) HGetAll(key string) *StringStringMapCmd

func (ClusterClient) HIncrBy Uses

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

func (ClusterClient) HIncrByFloat Uses

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

func (ClusterClient) HKeys Uses

❖
func (c ClusterClient) HKeys(key string) *StringSliceCmd

func (ClusterClient) HLen Uses

❖
func (c ClusterClient) HLen(key string) *IntCmd

func (ClusterClient) HMGet Uses

❖
func (c ClusterClient) 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 (ClusterClient) HMSet Uses

❖
func (c ClusterClient) HMSet(key string, values ...interface{}) *IntCmd

HMSet is like HSet, but accepts multiple values: 

- 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 uses HSET Redis command underneath because HMSET is deprecated.

func (ClusterClient) HScan Uses

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

func (ClusterClient) HSet Uses

❖
func (c ClusterClient) HSet(key, field string, value interface{}) *BoolCmd

func (ClusterClient) HSetNX Uses

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

func (ClusterClient) HVals Uses

❖
func (c ClusterClient) HVals(key string) *StringSliceCmd

func (ClusterClient) Incr Uses

❖
func (c ClusterClient) Incr(key string) *IntCmd

func (ClusterClient) IncrBy Uses

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

func (ClusterClient) IncrByFloat Uses

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

func (ClusterClient) Info Uses

❖
func (c ClusterClient) Info(section ...string) *StringCmd

func (ClusterClient) Keys Uses

❖
func (c ClusterClient) Keys(pattern string) *StringSliceCmd

func (ClusterClient) LIndex Uses

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

func (ClusterClient) LInsert Uses

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

func (ClusterClient) LInsertAfter Uses

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

func (ClusterClient) LInsertBefore Uses

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

func (ClusterClient) LLen Uses

❖
func (c ClusterClient) LLen(key string) *IntCmd

func (ClusterClient) LPop Uses

❖
func (c ClusterClient) LPop(key string) *StringCmd

func (ClusterClient) LPush Uses

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

func (ClusterClient) LPushX Uses

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

func (ClusterClient) LRange Uses

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

func (ClusterClient) LRem Uses

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

func (ClusterClient) LSet Uses

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

func (ClusterClient) LTrim Uses

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

func (ClusterClient) LastSave Uses

❖
func (c ClusterClient) LastSave() *IntCmd

func (ClusterClient) MGet Uses

❖
func (c ClusterClient) MGet(keys ...string) *SliceCmd

func (ClusterClient) MSet Uses

❖
func (c ClusterClient) 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 (ClusterClient) MSetNX Uses

❖
func (c ClusterClient) 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 (ClusterClient) MemoryUsage Uses

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

func (ClusterClient) Migrate Uses

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

func (ClusterClient) Move Uses

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

func (ClusterClient) ObjectEncoding Uses

❖
func (c ClusterClient) ObjectEncoding(key string) *StringCmd

func (ClusterClient) ObjectIdleTime Uses

❖
func (c ClusterClient) ObjectIdleTime(key string) *DurationCmd

func (ClusterClient) ObjectRefCount Uses

❖
func (c ClusterClient) ObjectRefCount(key string) *IntCmd

func (*ClusterClient) Options Uses

❖
func (c *ClusterClient) Options() *ClusterOptions

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

func (ClusterClient) PExpire Uses

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

func (ClusterClient) PExpireAt Uses

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

func (ClusterClient) PFAdd Uses

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

func (ClusterClient) PFCount Uses

❖
func (c ClusterClient) PFCount(keys ...string) *IntCmd

func (ClusterClient) PFMerge Uses

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

func (*ClusterClient) PSubscribe Uses

❖
func (c *ClusterClient) PSubscribe(channels ...string) *PubSub

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

func (ClusterClient) PTTL Uses

❖
func (c ClusterClient) PTTL(key string) *DurationCmd

func (ClusterClient) Persist Uses

❖
func (c ClusterClient) Persist(key string) *BoolCmd

func (ClusterClient) Ping Uses

❖
func (c ClusterClient) Ping() *StatusCmd

func (*ClusterClient) Pipeline Uses

❖
func (c *ClusterClient) Pipeline() Pipeliner

func (*ClusterClient) Pipelined Uses

❖
func (c *ClusterClient) Pipelined(fn func(Pipeliner) error) ([]Cmder, error)

func (*ClusterClient) PoolStats Uses

❖
func (c *ClusterClient) PoolStats() *PoolStats

PoolStats returns accumulated connection pool stats.

func (*ClusterClient) Process Uses

❖
func (c *ClusterClient) Process(cmd Cmder) error

func (*ClusterClient) ProcessContext Uses

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

func (ClusterClient) PubSubChannels Uses

❖
func (c ClusterClient) PubSubChannels(pattern string) *StringSliceCmd

func (ClusterClient) PubSubNumPat Uses

❖
func (c ClusterClient) PubSubNumPat() *IntCmd

func (ClusterClient) PubSubNumSub Uses

❖
func (c ClusterClient) PubSubNumSub(channels ...string) *StringIntMapCmd

func (ClusterClient) Publish Uses

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

Publish posts the message to the channel.

func (ClusterClient) Quit Uses

❖
func (c ClusterClient) Quit() *StatusCmd

func (ClusterClient) RPop Uses

❖
func (c ClusterClient) RPop(key string) *StringCmd

func (ClusterClient) RPopLPush Uses

❖
func (c ClusterClient) RPopLPush(source, destination string) *StringCmd

func (ClusterClient) RPush Uses

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

func (ClusterClient) RPushX Uses

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

func (ClusterClient) RandomKey Uses

❖
func (c ClusterClient) RandomKey() *StringCmd

func (ClusterClient) ReadOnly Uses

❖
func (c ClusterClient) ReadOnly() *StatusCmd

func (ClusterClient) ReadWrite Uses

❖
func (c ClusterClient) ReadWrite() *StatusCmd

func (*ClusterClient) ReloadState Uses

❖
func (c *ClusterClient) ReloadState() error

ReloadState reloads cluster state. If available it calls ClusterSlots func to get cluster slots information.

func (ClusterClient) Rename Uses

❖
func (c ClusterClient) Rename(key, newkey string) *StatusCmd

func (ClusterClient) RenameNX Uses

❖
func (c ClusterClient) RenameNX(key, newkey string) *BoolCmd

func (ClusterClient) Restore Uses

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

func (ClusterClient) RestoreReplace Uses

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

func (ClusterClient) SAdd Uses

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

func (ClusterClient) SCard Uses

❖
func (c ClusterClient) SCard(key string) *IntCmd

func (ClusterClient) SDiff Uses

❖
func (c ClusterClient) SDiff(keys ...string) *StringSliceCmd

func (ClusterClient) SDiffStore Uses

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

func (ClusterClient) SInter Uses

❖
func (c ClusterClient) SInter(keys ...string) *StringSliceCmd

func (ClusterClient) SInterStore Uses

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

func (ClusterClient) SIsMember Uses

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

func (ClusterClient) SMembers Uses

❖
func (c ClusterClient) SMembers(key string) *StringSliceCmd

Redis `SMEMBERS key` command output as a slice

func (ClusterClient) SMembersMap Uses

❖
func (c ClusterClient) SMembersMap(key string) *StringStructMapCmd

Redis `SMEMBERS key` command output as a map

func (ClusterClient) SMove Uses

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

func (ClusterClient) SPop Uses

❖
func (c ClusterClient) SPop(key string) *StringCmd

Redis `SPOP key` command.

func (ClusterClient) SPopN Uses

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

Redis `SPOP key count` command.

func (ClusterClient) SRandMember Uses

❖
func (c ClusterClient) SRandMember(key string) *StringCmd

Redis `SRANDMEMBER key` command.

func (ClusterClient) SRandMemberN Uses

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

Redis `SRANDMEMBER key count` command.

func (ClusterClient) SRem Uses

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

func (ClusterClient) SScan Uses

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

func (ClusterClient) SUnion Uses

❖
func (c ClusterClient) SUnion(keys ...string) *StringSliceCmd

func (ClusterClient) SUnionStore Uses

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

func (ClusterClient) Save Uses

❖
func (c ClusterClient) Save() *StatusCmd

func (ClusterClient) Scan Uses

❖
func (c ClusterClient) Scan(cursor uint64, match string, count int64) *ScanCmd

func (ClusterClient) ScriptExists Uses

❖
func (c ClusterClient) ScriptExists(hashes ...string) *BoolSliceCmd

func (ClusterClient) ScriptFlush Uses

❖
func (c ClusterClient) ScriptFlush() *StatusCmd

func (ClusterClient) ScriptKill Uses

❖
func (c ClusterClient) ScriptKill() *StatusCmd

func (ClusterClient) ScriptLoad Uses

❖
func (c ClusterClient) ScriptLoad(script string) *StringCmd

func (ClusterClient) Set Uses

❖
func (c ClusterClient) 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.

func (ClusterClient) SetBit Uses

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

func (ClusterClient) SetNX Uses

❖
func (c ClusterClient) 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 (ClusterClient) SetRange Uses

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

func (ClusterClient) SetXX Uses

❖
func (c ClusterClient) 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 (ClusterClient) Shutdown Uses

❖
func (c ClusterClient) Shutdown() *StatusCmd

func (ClusterClient) ShutdownNoSave Uses

❖
func (c ClusterClient) ShutdownNoSave() *StatusCmd

func (ClusterClient) ShutdownSave Uses

❖
func (c ClusterClient) ShutdownSave() *StatusCmd

func (ClusterClient) SlaveOf Uses

❖
func (c ClusterClient) SlaveOf(host, port string) *StatusCmd

func (ClusterClient) SlowLog Uses

❖
func (c ClusterClient) SlowLog()

func (ClusterClient) Sort Uses

❖
func (c ClusterClient) Sort(key string, sort *Sort) *StringSliceCmd

func (ClusterClient) SortInterfaces Uses

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

func (ClusterClient) SortStore Uses

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

func (ClusterClient) StrLen Uses

❖
func (c ClusterClient) StrLen(key string) *IntCmd

func (*ClusterClient) Subscribe Uses

❖
func (c *ClusterClient) Subscribe(channels ...string) *PubSub

Subscribe subscribes the client to the specified channels. Channels can be omitted to create empty subscription.

func (ClusterClient) Sync Uses

❖
func (c ClusterClient) Sync()

func (ClusterClient) TTL Uses

❖
func (c ClusterClient) TTL(key string) *DurationCmd

func (ClusterClient) Time Uses

❖
func (c ClusterClient) Time() *TimeCmd

func (ClusterClient) Touch Uses

❖
func (c ClusterClient) Touch(keys ...string) *IntCmd

func (*ClusterClient) TxPipeline Uses

❖
func (c *ClusterClient) TxPipeline() Pipeliner

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

func (*ClusterClient) TxPipelined Uses

❖
func (c *ClusterClient) TxPipelined(fn func(Pipeliner) error) ([]Cmder, error)

func (ClusterClient) Type Uses

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

func (ClusterClient) Wait Uses

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

func (*ClusterClient) Watch Uses

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

func (*ClusterClient) WatchContext Uses

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

func (*ClusterClient) WithContext Uses

❖
func (c *ClusterClient) WithContext(ctx context.Context) *ClusterClient

func (ClusterClient) XAck Uses

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

func (ClusterClient) XAdd Uses

❖
func (c ClusterClient) XAdd(a *XAddArgs) *StringCmd

func (ClusterClient) XClaim Uses

❖
func (c ClusterClient) XClaim(a *XClaimArgs) *XMessageSliceCmd

func (ClusterClient) XClaimJustID Uses

❖
func (c ClusterClient) XClaimJustID(a *XClaimArgs) *StringSliceCmd

func (ClusterClient) XDel Uses

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

func (ClusterClient) XGroupCreate Uses

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

func (ClusterClient) XGroupCreateMkStream Uses

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

func (ClusterClient) XGroupDelConsumer Uses

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

func (ClusterClient) XGroupDestroy Uses

❖
func (c ClusterClient) XGroupDestroy(stream, group string) *IntCmd

func (ClusterClient) XGroupSetID Uses

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

func (ClusterClient) XInfoGroups Uses

❖
func (c ClusterClient) XInfoGroups(key string) *XInfoGroupsCmd

func (ClusterClient) XLen Uses

❖
func (c ClusterClient) XLen(stream string) *IntCmd

func (ClusterClient) XPending Uses

❖
func (c ClusterClient) XPending(stream, group string) *XPendingCmd

func (ClusterClient) XPendingExt Uses

❖
func (c ClusterClient) XPendingExt(a *XPendingExtArgs) *XPendingExtCmd

func (ClusterClient) XRange Uses

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

func (ClusterClient) XRangeN Uses

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

func (ClusterClient) XRead Uses

❖
func (c ClusterClient) XRead(a *XReadArgs) *XStreamSliceCmd

func (ClusterClient) XReadGroup Uses

❖
func (c ClusterClient) XReadGroup(a *XReadGroupArgs) *XStreamSliceCmd

func (ClusterClient) XReadStreams Uses

❖
func (c ClusterClient) XReadStreams(streams ...string) *XStreamSliceCmd

func (ClusterClient) XRevRange Uses

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

func (ClusterClient) XRevRangeN Uses

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

func (ClusterClient) XTrim Uses

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

func (ClusterClient) XTrimApprox Uses

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

func (ClusterClient) ZAdd Uses

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

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

func (ClusterClient) ZAddCh Uses

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

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

func (ClusterClient) ZAddNX Uses

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

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

func (ClusterClient) ZAddNXCh Uses

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

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

func (ClusterClient) ZAddXX Uses

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

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

func (ClusterClient) ZAddXXCh Uses

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

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

func (ClusterClient) ZCard Uses

❖
func (c ClusterClient) ZCard(key string) *IntCmd

func (ClusterClient) ZCount Uses

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

func (ClusterClient) ZIncr Uses

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

Redis `ZADD key INCR score member` command.

func (ClusterClient) ZIncrBy Uses

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

func (ClusterClient) ZIncrNX Uses

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

Redis `ZADD key NX INCR score member` command.

func (ClusterClient) ZIncrXX Uses

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

Redis `ZADD key XX INCR score member` command.

func (ClusterClient) ZInterStore Uses

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

func (ClusterClient) ZLexCount Uses

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

func (ClusterClient) ZPopMax Uses

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

func (ClusterClient) ZPopMin Uses

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

func (ClusterClient) ZRange Uses

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

func (ClusterClient) ZRangeByLex Uses

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

func (ClusterClient) ZRangeByScore Uses

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

func (ClusterClient) ZRangeByScoreWithScores Uses

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

func (ClusterClient) ZRangeWithScores Uses

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

func (ClusterClient) ZRank Uses

❖
func (c ClusterClient) ZRank(key, member string) *IntCmd

func (ClusterClient) ZRem Uses

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

func (ClusterClient) ZRemRangeByLex Uses

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

func (ClusterClient) ZRemRangeByRank Uses

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

func (ClusterClient) ZRemRangeByScore Uses

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

func (ClusterClient) ZRevRange Uses

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

func (ClusterClient) ZRevRangeByLex Uses

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

func (ClusterClient) ZRevRangeByScore Uses

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

func (ClusterClient) ZRevRangeByScoreWithScores Uses

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

func (ClusterClient) ZRevRangeWithScores Uses

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

func (ClusterClient) ZRevRank Uses

❖
func (c ClusterClient) ZRevRank(key, member string) *IntCmd

func (ClusterClient) ZScan Uses

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

func (ClusterClient) ZScore Uses

❖
func (c ClusterClient) ZScore(key, member string) *FloatCmd

func (ClusterClient) ZUnionStore Uses

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

type ClusterNode Uses

❖
type ClusterNode struct {
    ID   string
    Addr string
}

type ClusterOptions Uses

❖
type ClusterOptions struct {
    // A seed list of host:port addresses of cluster nodes.
    Addrs []string

    // The maximum number of retries before giving up. Command is retried
    // on network errors and MOVED/ASK redirects.
    // Default is 8 retries.
    MaxRedirects int

    // Enables read-only commands on slave nodes.
    ReadOnly bool
    // Allows routing read-only commands to the closest master or slave node.
    // It automatically enables ReadOnly.
    RouteByLatency bool
    // Allows routing read-only commands to the random master or slave node.
    // It automatically enables ReadOnly.
    RouteRandomly bool

    // Optional function that returns cluster slots information.
    // It is useful to manually create cluster of standalone Redis servers
    // and load-balance read/write operations between master and slaves.
    // It can use service like ZooKeeper to maintain configuration information
    // and Cluster.ReloadState to manually trigger state reloading.
    ClusterSlots func() ([]ClusterSlot, error)

    // Optional hook that is called when a new node is created.
    OnNewNode func(*Client)

    Dialer func(ctx context.Context, network, addr string) (net.Conn, error)

    OnConnect func(*Conn) error

    Password string

    MaxRetries      int
    MinRetryBackoff time.Duration
    MaxRetryBackoff time.Duration

    DialTimeout  time.Duration
    ReadTimeout  time.Duration
    WriteTimeout time.Duration

    // PoolSize applies per cluster node and not for the whole cluster.
    PoolSize           int
    MinIdleConns       int
    MaxConnAge         time.Duration
    PoolTimeout        time.Duration
    IdleTimeout        time.Duration
    IdleCheckFrequency time.Duration

    TLSConfig *tls.Config
}

ClusterOptions are used to configure a cluster client and should be passed to NewClusterClient.

type ClusterSlot Uses

❖
type ClusterSlot struct {
    Start int
    End   int
    Nodes []ClusterNode
}

type ClusterSlotsCmd Uses

❖
type ClusterSlotsCmd struct {
    // contains filtered or unexported fields
}

func NewClusterSlotsCmd Uses

❖
func NewClusterSlotsCmd(args ...interface{}) *ClusterSlotsCmd

func NewClusterSlotsCmdResult Uses

❖
func NewClusterSlotsCmdResult(val []ClusterSlot, err error) *ClusterSlotsCmd

NewClusterSlotsCmdResult returns a ClusterSlotsCmd initialised with val and err for testing

func (*ClusterSlotsCmd) Args Uses

❖
func (cmd *ClusterSlotsCmd) Args() []interface{}

func (*ClusterSlotsCmd) Err Uses

❖
func (cmd *ClusterSlotsCmd) Err() error

func (*ClusterSlotsCmd) Name Uses

❖
func (cmd *ClusterSlotsCmd) Name() string

func (*ClusterSlotsCmd) Result Uses

❖
func (cmd *ClusterSlotsCmd) Result() ([]ClusterSlot, error)

func (*ClusterSlotsCmd) SetErr Uses

❖
func (cmd *ClusterSlotsCmd) SetErr(e error)

func (*ClusterSlotsCmd) String Uses

❖
func (cmd *ClusterSlotsCmd) String() string

func (*ClusterSlotsCmd) Val Uses

❖
func (cmd *ClusterSlotsCmd) Val() []ClusterSlot

type Cmd Uses

❖
type Cmd struct {
    // contains filtered or unexported fields
}

func NewCmd Uses

❖
func NewCmd(args ...interface{}) *Cmd

func NewCmdResult Uses

❖
func NewCmdResult(val interface{}, err error) *Cmd

NewCmdResult returns a Cmd initialised with val and err for testing

func (*Cmd) Args Uses

❖
func (cmd *Cmd) Args() []interface{}

func (*Cmd) Bool Uses

❖
func (cmd *Cmd) Bool() (bool, error)

func (*Cmd) Err Uses

❖
func (cmd *Cmd) Err() error

func (*Cmd) Float32 Uses

❖
func (cmd *Cmd) Float32() (float32, error)

func (*Cmd) Float64 Uses

❖
func (cmd *Cmd) Float64() (float64, error)

func (*Cmd) Int Uses

❖
func (cmd *Cmd) Int() (int, error)

func (*Cmd) Int64 Uses

❖
func (cmd *Cmd) Int64() (int64, error)

func (*Cmd) Name Uses

❖
func (cmd *Cmd) Name() string

func (*Cmd) Result Uses

❖
func (cmd *Cmd) Result() (interface{}, error)

func (*Cmd) SetErr Uses

❖
func (cmd *Cmd) SetErr(e error)

func (*Cmd) String Uses

❖
func (cmd *Cmd) String() string

func (*Cmd) Text Uses

❖
func (cmd *Cmd) Text() (string, error)

func (*Cmd) Uint64 Uses

❖
func (cmd *Cmd) Uint64() (uint64, error)

func (*Cmd) Val Uses

❖
func (cmd *Cmd) Val() interface{}

type Cmdable Uses

❖
type Cmdable interface {
    Pipeline() Pipeliner
    Pipelined(fn func(Pipeliner) error) ([]Cmder, error)

    TxPipelined(fn func(Pipeliner) error) ([]Cmder, error)
    TxPipeline() Pipeliner

    Command() *CommandsInfoCmd
    ClientGetName() *StringCmd
    Echo(message interface{}) *StringCmd
    Ping() *StatusCmd
    Quit() *StatusCmd
    Del(keys ...string) *IntCmd
    Unlink(keys ...string) *IntCmd
    Dump(key string) *StringCmd
    Exists(keys ...string) *IntCmd
    Expire(key string, expiration time.Duration) *BoolCmd
    ExpireAt(key string, tm time.Time) *BoolCmd
    Keys(pattern string) *StringSliceCmd
    Migrate(host, port, key string, db int, timeout time.Duration) *StatusCmd
    Move(key string, db int) *BoolCmd
    ObjectRefCount(key string) *IntCmd
    ObjectEncoding(key string) *StringCmd
    ObjectIdleTime(key string) *DurationCmd
    Persist(key string) *BoolCmd
    PExpire(key string, expiration time.Duration) *BoolCmd
    PExpireAt(key string, tm time.Time) *BoolCmd
    PTTL(key string) *DurationCmd
    RandomKey() *StringCmd
    Rename(key, newkey string) *StatusCmd
    RenameNX(key, newkey string) *BoolCmd
    Restore(key string, ttl time.Duration, value string) *StatusCmd
    RestoreReplace(key string, ttl time.Duration, value string) *StatusCmd
    Sort(key string, sort *Sort) *StringSliceCmd
    SortStore(key, store string, sort *Sort) *IntCmd
    SortInterfaces(key string, sort *Sort) *SliceCmd
    Touch(keys ...string) *IntCmd
    TTL(key string) *DurationCmd
    Type(key string) *StatusCmd
    Scan(cursor uint64, match string, count int64) *ScanCmd
    SScan(key string, cursor uint64, match string, count int64) *ScanCmd
    HScan(key string, cursor uint64, match string, count int64) *ScanCmd
    ZScan(key string, cursor uint64, match string, count int64) *ScanCmd
    Append(key, value string) *IntCmd
    BitCount(key string, bitCount *BitCount) *IntCmd
    BitOpAnd(destKey string, keys ...string) *IntCmd
    BitOpOr(destKey string, keys ...string) *IntCmd
    BitOpXor(destKey string, keys ...string) *IntCmd
    BitOpNot(destKey string, key string) *IntCmd
    BitPos(key string, bit int64, pos ...int64) *IntCmd
    BitField(key string, args ...interface{}) *IntSliceCmd
    Decr(key string) *IntCmd
    DecrBy(key string, decrement int64) *IntCmd
    Get(key string) *StringCmd
    GetBit(key string, offset int64) *IntCmd
    GetRange(key string, start, end int64) *StringCmd
    GetSet(key string, value interface{}) *StringCmd
    Incr(key string) *IntCmd
    IncrBy(key string, value int64) *IntCmd
    IncrByFloat(key string, value float64) *FloatCmd
    MGet(keys ...string) *SliceCmd
    MSet(values ...interface{}) *StatusCmd
    MSetNX(values ...interface{}) *BoolCmd
    Set(key string, value interface{}, expiration time.Duration) *StatusCmd
    SetBit(key string, offset int64, value int) *IntCmd
    SetNX(key string, value interface{}, expiration time.Duration) *BoolCmd
    SetXX(key string, value interface{}, expiration time.Duration) *BoolCmd
    SetRange(key string, offset int64, value string) *IntCmd
    StrLen(key string) *IntCmd
    HDel(key string, fields ...string) *IntCmd
    HExists(key, field string) *BoolCmd
    HGet(key, field string) *StringCmd
    HGetAll(key string) *StringStringMapCmd
    HIncrBy(key, field string, incr int64) *IntCmd
    HIncrByFloat(key, field string, incr float64) *FloatCmd
    HKeys(key string) *StringSliceCmd
    HLen(key string) *IntCmd
    HMGet(key string, fields ...string) *SliceCmd
    HMSet(key string, values ...interface{}) *IntCmd
    HSet(key, field string, value interface{}) *BoolCmd
    HSetNX(key, field string, value interface{}) *BoolCmd
    HVals(key string) *StringSliceCmd
    BLPop(timeout time.Duration, keys ...string) *StringSliceCmd
    BRPop(timeout time.Duration, keys ...string) *StringSliceCmd
    BRPopLPush(source, destination string, timeout time.Duration) *StringCmd
    LIndex(key string, index int64) *StringCmd
    LInsert(key, op string, pivot, value interface{}) *IntCmd
    LInsertBefore(key string, pivot, value interface{}) *IntCmd
    LInsertAfter(key string, pivot, value interface{}) *IntCmd
    LLen(key string) *IntCmd
    LPop(key string) *StringCmd
    LPush(key string, values ...interface{}) *IntCmd
    LPushX(key string, values ...interface{}) *IntCmd
    LRange(key string, start, stop int64) *StringSliceCmd
    LRem(key string, count int64, value interface{}) *IntCmd
    LSet(key string, index int64, value interface{}) *StatusCmd
    LTrim(key string, start, stop int64) *StatusCmd
    RPop(key string) *StringCmd
    RPopLPush(source, destination string) *StringCmd
    RPush(key string, values ...interface{}) *IntCmd
    RPushX(key string, values ...interface{}) *IntCmd
    SAdd(key string, members ...interface{}) *IntCmd
    SCard(key string) *IntCmd
    SDiff(keys ...string) *StringSliceCmd
    SDiffStore(destination string, keys ...string) *IntCmd
    SInter(keys ...string) *StringSliceCmd
    SInterStore(destination string, keys ...string) *IntCmd
    SIsMember(key string, member interface{}) *BoolCmd
    SMembers(key string) *StringSliceCmd
    SMembersMap(key string) *StringStructMapCmd
    SMove(source, destination string, member interface{}) *BoolCmd
    SPop(key string) *StringCmd
    SPopN(key string, count int64) *StringSliceCmd
    SRandMember(key string) *StringCmd
    SRandMemberN(key string, count int64) *StringSliceCmd
    SRem(key string, members ...interface{}) *IntCmd
    SUnion(keys ...string) *StringSliceCmd
    SUnionStore(destination string, keys ...string) *IntCmd
    XAdd(a *XAddArgs) *StringCmd
    XDel(stream string, ids ...string) *IntCmd
    XLen(stream string) *IntCmd
    XRange(stream, start, stop string) *XMessageSliceCmd
    XRangeN(stream, start, stop string, count int64) *XMessageSliceCmd
    XRevRange(stream string, start, stop string) *XMessageSliceCmd
    XRevRangeN(stream string, start, stop string, count int64) *XMessageSliceCmd
    XRead(a *XReadArgs) *XStreamSliceCmd
    XReadStreams(streams ...string) *XStreamSliceCmd
    XGroupCreate(stream, group, start string) *StatusCmd
    XGroupCreateMkStream(stream, group, start string) *StatusCmd
    XGroupSetID(stream, group, start string) *StatusCmd
    XGroupDestroy(stream, group string) *IntCmd
    XGroupDelConsumer(stream, group, consumer string) *IntCmd
    XReadGroup(a *XReadGroupArgs) *XStreamSliceCmd
    XAck(stream, group string, ids ...string) *IntCmd
    XPending(stream, group string) *XPendingCmd
    XPendingExt(a *XPendingExtArgs) *XPendingExtCmd
    XClaim(a *XClaimArgs) *XMessageSliceCmd
    XClaimJustID(a *XClaimArgs) *StringSliceCmd
    XTrim(key string, maxLen int64) *IntCmd
    XTrimApprox(key string, maxLen int64) *IntCmd
    XInfoGroups(key string) *XInfoGroupsCmd
    BZPopMax(timeout time.Duration, keys ...string) *ZWithKeyCmd
    BZPopMin(timeout time.Duration, keys ...string) *ZWithKeyCmd
    ZAdd(key string, members ...*Z) *IntCmd
    ZAddNX(key string, members ...*Z) *IntCmd
    ZAddXX(key string, members ...*Z) *IntCmd
    ZAddCh(key string, members ...*Z) *IntCmd
    ZAddNXCh(key string, members ...*Z) *IntCmd
    ZAddXXCh(key string, members ...*Z) *IntCmd
    ZIncr(key string, member *Z) *FloatCmd
    ZIncrNX(key string, member *Z) *FloatCmd
    ZIncrXX(key string, member *Z) *FloatCmd
    ZCard(key string) *IntCmd
    ZCount(key, min, max string) *IntCmd
    ZLexCount(key, min, max string) *IntCmd
    ZIncrBy(key string, increment float64, member string) *FloatCmd
    ZInterStore(destination string, store *ZStore) *IntCmd
    ZPopMax(key string, count ...int64) *ZSliceCmd
    ZPopMin(key string, count ...int64) *ZSliceCmd
    ZRange(key string, start, stop int64) *StringSliceCmd
    ZRangeWithScores(key string, start, stop int64) *ZSliceCmd
    ZRangeByScore(key string, opt *ZRangeBy) *StringSliceCmd
    ZRangeByLex(key string, opt *ZRangeBy) *StringSliceCmd
    ZRangeByScoreWithScores(key string, opt *ZRangeBy) *ZSliceCmd
    ZRank(key, member string) *IntCmd
    ZRem(key string, members ...interface{}) *IntCmd
    ZRemRangeByRank(key string, start, stop int64) *IntCmd
    ZRemRangeByScore(key, min, max string) *IntCmd
    ZRemRangeByLex(key, min, max string) *IntCmd
    ZRevRange(key string, start, stop int64) *StringSliceCmd
    ZRevRangeWithScores(key string, start, stop int64) *ZSliceCmd
    ZRevRangeByScore(key string, opt *ZRangeBy) *StringSliceCmd
    ZRevRangeByLex(key string, opt *ZRangeBy) *StringSliceCmd
    ZRevRangeByScoreWithScores(key string, opt *ZRangeBy) *ZSliceCmd
    ZRevRank(key, member string) *IntCmd
    ZScore(key, member string) *FloatCmd
    ZUnionStore(dest string, store *ZStore) *IntCmd
    PFAdd(key string, els ...interface{}) *IntCmd
    PFCount(keys ...string) *IntCmd
    PFMerge(dest string, keys ...string) *StatusCmd
    BgRewriteAOF() *StatusCmd
    BgSave() *StatusCmd
    ClientKill(ipPort string) *StatusCmd
    ClientKillByFilter(keys ...string) *IntCmd
    ClientList() *StringCmd
    ClientPause(dur time.Duration) *BoolCmd
    ClientID() *IntCmd
    ConfigGet(parameter string) *SliceCmd
    ConfigResetStat() *StatusCmd
    ConfigSet(parameter, value string) *StatusCmd
    ConfigRewrite() *StatusCmd
    DBSize() *IntCmd
    FlushAll() *StatusCmd
    FlushAllAsync() *StatusCmd
    FlushDB() *StatusCmd
    FlushDBAsync() *StatusCmd
    Info(section ...string) *StringCmd
    LastSave() *IntCmd
    Save() *StatusCmd
    Shutdown() *StatusCmd
    ShutdownSave() *StatusCmd
    ShutdownNoSave() *StatusCmd
    SlaveOf(host, port string) *StatusCmd
    Time() *TimeCmd
    Eval(script string, keys []string, args ...interface{}) *Cmd
    EvalSha(sha1 string, keys []string, args ...interface{}) *Cmd
    ScriptExists(hashes ...string) *BoolSliceCmd
    ScriptFlush() *StatusCmd
    ScriptKill() *StatusCmd
    ScriptLoad(script string) *StringCmd
    DebugObject(key string) *StringCmd
    Publish(channel string, message interface{}) *IntCmd
    PubSubChannels(pattern string) *StringSliceCmd
    PubSubNumSub(channels ...string) *StringIntMapCmd
    PubSubNumPat() *IntCmd
    ClusterSlots() *ClusterSlotsCmd
    ClusterNodes() *StringCmd
    ClusterMeet(host, port string) *StatusCmd
    ClusterForget(nodeID string) *StatusCmd
    ClusterReplicate(nodeID string) *StatusCmd
    ClusterResetSoft() *StatusCmd
    ClusterResetHard() *StatusCmd
    ClusterInfo() *StringCmd
    ClusterKeySlot(key string) *IntCmd
    ClusterGetKeysInSlot(slot int, count int) *StringSliceCmd
    ClusterCountFailureReports(nodeID string) *IntCmd
    ClusterCountKeysInSlot(slot int) *IntCmd
    ClusterDelSlots(slots ...int) *StatusCmd
    ClusterDelSlotsRange(min, max int) *StatusCmd
    ClusterSaveConfig() *StatusCmd
    ClusterSlaves(nodeID string) *StringSliceCmd
    ClusterFailover() *StatusCmd
    ClusterAddSlots(slots ...int) *StatusCmd
    ClusterAddSlotsRange(min, max int) *StatusCmd
    GeoAdd(key string, geoLocation ...*GeoLocation) *IntCmd
    GeoPos(key string, members ...string) *GeoPosCmd
    GeoRadius(key string, longitude, latitude float64, query *GeoRadiusQuery) *GeoLocationCmd
    GeoRadiusStore(key string, longitude, latitude float64, query *GeoRadiusQuery) *IntCmd
    GeoRadiusByMember(key, member string, query *GeoRadiusQuery) *GeoLocationCmd
    GeoRadiusByMemberStore(key, member string, query *GeoRadiusQuery) *IntCmd
    GeoDist(key string, member1, member2, unit string) *FloatCmd
    GeoHash(key string, members ...string) *StringSliceCmd
    ReadOnly() *StatusCmd
    ReadWrite() *StatusCmd
    MemoryUsage(key string, samples ...int) *IntCmd
}

type Cmder Uses

❖
type Cmder interface {
    Name() string
    Args() []interface{}
    String() string

    SetErr(error)
    Err() error
    // contains filtered or unexported methods
}

type CommandInfo Uses

❖
type CommandInfo struct {
    Name        string
    Arity       int8
    Flags       []string
    FirstKeyPos int8
    LastKeyPos  int8
    StepCount   int8
    ReadOnly    bool
}

type CommandsInfoCmd Uses

❖
type CommandsInfoCmd struct {
    // contains filtered or unexported fields
}

func NewCommandsInfoCmd Uses

❖
func NewCommandsInfoCmd(args ...interface{}) *CommandsInfoCmd

func NewCommandsInfoCmdResult Uses

❖
func NewCommandsInfoCmdResult(val map[string]*CommandInfo, err error) *CommandsInfoCmd

NewCommandsInfoCmdResult returns a CommandsInfoCmd initialised with val and err for testing

func (*CommandsInfoCmd) Args Uses

❖
func (cmd *CommandsInfoCmd) Args() []interface{}

func (*CommandsInfoCmd) Err Uses

❖
func (cmd *CommandsInfoCmd) Err() error

func (*CommandsInfoCmd) Name Uses

❖
func (cmd *CommandsInfoCmd) Name() string

func (*CommandsInfoCmd) Result Uses

❖
func (cmd *CommandsInfoCmd) Result() (map[string]*CommandInfo, error)

func (*CommandsInfoCmd) SetErr Uses

❖
func (cmd *CommandsInfoCmd) SetErr(e error)

func (*CommandsInfoCmd) String Uses

❖
func (cmd *CommandsInfoCmd) String() string

func (*CommandsInfoCmd) Val Uses

❖
func (cmd *CommandsInfoCmd) Val() map[string]*CommandInfo

type Conn Uses

❖
type Conn struct {
    // contains filtered or unexported fields
}

Conn is like Client, but its pool contains single connection.

Example

Code: 

conn := rdb.Conn()

err := conn.ClientSetName("foobar").Err()
if err != nil {
    panic(err)
}

// Open other connections.
for i := 0; i < 10; i++ {
    go rdb.Ping()
}

s, err := conn.ClientGetName().Result()
if err != nil {
    panic(err)
}
fmt.Println(s)

Output:

foobar

func (*Conn) Pipeline Uses

❖
func (c *Conn) Pipeline() Pipeliner

func (*Conn) Pipelined Uses

❖
func (c *Conn) Pipelined(fn func(Pipeliner) error) ([]Cmder, error)

func (*Conn) Process Uses

❖
func (c *Conn) Process(cmd Cmder) error

func (*Conn) ProcessContext Uses

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

func (*Conn) TxPipeline Uses

❖
func (c *Conn) TxPipeline() Pipeliner

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

func (*Conn) TxPipelined Uses

❖
func (c *Conn) TxPipelined(fn func(Pipeliner) error) ([]Cmder, error)

type DurationCmd Uses

❖
type DurationCmd struct {
    // contains filtered or unexported fields
}

func NewDurationCmd Uses

❖
func NewDurationCmd(precision time.Duration, args ...interface{}) *DurationCmd

func NewDurationResult Uses

❖
func NewDurationResult(val time.Duration, err error) *DurationCmd

NewDurationResult returns a DurationCmd initialised with val and err for testing

func (*DurationCmd) Args Uses

❖
func (cmd *DurationCmd) Args() []interface{}

func (*DurationCmd) Err Uses

❖
func (cmd *DurationCmd) Err() error

func (*DurationCmd) Name Uses

❖
func (cmd *DurationCmd) Name() string

func (*DurationCmd) Result Uses

❖
func (cmd *DurationCmd) Result() (time.Duration, error)

func (*DurationCmd) SetErr Uses

❖
func (cmd *DurationCmd) SetErr(e error)

func (*DurationCmd) String Uses

❖
func (cmd *DurationCmd) String() string

func (*DurationCmd) Val Uses

❖
func (cmd *DurationCmd) Val() time.Duration

type FailoverOptions Uses

❖
type FailoverOptions struct {
    // The master name.
    MasterName string
    // A seed list of host:port addresses of sentinel nodes.
    SentinelAddrs    []string
    SentinelPassword string

    Dialer    func(ctx context.Context, network, addr string) (net.Conn, error)
    OnConnect func(*Conn) error

    Password string
    DB       int

    MaxRetries      int
    MinRetryBackoff time.Duration
    MaxRetryBackoff time.Duration

    DialTimeout  time.Duration
    ReadTimeout  time.Duration
    WriteTimeout time.Duration

    PoolSize           int
    MinIdleConns       int
    MaxConnAge         time.Duration
    PoolTimeout        time.Duration
    IdleTimeout        time.Duration
    IdleCheckFrequency time.Duration

    TLSConfig *tls.Config
}

FailoverOptions are used to configure a failover client and should be passed to NewFailoverClient.

type FloatCmd Uses

❖
type FloatCmd struct {
    // contains filtered or unexported fields
}

func NewFloatCmd Uses

❖
func NewFloatCmd(args ...interface{}) *FloatCmd

func NewFloatResult Uses

❖
func NewFloatResult(val float64, err error) *FloatCmd

NewFloatResult returns a FloatCmd initialised with val and err for testing

func (*FloatCmd) Args Uses

❖
func (cmd *FloatCmd) Args() []interface{}

func (*FloatCmd) Err Uses

❖
func (cmd *FloatCmd) Err() error

func (*FloatCmd) Name Uses

❖
func (cmd *FloatCmd) Name() string

func (*FloatCmd) Result Uses

❖
func (cmd *FloatCmd) Result() (float64, error)

func (*FloatCmd) SetErr Uses

❖
func (cmd *FloatCmd) SetErr(e error)

func (*FloatCmd) String Uses

❖
func (cmd *FloatCmd) String() string

func (*FloatCmd) Val Uses

❖
func (cmd *FloatCmd) Val() float64

type GeoLocation Uses

❖
type GeoLocation struct {
    Name                      string
    Longitude, Latitude, Dist float64
    GeoHash                   int64
}

GeoLocation is used with GeoAdd to add geospatial location.

type GeoLocationCmd Uses

❖
type GeoLocationCmd struct {
    // contains filtered or unexported fields
}

func NewGeoLocationCmd Uses

❖
func NewGeoLocationCmd(q *GeoRadiusQuery, args ...interface{}) *GeoLocationCmd

func NewGeoLocationCmdResult Uses

❖
func NewGeoLocationCmdResult(val []GeoLocation, err error) *GeoLocationCmd

NewGeoLocationCmdResult returns a GeoLocationCmd initialised with val and err for testing

func (*GeoLocationCmd) Args Uses

❖
func (cmd *GeoLocationCmd) Args() []interface{}

func (*GeoLocationCmd) Err Uses

❖
func (cmd *GeoLocationCmd) Err() error

func (*GeoLocationCmd) Name Uses

❖
func (cmd *GeoLocationCmd) Name() string

func (*GeoLocationCmd) Result Uses

❖
func (cmd *GeoLocationCmd) Result() ([]GeoLocation, error)

func (*GeoLocationCmd) SetErr Uses

❖
func (cmd *GeoLocationCmd) SetErr(e error)

func (*GeoLocationCmd) String Uses

❖
func (cmd *GeoLocationCmd) String() string

func (*GeoLocationCmd) Val Uses

❖
func (cmd *GeoLocationCmd) Val() []GeoLocation

type GeoPos Uses

❖
type GeoPos struct {
    Longitude, Latitude float64
}

type GeoPosCmd Uses

❖
type GeoPosCmd struct {
    // contains filtered or unexported fields
}

func NewGeoPosCmd Uses

❖
func NewGeoPosCmd(args ...interface{}) *GeoPosCmd

func NewGeoPosCmdResult Uses

❖
func NewGeoPosCmdResult(val []*GeoPos, err error) *GeoPosCmd

NewGeoPosCmdResult returns a GeoPosCmd initialised with val and err for testing

func (*GeoPosCmd) Args Uses

❖
func (cmd *GeoPosCmd) Args() []interface{}

func (*GeoPosCmd) Err Uses

❖
func (cmd *GeoPosCmd) Err() error

func (*GeoPosCmd) Name Uses

❖
func (cmd *GeoPosCmd) Name() string

func (*GeoPosCmd) Result Uses

❖
func (cmd *GeoPosCmd) Result() ([]*GeoPos, error)

func (*GeoPosCmd) SetErr Uses

❖
func (cmd *GeoPosCmd) SetErr(e error)

func (*GeoPosCmd) String Uses

❖
func (cmd *GeoPosCmd) String() string

func (*GeoPosCmd) Val Uses

❖
func (cmd *GeoPosCmd) Val() []*GeoPos

type GeoRadiusQuery Uses

❖
type GeoRadiusQuery struct {
    Radius float64
    // Can be m, km, ft, or mi. Default is km.
    Unit        string
    WithCoord   bool
    WithDist    bool
    WithGeoHash bool
    Count       int
    // Can be ASC or DESC. Default is no sort order.
    Sort      string
    Store     string
    StoreDist string
}

GeoRadiusQuery is used with GeoRadius to query geospatial index.

type Hash Uses

❖
type Hash consistenthash.Hash

Hash is type of hash function used in consistent hash.

type Hook Uses

❖
type Hook interface {
    BeforeProcess(ctx context.Context, cmd Cmder) (context.Context, error)
    AfterProcess(ctx context.Context, cmd Cmder) error

    BeforeProcessPipeline(ctx context.Context, cmds []Cmder) (context.Context, error)
    AfterProcessPipeline(ctx context.Context, cmds []Cmder) error
}

type IntCmd Uses

❖
type IntCmd struct {
    // contains filtered or unexported fields
}

func NewIntCmd Uses

❖
func NewIntCmd(args ...interface{}) *IntCmd

func NewIntResult Uses

❖
func NewIntResult(val int64, err error) *IntCmd

NewIntResult returns an IntCmd initialised with val and err for testing

func (*IntCmd) Args Uses

❖
func (cmd *IntCmd) Args() []interface{}

func (*IntCmd) Err Uses

❖
func (cmd *IntCmd) Err() error

func (*IntCmd) Name Uses

❖
func (cmd *IntCmd) Name() string

func (*IntCmd) Result Uses

❖
func (cmd *IntCmd) Result() (int64, error)

func (*IntCmd) SetErr Uses

❖
func (cmd *IntCmd) SetErr(e error)

func (*IntCmd) String Uses

❖
func (cmd *IntCmd) String() string

func (*IntCmd) Uint64 Uses

❖
func (cmd *IntCmd) Uint64() (uint64, error)

func (*IntCmd) Val Uses

❖
func (cmd *IntCmd) Val() int64

type IntSliceCmd Uses

❖
type IntSliceCmd struct {
    // contains filtered or unexported fields
}

func NewIntSliceCmd Uses

❖
func NewIntSliceCmd(args ...interface{}) *IntSliceCmd

func (*IntSliceCmd) Args Uses

❖
func (cmd *IntSliceCmd) Args() []interface{}

func (*IntSliceCmd) Err Uses

❖
func (cmd *IntSliceCmd) Err() error

func (*IntSliceCmd) Name Uses

❖
func (cmd *IntSliceCmd) Name() string

func (*IntSliceCmd) Result Uses

❖
func (cmd *IntSliceCmd) Result() ([]int64, error)

func (*IntSliceCmd) SetErr Uses

❖
func (cmd *IntSliceCmd) SetErr(e error)

func (*IntSliceCmd) String Uses

❖
func (cmd *IntSliceCmd) String() string

func (*IntSliceCmd) Val Uses

❖
func (cmd *IntSliceCmd) Val() []int64

type Limiter Uses

❖
type Limiter interface {
    // Allow returns nil if operation is allowed or an error otherwise.
    // If operation is allowed client must ReportResult of the operation
    // whether it is a success or a failure.
    Allow() error
    // ReportResult reports the result of the previously allowed operation.
    // nil indicates a success, non-nil error usually indicates a failure.
    ReportResult(result error)
}

Limiter is the interface of a rate limiter or a circuit breaker.

type Message Uses

❖
type Message struct {
    Channel string
    Pattern string
    Payload string
}

Message received as result of a PUBLISH command issued by another client.

func (*Message) String Uses

❖
func (m *Message) String() string

type Options Uses

❖
type Options struct {
    // The network type, either tcp or unix.
    // Default is tcp.
    Network string
    // host:port address.
    Addr string

    // Dialer creates new network connection and has priority over
    // Network and Addr options.
    Dialer func(ctx context.Context, network, addr string) (net.Conn, error)

    // Hook that is called when new connection is established.
    OnConnect func(*Conn) error

    // Optional password. Must match the password specified in the
    // requirepass server configuration option.
    Password string
    // Database to be selected after connecting to the server.
    DB  int

    // Maximum number of retries before giving up.
    // Default is to not retry failed commands.
    MaxRetries int
    // Minimum backoff between each retry.
    // Default is 8 milliseconds; -1 disables backoff.
    MinRetryBackoff time.Duration
    // Maximum backoff between each retry.
    // Default is 512 milliseconds; -1 disables backoff.
    MaxRetryBackoff time.Duration

    // Dial timeout for establishing new connections.
    // Default is 5 seconds.
    DialTimeout time.Duration
    // Timeout for socket reads. If reached, commands will fail
    // with a timeout instead of blocking. Use value -1 for no timeout and 0 for default.
    // Default is 3 seconds.
    ReadTimeout time.Duration
    // Timeout for socket writes. If reached, commands will fail
    // with a timeout instead of blocking.
    // Default is ReadTimeout.
    WriteTimeout time.Duration

    // Maximum number of socket connections.
    // Default is 10 connections per every CPU as reported by runtime.NumCPU.
    PoolSize int
    // Minimum number of idle connections which is useful when establishing
    // new connection is slow.
    MinIdleConns int
    // Connection age at which client retires (closes) the connection.
    // Default is to not close aged connections.
    MaxConnAge time.Duration
    // Amount of time client waits for connection if all connections
    // are busy before returning an error.
    // Default is ReadTimeout + 1 second.
    PoolTimeout time.Duration
    // Amount of time after which client closes idle connections.
    // Should be less than server's timeout.
    // Default is 5 minutes. -1 disables idle timeout check.
    IdleTimeout time.Duration
    // Frequency of idle checks made by idle connections reaper.
    // Default is 1 minute. -1 disables idle connections reaper,
    // but idle connections are still discarded by the client
    // if IdleTimeout is set.
    IdleCheckFrequency time.Duration

    // TLS Config to use. When set TLS will be negotiated.
    TLSConfig *tls.Config

    // Limiter interface used to implemented circuit breaker or rate limiter.
    Limiter Limiter
    // contains filtered or unexported fields
}

func ParseURL Uses

❖
func ParseURL(redisURL string) (*Options, error)

ParseURL parses an URL into Options that can be used to connect to Redis.

Example

Code: 

opt, err := redis.ParseURL("redis://:qwerty@localhost:6379/1")
if err != nil {
    panic(err)
}
fmt.Println("addr is", opt.Addr)
fmt.Println("db is", opt.DB)
fmt.Println("password is", opt.Password)

// Create client as usually.
_ = redis.NewClient(opt)

Output:

addr is localhost:6379
db is 1
password is qwerty

type Pipeline Uses

❖
type Pipeline struct {
    // contains filtered or unexported fields
}

Pipeline implements pipelining as described in http://redis.io/topics/pipelining. It's safe for concurrent use by multiple goroutines.

Example (Instrumentation)

Code: 

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

rdb.Pipelined(func(pipe redis.Pipeliner) error {
    pipe.Ping()
    pipe.Ping()
    return nil
})

Output:

pipeline starting processing: [ping:  ping: ]
pipeline finished processing: [ping: PONG ping: PONG]

func (Pipeline) Append Uses

❖
func (c Pipeline) Append(key, value string) *IntCmd

func (Pipeline) Auth Uses

❖
func (c Pipeline) Auth(password string) *StatusCmd

func (Pipeline) BLPop Uses

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

func (Pipeline) BRPop Uses

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

func (Pipeline) BRPopLPush Uses

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

func (Pipeline) BZPopMax Uses

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

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

func (Pipeline) BZPopMin Uses

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

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

func (Pipeline) BgRewriteAOF Uses

❖
func (c Pipeline) BgRewriteAOF() *StatusCmd

func (Pipeline) BgSave Uses

❖
func (c Pipeline) BgSave() *StatusCmd

func (Pipeline) BitCount Uses

❖
func (c Pipeline) BitCount(key string, bitCount *BitCount) *IntCmd

func (Pipeline) BitField Uses

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

func (Pipeline) BitOpAnd Uses

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

func (Pipeline) BitOpNot Uses

❖
func (c Pipeline) BitOpNot(destKey string, key string) *IntCmd

func (Pipeline) BitOpOr Uses

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

func (Pipeline) BitOpXor Uses

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

func (Pipeline) BitPos Uses

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

func (Pipeline) ClientGetName Uses

❖
func (c Pipeline) ClientGetName() *StringCmd

ClientGetName returns the name of the connection.

func (Pipeline) ClientID Uses

❖
func (c Pipeline) ClientID() *IntCmd

func (Pipeline) ClientKill Uses

❖
func (c Pipeline) ClientKill(ipPort string) *StatusCmd

func (Pipeline) ClientKillByFilter Uses

❖
func (c Pipeline) ClientKillByFilter(keys ...string) *IntCmd

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

func (Pipeline) ClientList Uses

❖
func (c Pipeline) ClientList() *StringCmd

func (Pipeline) ClientPause Uses

❖
func (c Pipeline) ClientPause(dur time.Duration) *BoolCmd

func (Pipeline) ClientSetName Uses

❖
func (c Pipeline) ClientSetName(name string) *BoolCmd

ClientSetName assigns a name to the connection.

func (Pipeline) ClientUnblock Uses

❖
func (c Pipeline) ClientUnblock(id int64) *IntCmd

func (Pipeline) ClientUnblockWithError Uses

❖
func (c Pipeline) ClientUnblockWithError(id int64) *IntCmd

func (*Pipeline) Close Uses

❖
func (c *Pipeline) Close() error

Close closes the pipeline, releasing any open resources.

func (Pipeline) ClusterAddSlots Uses

❖
func (c Pipeline) ClusterAddSlots(slots ...int) *StatusCmd

func (Pipeline) ClusterAddSlotsRange Uses

❖
func (c Pipeline) ClusterAddSlotsRange(min, max int) *StatusCmd

func (Pipeline) ClusterCountFailureReports Uses

❖
func (c Pipeline) ClusterCountFailureReports(nodeID string) *IntCmd

func (Pipeline) ClusterCountKeysInSlot Uses

❖
func (c Pipeline) ClusterCountKeysInSlot(slot int) *IntCmd

func (Pipeline) ClusterDelSlots Uses

❖
func (c Pipeline) ClusterDelSlots(slots ...int) *StatusCmd

func (Pipeline) ClusterDelSlotsRange Uses

❖
func (c Pipeline) ClusterDelSlotsRange(min, max int) *StatusCmd

func (Pipeline) ClusterFailover Uses

❖
func (c Pipeline) ClusterFailover() *StatusCmd

func (Pipeline) ClusterForget Uses

❖
func (c Pipeline) ClusterForget(nodeID string) *StatusCmd

func (Pipeline) ClusterGetKeysInSlot Uses

❖
func (c Pipeline) ClusterGetKeysInSlot(slot int, count int) *StringSliceCmd

func (Pipeline) ClusterInfo Uses

❖
func (c Pipeline) ClusterInfo() *StringCmd

func (Pipeline) ClusterKeySlot Uses

❖
func (c Pipeline) ClusterKeySlot(key string) *IntCmd

func (Pipeline) ClusterMeet Uses

❖
func (c Pipeline) ClusterMeet(host, port string) *StatusCmd

func (Pipeline) ClusterNodes Uses

❖
func (c Pipeline) ClusterNodes() *StringCmd

func (Pipeline) ClusterReplicate Uses

❖
func (c Pipeline) ClusterReplicate(nodeID string) *StatusCmd

func (Pipeline) ClusterResetHard Uses

❖
func (c Pipeline) ClusterResetHard() *StatusCmd

func (Pipeline) ClusterResetSoft Uses

❖
func (c Pipeline) ClusterResetSoft() *StatusCmd

func (Pipeline) ClusterSaveConfig Uses

❖
func (c Pipeline) ClusterSaveConfig() *StatusCmd

func (Pipeline) ClusterSlaves Uses

❖
func (c Pipeline) ClusterSlaves(nodeID string) *StringSliceCmd

func (Pipeline) ClusterSlots Uses

❖
func (c Pipeline) ClusterSlots() *ClusterSlotsCmd

func (Pipeline) Command Uses

❖
func (c Pipeline) Command() *CommandsInfoCmd

func (Pipeline) ConfigGet Uses

❖
func (c Pipeline) ConfigGet(parameter string) *SliceCmd

func (Pipeline) ConfigResetStat Uses

❖
func (c Pipeline) ConfigResetStat() *StatusCmd

func (Pipeline) ConfigRewrite Uses

❖
func (c Pipeline) ConfigRewrite() *StatusCmd

func (Pipeline) ConfigSet Uses

❖
func (c Pipeline) ConfigSet(parameter, value string) *StatusCmd

func (Pipeline) DBSize Uses

❖
func (c Pipeline) DBSize() *IntCmd

func (Pipeline) DbSize Uses

❖
func (c Pipeline) DbSize() *IntCmd

Deperecated. Use DBSize instead.

func (Pipeline) DebugObject Uses

❖
func (c Pipeline) DebugObject(key string) *StringCmd

func (Pipeline) Decr Uses

❖
func (c Pipeline) Decr(key string) *IntCmd

func (Pipeline) DecrBy Uses

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

func (Pipeline) Del Uses

❖
func (c Pipeline) Del(keys ...string) *IntCmd

func (*Pipeline) Discard Uses

❖
func (c *Pipeline) Discard() error

Discard resets the pipeline and discards queued commands.

func (*Pipeline) Do Uses

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

func (Pipeline) Dump Uses

❖
func (c Pipeline) Dump(key string) *StringCmd

func (Pipeline) Echo Uses

❖
func (c Pipeline) Echo(message interface{}) *StringCmd

func (Pipeline) Eval Uses

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

func (Pipeline) EvalSha Uses

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

func (*Pipeline) Exec Uses

❖
func (c *Pipeline) Exec() ([]Cmder, error)

Exec executes all previously queued commands using one client-server roundtrip.

Exec always returns list of commands and error of the first failed command if any.

func (*Pipeline) ExecContext Uses

❖
func (c *Pipeline) ExecContext(ctx context.Context) ([]Cmder, error)

func (Pipeline) Exists Uses

❖
func (c Pipeline) Exists(keys ...string) *IntCmd

func (Pipeline) Expire Uses

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

func (Pipeline) ExpireAt Uses

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

func (Pipeline) FlushAll Uses

❖
func (c Pipeline) FlushAll() *StatusCmd

func (Pipeline) FlushAllAsync Uses

❖
func (c Pipeline) FlushAllAsync() *StatusCmd

func (Pipeline) FlushDB Uses

❖
func (c Pipeline) FlushDB() *StatusCmd

func (Pipeline) FlushDBAsync Uses

❖
func (c Pipeline) FlushDBAsync() *StatusCmd

func (Pipeline) GeoAdd Uses

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

func (Pipeline) GeoDist Uses

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

func (Pipeline) GeoHash Uses

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

func (Pipeline) GeoPos Uses

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

func (Pipeline) GeoRadius Uses

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

GeoRadius is a read-only GEORADIUS_RO command.

func (Pipeline) GeoRadiusByMember Uses

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

GeoRadius is a read-only GEORADIUSBYMEMBER_RO command.

func (Pipeline) GeoRadiusByMemberStore Uses

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

GeoRadiusByMemberStore is a writing GEORADIUSBYMEMBER command.

func (Pipeline) GeoRadiusStore Uses

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

GeoRadiusStore is a writing GEORADIUS command.

func (Pipeline) Get Uses

❖
func (c Pipeline) Get(key string) *StringCmd

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

func (Pipeline) GetBit Uses

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

func (Pipeline) GetRange Uses

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

func (Pipeline) GetSet Uses

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

func (Pipeline) HDel Uses

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

func (Pipeline) HExists Uses

❖
func (c Pipeline) HExists(key, field string) *BoolCmd

func (Pipeline) HGet Uses

❖
func (c Pipeline) HGet(key, field string) *StringCmd

func (Pipeline) HGetAll Uses

❖
func (c Pipeline) HGetAll(key string) *StringStringMapCmd

func (Pipeline) HIncrBy Uses

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

func (Pipeline) HIncrByFloat Uses

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

func (Pipeline) HKeys Uses

❖
func (c Pipeline) HKeys(key string) *StringSliceCmd

func (Pipeline) HLen Uses

❖
func (c Pipeline) HLen(key string) *IntCmd

func (Pipeline) HMGet Uses

❖
func (c Pipeline) 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 (Pipeline) HMSet Uses

❖
func (c Pipeline) HMSet(key string, values ...interface{}) *IntCmd

HMSet is like HSet, but accepts multiple values: 

- 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 uses HSET Redis command underneath because HMSET is deprecated.

func (Pipeline) HScan Uses

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

func (Pipeline) HSet Uses

❖
func (c Pipeline) HSet(key, field string, value interface{}) *BoolCmd

func (Pipeline) HSetNX Uses

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

func (Pipeline) HVals Uses

❖
func (c Pipeline) HVals(key string) *StringSliceCmd

func (Pipeline) Incr Uses

❖
func (c Pipeline) Incr(key string) *IntCmd

func (Pipeline) IncrBy Uses

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

func (Pipeline) IncrByFloat Uses

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

func (Pipeline) Info Uses

❖
func (c Pipeline) Info(section ...string) *StringCmd

func (Pipeline) Keys Uses

❖
func (c Pipeline) Keys(pattern string) *StringSliceCmd

func (Pipeline) LIndex Uses

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

func (Pipeline) LInsert Uses

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

func (Pipeline) LInsertAfter Uses

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

func (Pipeline) LInsertBefore Uses

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

func (Pipeline) LLen Uses

❖
func (c Pipeline) LLen(key string) *IntCmd

func (Pipeline) LPop Uses

❖
func (c Pipeline) LPop(key string) *StringCmd

func (Pipeline) LPush Uses

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

func (Pipeline) LPushX Uses

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

func (Pipeline) LRange Uses

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

func (Pipeline) LRem Uses

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

func (Pipeline) LSet Uses

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

func (Pipeline) LTrim Uses

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

func (Pipeline) LastSave Uses

❖
func (c Pipeline) LastSave() *IntCmd

func (Pipeline) MGet Uses

❖
func (c Pipeline) MGet(keys ...string) *SliceCmd

func (Pipeline) MSet Uses

❖
func (c Pipeline) 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 (Pipeline) MSetNX Uses

❖
func (c Pipeline) 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 (Pipeline) MemoryUsage Uses

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

func (Pipeline) Migrate Uses

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

func (Pipeline) Move Uses

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

func (Pipeline) ObjectEncoding Uses

❖
func (c Pipeline) ObjectEncoding(key string) *StringCmd

func (Pipeline) ObjectIdleTime Uses

❖
func (c Pipeline) ObjectIdleTime(key string) *DurationCmd

func (Pipeline) ObjectRefCount Uses

❖
func (c Pipeline) ObjectRefCount(key string) *IntCmd

func (Pipeline) PExpire Uses

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

func (Pipeline) PExpireAt Uses

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

func (Pipeline) PFAdd Uses

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

func (Pipeline) PFCount Uses

❖
func (c Pipeline) PFCount(keys ...string) *IntCmd

func (Pipeline) PFMerge Uses

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

func (Pipeline) PTTL Uses

❖
func (c Pipeline) PTTL(key string) *DurationCmd

func (Pipeline) Persist Uses

❖
func (c Pipeline) Persist(key string) *BoolCmd

func (Pipeline) Ping Uses

❖
func (c Pipeline) Ping() *StatusCmd

func (*Pipeline) Pipeline Uses

❖
func (c *Pipeline) Pipeline() Pipeliner

func (*Pipeline) Pipelined Uses

❖
func (c *Pipeline) Pipelined(fn func(Pipeliner) error) ([]Cmder, error)

func (*Pipeline) Process Uses

❖
func (c *Pipeline) Process(cmd Cmder) error

Process queues the cmd for later execution.

func (Pipeline) PubSubChannels Uses

❖
func (c Pipeline) PubSubChannels(pattern string) *StringSliceCmd

func (Pipeline) PubSubNumPat Uses

❖
func (c Pipeline) PubSubNumPat() *IntCmd

func (Pipeline) PubSubNumSub Uses

❖
func (c Pipeline) PubSubNumSub(channels ...string) *StringIntMapCmd

func (Pipeline) Publish Uses

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

Publish posts the message to the channel.

func (Pipeline) Quit Uses

❖
func (c Pipeline) Quit() *StatusCmd

func (Pipeline) RPop Uses

❖
func (c Pipeline) RPop(key string) *StringCmd

func (Pipeline) RPopLPush Uses

❖
func (c Pipeline) RPopLPush(source, destination string) *StringCmd

func (Pipeline) RPush Uses

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

func (Pipeline) RPushX Uses

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

func (Pipeline) RandomKey Uses

❖
func (c Pipeline) RandomKey() *StringCmd

func (Pipeline) ReadOnly Uses

❖
func (c Pipeline) ReadOnly() *StatusCmd

func (Pipeline) ReadWrite Uses

❖
func (c Pipeline) ReadWrite() *StatusCmd

func (Pipeline) Rename Uses

❖
func (c Pipeline) Rename(key, newkey string) *StatusCmd

func (Pipeline) RenameNX Uses

❖
func (c Pipeline) RenameNX(key, newkey string) *BoolCmd

func (Pipeline) Restore Uses

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

func (Pipeline) RestoreReplace Uses

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

func (Pipeline) SAdd Uses

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

func (Pipeline) SCard Uses

❖
func (c Pipeline) SCard(key string) *IntCmd

func (Pipeline) SDiff Uses

❖
func (c Pipeline) SDiff(keys ...string) *StringSliceCmd

func (Pipeline) SDiffStore Uses

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

func (Pipeline) SInter Uses

❖
func (c Pipeline) SInter(keys ...string) *StringSliceCmd

func (Pipeline) SInterStore Uses

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

func (Pipeline) SIsMember Uses

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

func (Pipeline) SMembers Uses

❖
func (c Pipeline) SMembers(key string) *StringSliceCmd

Redis `SMEMBERS key` command output as a slice

func (Pipeline) SMembersMap Uses

❖
func (c Pipeline) SMembersMap(key string) *StringStructMapCmd

Redis `SMEMBERS key` command output as a map

func (Pipeline) SMove Uses

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

func (Pipeline) SPop Uses

❖
func (c Pipeline) SPop(key string) *StringCmd

Redis `SPOP key` command.

func (Pipeline) SPopN Uses

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

Redis `SPOP key count` command.

func (Pipeline) SRandMember Uses

❖
func (c Pipeline) SRandMember(key string) *StringCmd

Redis `SRANDMEMBER key` command.

func (Pipeline) SRandMemberN Uses

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

Redis `SRANDMEMBER key count` command.

func (Pipeline) SRem Uses

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

func (Pipeline) SScan Uses

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

func (Pipeline) SUnion Uses

❖
func (c Pipeline) SUnion(keys ...string) *StringSliceCmd

func (Pipeline) SUnionStore Uses

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

func (Pipeline) Save Uses

❖
func (c Pipeline) Save() *StatusCmd

func (Pipeline) Scan Uses

❖
func (c Pipeline) Scan(cursor uint64, match string, count int64) *ScanCmd

func (Pipeline) ScriptExists Uses

❖
func (c Pipeline) ScriptExists(hashes ...string) *BoolSliceCmd

func (Pipeline) ScriptFlush Uses

❖
func (c Pipeline) ScriptFlush() *StatusCmd

func (Pipeline) ScriptKill Uses

❖
func (c Pipeline) ScriptKill() *StatusCmd

func (Pipeline) ScriptLoad Uses

❖
func (c Pipeline) ScriptLoad(script string) *StringCmd

func (Pipeline) Select Uses

❖
func (c Pipeline) Select(index int) *StatusCmd

func (Pipeline) Set Uses

❖
func (c Pipeline) 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.

func (Pipeline) SetBit Uses

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

func (Pipeline) SetNX Uses

❖
func (c Pipeline) 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 (Pipeline) SetRange Uses

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

func (Pipeline) SetXX Uses

❖
func (c Pipeline) 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 (Pipeline) Shutdown Uses

❖
func (c Pipeline) Shutdown() *StatusCmd

func (Pipeline) ShutdownNoSave Uses

❖
func (c Pipeline) ShutdownNoSave() *StatusCmd

func (Pipeline) ShutdownSave Uses

❖
func (c Pipeline) ShutdownSave() *StatusCmd

func (Pipeline) SlaveOf Uses

❖
func (c Pipeline) SlaveOf(host, port string) *StatusCmd

func (Pipeline) SlowLog Uses

❖
func (c Pipeline) SlowLog()

func (Pipeline) Sort Uses

❖
func (c Pipeline) Sort(key string, sort *Sort) *StringSliceCmd

func (Pipeline) SortInterfaces Uses

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

func (Pipeline) SortStore Uses

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

func (Pipeline) StrLen Uses

❖
func (c Pipeline) StrLen(key string) *IntCmd

func (Pipeline) SwapDB Uses

❖
func (c Pipeline) SwapDB(index1, index2 int) *StatusCmd

func (Pipeline) Sync Uses

❖
func (c Pipeline) Sync()

func (Pipeline) TTL Uses

❖
func (c Pipeline) TTL(key string) *DurationCmd

func (Pipeline) Time Uses

❖
func (c Pipeline) Time() *TimeCmd

func (Pipeline) Touch Uses

❖
func (c Pipeline) Touch(keys ...string) *IntCmd

func (*Pipeline) TxPipeline Uses

❖
func (c *Pipeline) TxPipeline() Pipeliner

func (*Pipeline) TxPipelined Uses

❖
func (c *Pipeline) TxPipelined(fn func(Pipeliner) error) ([]Cmder, error)

func (Pipeline) Type Uses

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

func (Pipeline) Wait Uses

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

func (Pipeline) XAck Uses

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

func (Pipeline) XAdd Uses

❖
func (c Pipeline) XAdd(a *XAddArgs) *StringCmd

func (Pipeline) XClaim Uses

❖
func (c Pipeline) XClaim(a *XClaimArgs) *XMessageSliceCmd

func (Pipeline) XClaimJustID Uses

❖
func (c Pipeline) XClaimJustID(a *XClaimArgs) *StringSliceCmd

func (Pipeline) XDel Uses

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

func (Pipeline) XGroupCreate Uses

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

func (Pipeline) XGroupCreateMkStream Uses

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

func (Pipeline) XGroupDelConsumer Uses

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

func (Pipeline) XGroupDestroy Uses

❖
func (c Pipeline) XGroupDestroy(stream, group string) *IntCmd

func (Pipeline) XGroupSetID Uses

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

func (Pipeline) XInfoGroups Uses

❖
func (c Pipeline) XInfoGroups(key string) *XInfoGroupsCmd

func (Pipeline) XLen Uses

❖
func (c Pipeline) XLen(stream string) *IntCmd

func (Pipeline) XPending Uses

❖
func (c Pipeline) XPending(stream, group string) *XPendingCmd

func (Pipeline) XPendingExt Uses

❖
func (c Pipeline) XPendingExt(a *XPendingExtArgs) *XPendingExtCmd

func (Pipeline) XRange Uses

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

func (Pipeline) XRangeN Uses

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

func (Pipeline) XRead Uses

❖
func (c Pipeline) XRead(a *XReadArgs) *XStreamSliceCmd

func (Pipeline) XReadGroup Uses

❖
func (c Pipeline) XReadGroup(a *XReadGroupArgs) *XStreamSliceCmd

func (Pipeline) XReadStreams Uses

❖
func (c Pipeline) XReadStreams(streams ...string) *XStreamSliceCmd

func (Pipeline) XRevRange Uses

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

func (Pipeline) XRevRangeN Uses

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

func (Pipeline) XTrim Uses

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

func (Pipeline) XTrimApprox Uses

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

func (Pipeline) ZAdd Uses

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

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

func (Pipeline) ZAddCh Uses

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

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

func (Pipeline) ZAddNX Uses

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

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

func (Pipeline) ZAddNXCh Uses

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

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

func (Pipeline) ZAddXX Uses

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

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

func (Pipeline) ZAddXXCh Uses

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

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

func (Pipeline) ZCard Uses

❖
func (c Pipeline) ZCard(key string) *IntCmd

func (Pipeline) ZCount Uses

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

func (Pipeline) ZIncr Uses

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

Redis `ZADD key INCR score member` command.

func (Pipeline) ZIncrBy Uses

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

func (Pipeline) ZIncrNX Uses

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

Redis `ZADD key NX INCR score member` command.

func (Pipeline) ZIncrXX Uses

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

Redis `ZADD key XX INCR score member` command.

func (Pipeline) ZInterStore Uses

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

func (Pipeline) ZLexCount Uses

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

func (Pipeline) ZPopMax Uses

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

func (Pipeline) ZPopMin Uses

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

func (Pipeline) ZRange Uses

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

func (Pipeline) ZRangeByLex Uses

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

func (Pipeline) ZRangeByScore Uses

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

func (Pipeline) ZRangeByScoreWithScores Uses

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

func (Pipeline) ZRangeWithScores Uses

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

func (Pipeline) ZRank Uses

❖
func (c Pipeline) ZRank(key, member string) *IntCmd

func (Pipeline) ZRem Uses

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

func (Pipeline) ZRemRangeByLex Uses

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

func (Pipeline) ZRemRangeByRank Uses

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

func (Pipeline) ZRemRangeByScore Uses

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

func (Pipeline) ZRevRange Uses

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

func (Pipeline) ZRevRangeByLex Uses

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

func (Pipeline) ZRevRangeByScore Uses

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

func (Pipeline) ZRevRangeByScoreWithScores Uses

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

func (Pipeline) ZRevRangeWithScores Uses

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

func (Pipeline) ZRevRank Uses

❖
func (c Pipeline) ZRevRank(key, member string) *IntCmd

func (Pipeline) ZScan Uses

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

func (Pipeline) ZScore Uses

❖
func (c Pipeline) ZScore(key, member string) *FloatCmd

func (Pipeline) ZUnionStore Uses

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

type Pipeliner Uses

❖
type Pipeliner interface {
    StatefulCmdable
    Do(args ...interface{}) *Cmd
    Process(cmd Cmder) error
    Close() error
    Discard() error
    Exec() ([]Cmder, error)
    ExecContext(ctx context.Context) ([]Cmder, error)
}

Pipeliner is an mechanism to realise Redis Pipeline technique.

Pipelining is a technique to extremely speed up processing by packing operations to batches, send them at once to Redis and read a replies in a singe step. See https://redis.io/topics/pipelining

Pay attention, that Pipeline is not a transaction, so you can get unexpected results in case of big pipelines and small read/write timeouts. Redis client has retransmission logic in case of timeouts, pipeline can be retransmitted and commands can be executed more then once. To avoid this: it is good idea to use reasonable bigger read/write timeouts depends of your batch size and/or use TxPipeline.

type Pong Uses

❖
type Pong struct {
    Payload string
}

Pong received as result of a PING command issued by another client.

func (*Pong) String Uses

❖
func (p *Pong) String() string

type PoolStats Uses

❖
type PoolStats pool.Stats

type PubSub Uses

❖
type PubSub struct {
    // contains filtered or unexported fields
}

PubSub implements Pub/Sub commands as described in http://redis.io/topics/pubsub. Message receiving is NOT safe for concurrent use by multiple goroutines.

PubSub automatically reconnects to Redis Server and resubscribes to the channels in case of network errors.

Example

Code: 

pubsub := rdb.Subscribe("mychannel1")

// Wait for confirmation that subscription is created before publishing anything.
_, err := pubsub.Receive()
if err != nil {
    panic(err)
}

// Go channel which receives messages.
ch := pubsub.Channel()

// Publish a message.
err = rdb.Publish("mychannel1", "hello").Err()
if err != nil {
    panic(err)
}

time.AfterFunc(time.Second, func() {
    // When pubsub is closed channel is closed too.
    _ = pubsub.Close()
})

// Consume messages.
for msg := range ch {
    fmt.Println(msg.Channel, msg.Payload)
}

Output:

mychannel1 hello

func (*PubSub) Channel Uses

❖
func (c *PubSub) Channel() <-chan *Message

Channel returns a Go channel for concurrently receiving messages. The channel is closed together with the PubSub. If the Go channel is blocked full for 30 seconds the message is dropped. Receive* APIs can not be used after channel is created.

go-redis periodically sends ping messages to test connection health and re-subscribes if ping can not not received for 30 seconds.

func (*PubSub) ChannelSize Uses

❖
func (c *PubSub) ChannelSize(size int) <-chan *Message

ChannelSize is like Channel, but creates a Go channel with specified buffer size.

func (*PubSub) ChannelWithSubscriptions Uses

❖
func (c *PubSub) ChannelWithSubscriptions(size int) <-chan interface{}

ChannelWithSubscriptions is like Channel, but message type can be either *Subscription or *Message. Subscription messages can be used to detect reconnections.

ChannelWithSubscriptions can not be used together with Channel or ChannelSize.

func (*PubSub) Close Uses

❖
func (c *PubSub) Close() error

func (*PubSub) PSubscribe Uses

❖
func (c *PubSub) PSubscribe(patterns ...string) error

PSubscribe the client to the given patterns. It returns empty subscription if there are no patterns.

func (*PubSub) PUnsubscribe Uses

❖
func (c *PubSub) PUnsubscribe(patterns ...string) error

PUnsubscribe the client from the given patterns, or from all of them if none is given.

func (*PubSub) Ping Uses

❖
func (c *PubSub) Ping(payload ...string) error

func (*PubSub) Receive Uses

❖
func (c *PubSub) Receive() (interface{}, error)

Receive returns a message as a Subscription, Message, Pong or error. See PubSub example for details. This is low-level API and in most cases Channel should be used instead.

Example

Code: 

pubsub := rdb.Subscribe("mychannel2")
defer pubsub.Close()

for i := 0; i < 2; i++ {
    // ReceiveTimeout is a low level API. Use ReceiveMessage instead.
    msgi, err := pubsub.ReceiveTimeout(time.Second)
    if err != nil {
        break
    }

    switch msg := msgi.(type) {
    case *redis.Subscription:
        fmt.Println("subscribed to", msg.Channel)

        _, err := rdb.Publish("mychannel2", "hello").Result()
        if err != nil {
            panic(err)
        }
    case *redis.Message:
        fmt.Println("received", msg.Payload, "from", msg.Channel)
    default:
        panic("unreached")
    }
}

// sent message to 1 rdb
// received hello from mychannel2

func (*PubSub) ReceiveMessage Uses

❖
func (c *PubSub) ReceiveMessage() (*Message, error)

ReceiveMessage returns a Message or error ignoring Subscription and Pong messages. This is low-level API and in most cases Channel should be used instead.

func (*PubSub) ReceiveTimeout Uses

❖
func (c *PubSub) ReceiveTimeout(timeout time.Duration) (interface{}, error)

ReceiveTimeout acts like Receive but returns an error if message is not received in time. This is low-level API and in most cases Channel should be used instead.

func (*PubSub) String Uses

❖
func (c *PubSub) String() string

func (*PubSub) Subscribe Uses

❖
func (c *PubSub) Subscribe(channels ...string) error

Subscribe the client to the specified channels. It returns empty subscription if there are no channels.

func (*PubSub) Unsubscribe Uses

❖
func (c *PubSub) Unsubscribe(channels ...string) error

Unsubscribe the client from the given channels, or from all of them if none is given.

type Ring Uses

❖
type Ring struct {
    // contains filtered or unexported fields
}

Ring is a Redis client that uses consistent hashing to distribute keys across multiple Redis servers (shards). It's safe for concurrent use by multiple goroutines.

Ring monitors the state of each shard and removes dead shards from the ring. When a shard comes online it is added back to the ring. This gives you maximum availability and partition tolerance, but no consistency between different shards or even clients. Each client uses shards that are available to the client and does not do any coordination when shard state is changed.

Ring should be used when you need multiple Redis servers for caching and can tolerate losing data when one of the servers dies. Otherwise you should use Redis Cluster.

func NewRing Uses

❖
func NewRing(opt *RingOptions) *Ring
Example

Code: 

rdb := redis.NewRing(&redis.RingOptions{
    Addrs: map[string]string{
        "shard1": ":7000",
        "shard2": ":7001",
        "shard3": ":7002",
    },
})
rdb.Ping()

func (*Ring) AddHook Uses

❖
func (hs *Ring) AddHook(hook Hook)

func (Ring) Append Uses

❖
func (c Ring) Append(key, value string) *IntCmd

func (Ring) BLPop Uses

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

func (Ring) BRPop Uses

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

func (Ring) BRPopLPush Uses

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

func (Ring) BZPopMax Uses

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

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

func (Ring) BZPopMin Uses

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

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

func (Ring) BgRewriteAOF Uses

❖
func (c Ring) BgRewriteAOF() *StatusCmd

func (Ring) BgSave Uses

❖
func (c Ring) BgSave() *StatusCmd

func (Ring) BitCount Uses

❖
func (c Ring) BitCount(key string, bitCount *BitCount) *IntCmd

func (Ring) BitField Uses

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

func (Ring) BitOpAnd Uses

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

func (Ring) BitOpNot Uses

❖
func (c Ring) BitOpNot(destKey string, key string) *IntCmd

func (Ring) BitOpOr Uses

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

func (Ring) BitOpXor Uses

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

func (Ring) BitPos Uses

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

func (Ring) ClientGetName Uses

❖
func (c Ring) ClientGetName() *StringCmd

ClientGetName returns the name of the connection.

func (Ring) ClientID Uses

❖
func (c Ring) ClientID() *IntCmd

func (Ring) ClientKill Uses

❖
func (c Ring) ClientKill(ipPort string) *StatusCmd

func (Ring) ClientKillByFilter Uses

❖
func (c Ring) ClientKillByFilter(keys ...string) *IntCmd

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

func (Ring) ClientList Uses

❖
func (c Ring) ClientList() *StringCmd

func (Ring) ClientPause Uses

❖
func (c Ring) ClientPause(dur time.Duration) *BoolCmd

func (Ring) ClientUnblock Uses

❖
func (c Ring) ClientUnblock(id int64) *IntCmd

func (Ring) ClientUnblockWithError Uses

❖
func (c Ring) ClientUnblockWithError(id int64) *IntCmd

func (*Ring) Close Uses

❖
func (c *Ring) Close() error

Close closes the ring client, releasing any open resources.

It is rare to Close a Ring, as the Ring is meant to be long-lived and shared between many goroutines.

func (Ring) ClusterAddSlots Uses

❖
func (c Ring) ClusterAddSlots(slots ...int) *StatusCmd

func (Ring) ClusterAddSlotsRange Uses

❖
func (c Ring) ClusterAddSlotsRange(min, max int) *StatusCmd

func (Ring) ClusterCountFailureReports Uses

❖
func (c Ring) ClusterCountFailureReports(nodeID string) *IntCmd

func (Ring) ClusterCountKeysInSlot Uses

❖
func (c Ring) ClusterCountKeysInSlot(slot int) *IntCmd

func (Ring) ClusterDelSlots Uses

❖
func (c Ring) ClusterDelSlots(slots ...int) *StatusCmd

func (Ring) ClusterDelSlotsRange Uses

❖
func (c Ring) ClusterDelSlotsRange(min, max int) *StatusCmd

func (Ring) ClusterFailover Uses

❖
func (c Ring) ClusterFailover() *StatusCmd

func (Ring) ClusterForget Uses

❖
func (c Ring) ClusterForget(nodeID string) *StatusCmd

func (Ring) ClusterGetKeysInSlot Uses

❖
func (c Ring) ClusterGetKeysInSlot(slot int, count int) *StringSliceCmd

func (Ring) ClusterInfo Uses

❖
func (c Ring) ClusterInfo() *StringCmd

func (Ring) ClusterKeySlot Uses

❖
func (c Ring) ClusterKeySlot(key string) *IntCmd

func (Ring) ClusterMeet Uses

❖
func (c Ring) ClusterMeet(host, port string) *StatusCmd

func (Ring) ClusterNodes Uses

❖
func (c Ring) ClusterNodes() *StringCmd

func (Ring) ClusterReplicate Uses

❖
func (c Ring) ClusterReplicate(nodeID string) *StatusCmd

func (Ring) ClusterResetHard Uses

❖
func (c Ring) ClusterResetHard() *StatusCmd

func (Ring) ClusterResetSoft Uses

❖
func (c Ring) ClusterResetSoft() *StatusCmd

func (Ring) ClusterSaveConfig Uses

❖
func (c Ring) ClusterSaveConfig() *StatusCmd

func (Ring) ClusterSlaves Uses

❖
func (c Ring) ClusterSlaves(nodeID string) *StringSliceCmd

func (Ring) ClusterSlots Uses

❖
func (c Ring) ClusterSlots() *ClusterSlotsCmd

func (Ring) Command Uses

❖
func (c Ring) Command() *CommandsInfoCmd

func (Ring) ConfigGet Uses

❖
func (c Ring) ConfigGet(parameter string) *SliceCmd

func (Ring) ConfigResetStat Uses

❖
func (c Ring) ConfigResetStat() *StatusCmd

func (Ring) ConfigRewrite Uses

❖
func (c Ring) ConfigRewrite() *StatusCmd

func (Ring) ConfigSet Uses

❖
func (c Ring) ConfigSet(parameter, value string) *StatusCmd

func (*Ring) Context Uses

❖
func (c *Ring) Context() context.Context

func (Ring) DBSize Uses

❖
func (c Ring) DBSize() *IntCmd

func (Ring) DbSize Uses

❖
func (c Ring) DbSize() *IntCmd

Deperecated. Use DBSize instead.

func (Ring) DebugObject Uses

❖
func (c Ring) DebugObject(key string) *StringCmd

func (Ring) Decr Uses

❖
func (c Ring) Decr(key string) *IntCmd

func (Ring) DecrBy Uses

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

func (Ring) Del Uses

❖
func (c Ring) Del(keys ...string) *IntCmd

func (*Ring) Do Uses

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

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

func (*Ring) DoContext Uses

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

func (Ring) Dump Uses

❖
func (c Ring) Dump(key string) *StringCmd

func (Ring) Echo Uses

❖
func (c Ring) Echo(message interface{}) *StringCmd

func (Ring) Eval Uses

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

func (Ring) EvalSha Uses

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

func (Ring) Exists Uses

❖
func (c Ring) Exists(keys ...string) *IntCmd

func (Ring) Expire Uses

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

func (Ring) ExpireAt Uses

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

func (Ring) FlushAll Uses

❖
func (c Ring) FlushAll() *StatusCmd

func (Ring) FlushAllAsync Uses

❖
func (c Ring) FlushAllAsync() *StatusCmd

func (Ring) FlushDB Uses

❖
func (c Ring) FlushDB() *StatusCmd

func (Ring) FlushDBAsync Uses

❖
func (c Ring) FlushDBAsync() *StatusCmd

func (*Ring) ForEachShard Uses

❖
func (c *Ring) ForEachShard(fn func(client *Client) error) error

ForEachShard concurrently calls the fn on each live shard in the ring. It returns the first error if any.

func (Ring) GeoAdd Uses

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

func (Ring) GeoDist Uses

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

func (Ring) GeoHash Uses

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

func (Ring) GeoPos Uses

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

func (Ring) GeoRadius Uses

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

GeoRadius is a read-only GEORADIUS_RO command.

func (Ring) GeoRadiusByMember Uses

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

GeoRadius is a read-only GEORADIUSBYMEMBER_RO command.

func (Ring) GeoRadiusByMemberStore Uses

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

GeoRadiusByMemberStore is a writing GEORADIUSBYMEMBER command.

func (Ring) GeoRadiusStore Uses

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

GeoRadiusStore is a writing GEORADIUS command.

func (Ring) Get Uses

❖
func (c Ring) Get(key string) *StringCmd

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

func (Ring) GetBit Uses

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

func (Ring) GetRange Uses

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

func (Ring) GetSet Uses

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

func (Ring) HDel Uses

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

func (Ring) HExists Uses

❖
func (c Ring) HExists(key, field string) *BoolCmd

func (Ring) HGet Uses

❖
func (c Ring) HGet(key, field string) *StringCmd

func (Ring) HGetAll