redis

package module
Version: v7.4.1 Latest Latest
Warning

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

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

README

Redis client for Golang

Build Status GoDoc Airbrake

Supports:

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

Installation

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

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

Import:

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

Quickstart

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

	pong, err := client.Ping().Result()
	fmt.Println(pong, err)
	// Output: PONG <nil>
}

func ExampleClient() {
	client := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "", // no password set
		DB:       0,  // use default DB
	})
	err := client.Set("key", "value", 0).Err()
	if err != nil {
		panic(err)
	}

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

	val2, err := client.Get("key2").Result()
	if err == redis.Nil {
		fmt.Println("key2 does not exist")
	} else if err != nil {
		panic(err)
	} else {
		fmt.Println("key2", val2)
	}
	// Output: key value
	// key2 does not exist
}

Howto

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

Look and feel

Some corner cases:

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

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

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

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

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

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

See also

Documentation

Overview

Package redis implements a Redis client.

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

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

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

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

rdb.Ping()
Output:

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

Index

Examples

Constants

View Source
const Nil = proto.Nil

Nil reply returned by Redis when key does not exist.

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

TxFailedErr transaction redis failed.

Variables

View Source
var ErrClosed = pool.ErrClosed

Functions

func SetLogger

func SetLogger(logger *log.Logger)

Types

type BitCount

type BitCount struct {
	Start, End int64
}

type BoolCmd

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

func NewBoolCmd

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

func NewBoolResult

func NewBoolResult(val bool, err error) *BoolCmd

NewBoolResult returns a BoolCmd initialised with val and err for testing

func (*BoolCmd) Args

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

func (*BoolCmd) Err

func (cmd *BoolCmd) Err() error

func (*BoolCmd) Name

func (cmd *BoolCmd) Name() string

func (*BoolCmd) Result

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

func (*BoolCmd) SetErr

func (cmd *BoolCmd) SetErr(e error)

func (*BoolCmd) String

func (cmd *BoolCmd) String() string

func (*BoolCmd) Val

func (cmd *BoolCmd) Val() bool

type BoolSliceCmd

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

func NewBoolSliceCmd

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

func NewBoolSliceResult

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

NewBoolSliceResult returns a BoolSliceCmd initialised with val and err for testing

func (*BoolSliceCmd) Args

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

func (*BoolSliceCmd) Err

func (cmd *BoolSliceCmd) Err() error

func (*BoolSliceCmd) Name

func (cmd *BoolSliceCmd) Name() string

func (*BoolSliceCmd) Result

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

func (*BoolSliceCmd) SetErr

func (cmd *BoolSliceCmd) SetErr(e error)

func (*BoolSliceCmd) String

func (cmd *BoolSliceCmd) String() string

func (*BoolSliceCmd) Val

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

type Client

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

Client is a Redis client representing a pool of zero or more underlying connections. It's safe for concurrent use by multiple goroutines.

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

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

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

key value
missing_key does not exist

func NewClient

func NewClient(opt *Options) *Client

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

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

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

PONG <nil>

func NewFailoverClient

func NewFailoverClient(failoverOpt *FailoverOptions) *Client

NewFailoverClient returns a Redis client that uses Redis Sentinel for automatic failover. It's safe for concurrent use by multiple goroutines.

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

func (*Client) AddHook

func (hs *Client) AddHook(hook Hook)

func (Client) Append

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

func (Client) BLPop

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

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

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

queue message

func (Client) BRPop

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

func (Client) BRPopLPush

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

func (Client) BZPopMax

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

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

func (Client) BZPopMin

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

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

func (Client) BgRewriteAOF

func (c Client) BgRewriteAOF() *StatusCmd

func (Client) BgSave

func (c Client) BgSave() *StatusCmd

func (Client) BitCount

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

func (Client) BitField

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

func (Client) BitOpAnd

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

func (Client) BitOpNot

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

func (Client) BitOpOr

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

func (Client) BitOpXor

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

func (Client) BitPos

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

func (Client) ClientGetName

func (c Client) ClientGetName() *StringCmd

ClientGetName returns the name of the connection.

func (Client) ClientID

func (c Client) ClientID() *IntCmd

func (Client) ClientKill

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

func (Client) ClientKillByFilter

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

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

func (Client) ClientList

func (c Client) ClientList() *StringCmd

func (Client) ClientPause

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

func (Client) ClientUnblock

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

func (Client) ClientUnblockWithError

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

func (Client) Close

func (c Client) Close() error

Close closes the client, releasing any open resources.

It is rare to Close a Client, as the Client is meant to be long-lived and shared between many goroutines.

func (Client) ClusterAddSlots

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

func (Client) ClusterAddSlotsRange

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

func (Client) ClusterCountFailureReports

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

func (Client) ClusterCountKeysInSlot

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

func (Client) ClusterDelSlots

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

func (Client) ClusterDelSlotsRange

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

func (Client) ClusterFailover

func (c Client) ClusterFailover() *StatusCmd

func (Client) ClusterForget

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

func (Client) ClusterGetKeysInSlot

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

func (Client) ClusterInfo

func (c Client) ClusterInfo() *StringCmd

func (Client) ClusterKeySlot

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

func (Client) ClusterMeet

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

func (Client) ClusterNodes

func (c Client) ClusterNodes() *StringCmd

func (Client) ClusterReplicate

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

func (Client) ClusterResetHard

func (c Client) ClusterResetHard() *StatusCmd

func (Client) ClusterResetSoft

func (c Client) ClusterResetSoft() *StatusCmd

func (Client) ClusterSaveConfig

func (c Client) ClusterSaveConfig() *StatusCmd

func (Client) ClusterSlaves

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

func (Client) ClusterSlots

func (c Client) ClusterSlots() *ClusterSlotsCmd

func (Client) Command

func (c Client) Command() *CommandsInfoCmd

func (Client) ConfigGet

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

func (Client) ConfigResetStat

func (c Client) ConfigResetStat() *StatusCmd

func (Client) ConfigRewrite

func (c Client) ConfigRewrite() *StatusCmd

func (Client) ConfigSet

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

func (*Client) Conn

func (c *Client) Conn() *Conn

func (*Client) Context

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

func (Client) DBSize

func (c Client) DBSize() *IntCmd

func (Client) DbSize

func (c Client) DbSize() *IntCmd

Deperecated. Use DBSize instead.

func (Client) DebugObject

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

func (Client) Decr

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

func (Client) DecrBy

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

func (Client) Del

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

func (*Client) Do

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

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

func (*Client) DoContext

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

func (Client) Dump

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

func (Client) Echo

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

func (Client) Eval

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

func (Client) EvalSha

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

func (Client) Exists

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

func (Client) Expire

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

func (Client) ExpireAt

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

func (Client) FlushAll

func (c Client) FlushAll() *StatusCmd

func (Client) FlushAllAsync

func (c Client) FlushAllAsync() *StatusCmd

func (Client) FlushDB

func (c Client) FlushDB() *StatusCmd

func (Client) FlushDBAsync

func (c Client) FlushDBAsync() *StatusCmd

func (Client) GeoAdd

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

func (Client) GeoDist

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

func (Client) GeoHash

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

func (Client) GeoPos

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

func (Client) GeoRadius

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

GeoRadius is a read-only GEORADIUS_RO command.

func (Client) GeoRadiusByMember

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

GeoRadius is a read-only GEORADIUSBYMEMBER_RO command.

func (Client) GeoRadiusByMemberStore

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

GeoRadiusByMemberStore is a writing GEORADIUSBYMEMBER command.

func (Client) GeoRadiusStore

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

GeoRadiusStore is a writing GEORADIUS command.

func (Client) Get

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

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

func (Client) GetBit

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

func (Client) GetRange

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

func (Client) GetSet

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

func (Client) HDel

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

func (Client) HExists

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

func (Client) HGet

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

func (Client) HGetAll

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

func (Client) HIncrBy

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

func (Client) HIncrByFloat

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

func (Client) HKeys

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

func (Client) HLen

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

func (Client) HMGet

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

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

func (Client) HMSet

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

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

func (Client) HScan

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

func (Client) HSet

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

HSet accepts values in following formats:

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

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

func (Client) HSetNX

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

func (Client) HVals

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

func (Client) Incr

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

fmt.Println(result)
Output:

1

func (Client) IncrBy

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

func (Client) IncrByFloat

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

func (Client) Info

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

func (Client) Keys

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

func (Client) LIndex

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

func (Client) LInsert

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

func (Client) LInsertAfter

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

func (Client) LInsertBefore

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

func (Client) LLen

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

func (Client) LPop

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

func (Client) LPush

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

func (Client) LPushX

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

func (Client) LRange

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

func (Client) LRem

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

func (Client) LSet

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

func (Client) LTrim

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

func (Client) LastSave

func (c Client) LastSave() *IntCmd

func (Client) MGet

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

func (Client) MSet

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

MSet is like Set but accepts multiple values:

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

func (Client) MSetNX

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

MSetNX is like SetNX but accepts multiple values:

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

func (Client) MemoryUsage

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

func (Client) Migrate

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

func (Client) Move

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

func (Client) ObjectEncoding

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

func (Client) ObjectIdleTime

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

func (Client) ObjectRefCount

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

func (*Client) Options

func (c *Client) Options() *Options

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

func (Client) PExpire

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

func (Client) PExpireAt

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

func (Client) PFAdd

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

func (Client) PFCount

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

func (Client) PFMerge

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

func (*Client) PSubscribe

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

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

func (Client) PTTL

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

func (Client) Persist

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

func (Client) Ping

func (c Client) Ping() *StatusCmd

func (*Client) Pipeline

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

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

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

1 <nil>

func (*Client) Pipelined

func (c *Client) Pipelined(fn func(Pipeliner) error) ([]Cmder, error)
Example
var incr *redis.IntCmd
_, err := rdb.Pipelined(func(pipe redis.Pipeliner) error {
	incr = pipe.Incr("pipelined_counter")
	pipe.Expire("pipelined_counter", time.Hour)
	return nil
})
fmt.Println(incr.Val(), err)
Output:

1 <nil>

func (*Client) PoolStats

func (c *Client) PoolStats() *PoolStats

PoolStats returns connection pool stats.

func (*Client) Process

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

func (*Client) ProcessContext

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

func (Client) PubSubChannels

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

func (Client) PubSubNumPat

func (c Client) PubSubNumPat() *IntCmd

func (Client) PubSubNumSub

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

func (Client) Publish

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

Publish posts the message to the channel.

func (Client) Quit

func (c Client) Quit() *StatusCmd

func (Client) RPop

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

func (Client) RPopLPush

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

func (Client) RPush

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

func (Client) RPushX

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

func (Client) RandomKey

func (c Client) RandomKey() *StringCmd

func (Client) ReadOnly

func (c Client) ReadOnly() *StatusCmd

func (Client) ReadWrite

func (c Client) ReadWrite() *StatusCmd

func (Client) Rename

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

func (Client) RenameNX

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

func (Client) Restore

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

func (Client) RestoreReplace

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

func (Client) SAdd

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

func (Client) SCard

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

func (Client) SDiff

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

func (Client) SDiffStore

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

func (Client) SInter

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

func (Client) SInterStore

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

func (Client) SIsMember

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

func (Client) SMembers

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

Redis `SMEMBERS key` command output as a slice

func (Client) SMembersMap

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

Redis `SMEMBERS key` command output as a map

func (Client) SMove

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

func (Client) SPop

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

Redis `SPOP key` command.

func (Client) SPopN

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

Redis `SPOP key count` command.

func (Client) SRandMember

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

Redis `SRANDMEMBER key` command.

func (Client) SRandMemberN

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

Redis `SRANDMEMBER key count` command.

func (Client) SRem

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

func (Client) SScan

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

func (Client) SUnion

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

func (Client) SUnionStore

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

func (Client) Save

func (c Client) Save() *StatusCmd

func (Client) Scan

func (c Client) Scan(cursor uint64, match string, count int64) *ScanCmd
Example
rdb.FlushDB()
for i := 0; i < 33; i++ {
	err := rdb.Set(fmt.Sprintf("key%d", i), "value", 0).Err()
	if err != nil {
		panic(err)
	}
}

var cursor uint64
var n int
for {
	var keys []string
	var err error
	keys, cursor, err = rdb.Scan(cursor, "key*", 10).Result()
	if err != nil {
		panic(err)
	}
	n += len(keys)
	if cursor == 0 {
		break
	}
}

fmt.Printf("found %d keys\n", n)
Output:

found 33 keys

func (Client) ScriptExists

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

func (Client) ScriptFlush

func (c Client) ScriptFlush() *StatusCmd

func (Client) ScriptKill

func (c Client) ScriptKill() *StatusCmd

func (Client) ScriptLoad

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

func (Client) Set

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

Redis `SET key value [expiration]` command.

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

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

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

func (Client) SetBit

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

func (Client) SetNX

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

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

Zero expiration means the key has no expiration time.

func (Client) SetRange

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

func (Client) SetXX

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

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

Zero expiration means the key has no expiration time.

func (Client) Shutdown

func (c Client) Shutdown() *StatusCmd

func (Client) ShutdownNoSave

func (c Client) ShutdownNoSave() *StatusCmd

func (Client) ShutdownSave

func (c Client) ShutdownSave() *StatusCmd

func (Client) SlaveOf

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

func (Client) SlowLog

func (c Client) SlowLog()

func (Client) Sort

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

func (Client) SortInterfaces

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

func (Client) SortStore

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

func (Client) StrLen

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

func (Client) String

func (c Client) String() string

func (*Client) Subscribe

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

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

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

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

ch := sub.Channel()

func (Client) Sync

func (c Client) Sync()

func (Client) TTL

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

func (Client) Time

func (c Client) Time() *TimeCmd

func (Client) Touch

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

func (*Client) TxPipeline

func (c *Client) TxPipeline() Pipeliner

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

Example
pipe := rdb.TxPipeline()

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

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

1 <nil>

func (*Client) TxPipelined

func (c *Client) TxPipelined(fn func(Pipeliner) error) ([]Cmder, error)
Example
var incr *redis.IntCmd
_, err := rdb.TxPipelined(func(pipe redis.Pipeliner) error {
	incr = pipe.Incr("tx_pipelined_counter")
	pipe.Expire("tx_pipelined_counter", time.Hour)
	return nil
})
fmt.Println(incr.Val(), err)
Output:

1 <nil>

func (Client) Type

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

func (Client) Wait

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

func (*Client) Watch

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

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

The transaction is automatically closed when fn exits.

Example
const routineCount = 100

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

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

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

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

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

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

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

ended with 100 <nil>

func (*Client) WatchContext

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

func (*Client) WithContext

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

func (*Client) WithTimeout

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

func (Client) XAck

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

func (Client) XAdd

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

func (Client) XClaim

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

func (Client) XClaimJustID

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

func (Client) XDel

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

func (Client) XGroupCreate

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

func (Client) XGroupCreateMkStream

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

func (Client) XGroupDelConsumer

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

func (Client) XGroupDestroy

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

func (Client) XGroupSetID

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

func (Client) XInfoGroups

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

func (Client) XLen

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

func (Client) XPending

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

func (Client) XPendingExt

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

func (Client) XRange

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

func (Client) XRangeN

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

func (Client) XRead

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

func (Client) XReadGroup

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

func (Client) XReadStreams

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

func (Client) XRevRange

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

func (Client) XRevRangeN

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

func (Client) XTrim

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

func (Client) XTrimApprox

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

func (Client) ZAdd

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

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

func (Client) ZAddCh

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

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

func (Client) ZAddNX

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

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

func (Client) ZAddNXCh

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

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

func (Client) ZAddXX

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

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

func (Client) ZAddXXCh

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

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

func (Client) ZCard

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

func (Client) ZCount

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

func (Client) ZIncr

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

Redis `ZADD key INCR score member` command.

func (Client) ZIncrBy

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

func (Client) ZIncrNX

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

Redis `ZADD key NX INCR score member` command.

func (Client) ZIncrXX

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

Redis `ZADD key XX INCR score member` command.

func (Client) ZInterStore

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

func (Client) ZLexCount

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

func (Client) ZPopMax

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

func (Client) ZPopMin

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

func (Client) ZRange

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

func (Client) ZRangeByLex

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

func (Client) ZRangeByScore

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

func (Client) ZRangeByScoreWithScores

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

func (Client) ZRangeWithScores

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

func (Client) ZRank

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

func (Client) ZRem

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

func (Client) ZRemRangeByLex

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

func (Client) ZRemRangeByRank

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

func (Client) ZRemRangeByScore

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

func (Client) ZRevRange

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

func (Client) ZRevRangeByLex

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

func (Client) ZRevRangeByScore

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

func (Client) ZRevRangeByScoreWithScores

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

func (Client) ZRevRangeWithScores

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

func (Client) ZRevRank

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

func (Client) ZScan

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

func (Client) ZScore

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

func (Client) ZUnionStore

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

type ClusterClient

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

ClusterClient is a Redis Cluster client representing a pool of zero or more underlying connections. It's safe for concurrent use by multiple goroutines.

func NewClusterClient

func NewClusterClient(opt *ClusterOptions) *ClusterClient

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

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

Example (ManualSetup)

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

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

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

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

func (*ClusterClient) AddHook

func (hs *ClusterClient) AddHook(hook Hook)

func (ClusterClient) Append

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

func (ClusterClient) BLPop

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

func (ClusterClient) BRPop

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

func (ClusterClient) BRPopLPush

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

func (ClusterClient) BZPopMax

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

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

func (ClusterClient) BZPopMin

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

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

func (ClusterClient) BgRewriteAOF

func (c ClusterClient) BgRewriteAOF() *StatusCmd

func (ClusterClient) BgSave

func (c ClusterClient) BgSave() *StatusCmd

func (ClusterClient) BitCount

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

func (ClusterClient) BitField

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

func (ClusterClient) BitOpAnd

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

func (ClusterClient) BitOpNot

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

func (ClusterClient) BitOpOr

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

func (ClusterClient) BitOpXor

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

func (ClusterClient) BitPos

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

func (ClusterClient) ClientGetName

func (c ClusterClient) ClientGetName() *StringCmd

ClientGetName returns the name of the connection.

func (ClusterClient) ClientID

func (c ClusterClient) ClientID() *IntCmd

func (ClusterClient) ClientKill

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

func (ClusterClient) ClientKillByFilter

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

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

func (ClusterClient) ClientList

func (c ClusterClient) ClientList() *StringCmd

func (ClusterClient) ClientPause

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

func (ClusterClient) ClientUnblock

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

func (ClusterClient) ClientUnblockWithError

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

func (*ClusterClient) Close

func (c *ClusterClient) Close() error

Close closes the cluster client, releasing any open resources.

It is rare to Close a ClusterClient, as the ClusterClient is meant to be long-lived and shared between many goroutines.

func (ClusterClient) ClusterAddSlots

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

func (ClusterClient) ClusterAddSlotsRange

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

func (ClusterClient) ClusterCountFailureReports

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

func (ClusterClient) ClusterCountKeysInSlot

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

func (ClusterClient) ClusterDelSlots

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

func (ClusterClient) ClusterDelSlotsRange

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

func (ClusterClient) ClusterFailover

func (c ClusterClient) ClusterFailover() *StatusCmd

func (ClusterClient) ClusterForget

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

func (ClusterClient) ClusterGetKeysInSlot

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

func (ClusterClient) ClusterInfo

func (c ClusterClient) ClusterInfo() *StringCmd

func (ClusterClient) ClusterKeySlot

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

func (ClusterClient) ClusterMeet

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

func (ClusterClient) ClusterNodes

func (c ClusterClient) ClusterNodes() *StringCmd

func (ClusterClient) ClusterReplicate

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

func (ClusterClient) ClusterResetHard

func (c ClusterClient) ClusterResetHard() *StatusCmd

func (ClusterClient) ClusterResetSoft

func (c ClusterClient) ClusterResetSoft() *StatusCmd

func (ClusterClient) ClusterSaveConfig

func (c ClusterClient) ClusterSaveConfig() *StatusCmd

func (ClusterClient) ClusterSlaves

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

func (ClusterClient) ClusterSlots

func (c ClusterClient) ClusterSlots() *ClusterSlotsCmd

func (ClusterClient) Command

func (c ClusterClient) Command() *CommandsInfoCmd

func (ClusterClient) ConfigGet

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

func (ClusterClient) ConfigResetStat

func (c ClusterClient) ConfigResetStat() *StatusCmd

func (ClusterClient) ConfigRewrite

func (c ClusterClient) ConfigRewrite() *StatusCmd

func (ClusterClient) ConfigSet

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

func (*ClusterClient) Context

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

func (*ClusterClient) DBSize

func (c *ClusterClient) DBSize() *IntCmd

func (ClusterClient) DbSize

func (c ClusterClient) DbSize() *IntCmd

Deperecated. Use DBSize instead.

func (ClusterClient) DebugObject

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

func (ClusterClient) Decr

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

func (ClusterClient) DecrBy

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

func (ClusterClient) Del

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

func (*ClusterClient) Do

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

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

func (*ClusterClient) DoContext

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

func (ClusterClient) Dump

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

func (ClusterClient) Echo

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

func (ClusterClient) Eval

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

func (ClusterClient) EvalSha

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

func (ClusterClient) Exists

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

func (ClusterClient) Expire

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

func (ClusterClient) ExpireAt

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

func (ClusterClient) FlushAll

func (c ClusterClient) FlushAll() *StatusCmd

func (ClusterClient) FlushAllAsync

func (c ClusterClient) FlushAllAsync() *StatusCmd

func (ClusterClient) FlushDB

func (c ClusterClient) FlushDB() *StatusCmd

func (ClusterClient) FlushDBAsync

func (c ClusterClient) FlushDBAsync() *StatusCmd

func (*ClusterClient) ForEachMaster

func (c *ClusterClient) ForEachMaster(fn func(client *Client) error) error

ForEachMaster concurrently calls the fn on each master node in the cluster. It returns the first error if any.

func (*ClusterClient) ForEachNode

func (c *ClusterClient) ForEachNode(fn func(client *Client) error) error

ForEachNode concurrently calls the fn on each known node in the cluster. It returns the first error if any.

func (*ClusterClient) ForEachSlave

func (c *ClusterClient) ForEachSlave(fn func(client *Client) error) error

ForEachSlave concurrently calls the fn on each slave node in the cluster. It returns the first error if any.

func (ClusterClient) GeoAdd

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

func (ClusterClient) GeoDist

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

func (ClusterClient) GeoHash

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

func (ClusterClient) GeoPos

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

func (ClusterClient) GeoRadius

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

GeoRadius is a read-only GEORADIUS_RO command.

func (ClusterClient) GeoRadiusByMember

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

GeoRadius is a read-only GEORADIUSBYMEMBER_RO command.

func (ClusterClient) GeoRadiusByMemberStore

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

GeoRadiusByMemberStore is a writing GEORADIUSBYMEMBER command.

func (ClusterClient) GeoRadiusStore

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

GeoRadiusStore is a writing GEORADIUS command.

func (ClusterClient) Get

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

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

func (ClusterClient) GetBit

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

func (ClusterClient) GetRange

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

func (ClusterClient) GetSet

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

func (ClusterClient) HDel

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

func (ClusterClient) HExists

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

func (ClusterClient) HGet

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

func (ClusterClient) HGetAll

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

func (ClusterClient) HIncrBy

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

func (ClusterClient) HIncrByFloat

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

func (ClusterClient) HKeys

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

func (ClusterClient) HLen

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

func (ClusterClient) HMGet

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

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

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

func (ClusterClient) HScan

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

func (ClusterClient) HSet

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

HSet accepts values in following formats:

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

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

func (ClusterClient) HSetNX

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

func (ClusterClient) HVals

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

func (ClusterClient) Incr

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

func (ClusterClient) IncrBy

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

func (ClusterClient) IncrByFloat

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

func (ClusterClient) Info

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

func (ClusterClient) Keys

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

func (ClusterClient) LIndex

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

func (ClusterClient) LInsert

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

func (ClusterClient) LInsertAfter

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

func (ClusterClient) LInsertBefore

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

func (ClusterClient) LLen

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

func (ClusterClient) LPop

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

func (ClusterClient) LPush

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

func (ClusterClient) LPushX

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

func (ClusterClient) LRange

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

func (ClusterClient) LRem

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

func (ClusterClient) LSet

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

func (ClusterClient) LTrim

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

func (ClusterClient) LastSave

func (c ClusterClient) LastSave() *IntCmd

func (ClusterClient) MGet

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

func (ClusterClient) MSet

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

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

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

func (ClusterClient) Migrate

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

func (ClusterClient) Move

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

func (ClusterClient) ObjectEncoding

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

func (ClusterClient) ObjectIdleTime

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

func (ClusterClient) ObjectRefCount

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

func (*ClusterClient) Options

func (c *ClusterClient) Options() *ClusterOptions

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

func (ClusterClient) PExpire

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

func (ClusterClient) PExpireAt

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

func (ClusterClient) PFAdd

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

func (ClusterClient) PFCount

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

func (ClusterClient) PFMerge

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

func (*ClusterClient) PSubscribe

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

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

func (ClusterClient) Persist

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

func (ClusterClient) Ping

func (c ClusterClient) Ping() *StatusCmd

func (*ClusterClient) Pipeline

func (c *ClusterClient) Pipeline() Pipeliner

func (*ClusterClient) Pipelined

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

func (*ClusterClient) PoolStats

func (c *ClusterClient) PoolStats() *PoolStats

PoolStats returns accumulated connection pool stats.

func (*ClusterClient) Process

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

func (*ClusterClient) ProcessContext

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

func (ClusterClient) PubSubChannels

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

func (ClusterClient) PubSubNumPat

func (c ClusterClient) PubSubNumPat() *IntCmd

func (ClusterClient) PubSubNumSub

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

func (ClusterClient) Publish

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

Publish posts the message to the channel.

func (ClusterClient) Quit

func (c ClusterClient) Quit() *StatusCmd

func (ClusterClient) RPop

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

func (ClusterClient) RPopLPush

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

func (ClusterClient) RPush

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

func (ClusterClient) RPushX

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

func (ClusterClient) RandomKey

func (c ClusterClient) RandomKey() *StringCmd

func (ClusterClient) ReadOnly

func (c ClusterClient) ReadOnly() *StatusCmd

func (ClusterClient) ReadWrite

func (c ClusterClient) ReadWrite() *StatusCmd

func (*ClusterClient) ReloadState

func (c *ClusterClient) ReloadState() error

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

func (ClusterClient) Rename

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

func (ClusterClient) RenameNX

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

func (ClusterClient) Restore

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

func (ClusterClient) RestoreReplace

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

func (ClusterClient) SAdd

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

func (ClusterClient) SCard

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

func (ClusterClient) SDiff

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

func (ClusterClient) SDiffStore

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

func (ClusterClient) SInter

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

func (ClusterClient) SInterStore

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

func (ClusterClient) SIsMember

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

func (ClusterClient) SMembers

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

Redis `SMEMBERS key` command output as a slice

func (ClusterClient) SMembersMap

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

Redis `SMEMBERS key` command output as a map

func (ClusterClient) SMove

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

func (ClusterClient) SPop

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

Redis `SPOP key` command.

func (ClusterClient) SPopN

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

Redis `SPOP key count` command.

func (ClusterClient) SRandMember

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

Redis `SRANDMEMBER key` command.

func (ClusterClient) SRandMemberN

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

Redis `SRANDMEMBER key count` command.

func (ClusterClient) SRem

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

func (ClusterClient) SScan

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

func (ClusterClient) SUnion

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

func (ClusterClient) SUnionStore

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

func (ClusterClient) Save

func (c ClusterClient) Save() *StatusCmd

func (ClusterClient) Scan

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

func (ClusterClient) ScriptExists

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

func (ClusterClient) ScriptFlush

func (c ClusterClient) ScriptFlush() *StatusCmd

func (ClusterClient) ScriptKill

func (c ClusterClient) ScriptKill() *StatusCmd

func (ClusterClient) ScriptLoad

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

func (ClusterClient) Set

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

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

func (ClusterClient) SetNX

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

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

func (ClusterClient) SetXX

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

func (c ClusterClient) Shutdown() *StatusCmd

func (ClusterClient) ShutdownNoSave

func (c ClusterClient) ShutdownNoSave() *StatusCmd

func (ClusterClient) ShutdownSave

func (c ClusterClient) ShutdownSave() *StatusCmd

func (ClusterClient) SlaveOf

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

func (ClusterClient) SlowLog

func (c ClusterClient) SlowLog()

func (ClusterClient) Sort

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

func (ClusterClient) SortInterfaces

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

func (ClusterClient) SortStore

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

func (ClusterClient) StrLen

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

func (*ClusterClient) Subscribe

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

func (c ClusterClient) Sync()

func (ClusterClient) TTL

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

func (ClusterClient) Time

func (c ClusterClient) Time() *TimeCmd

func (ClusterClient) Touch

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

func (*ClusterClient) TxPipeline

func (c *ClusterClient) TxPipeline() Pipeliner

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

func (*ClusterClient) TxPipelined

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

func (ClusterClient) Type

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

func (ClusterClient) Wait

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

func (*ClusterClient) Watch

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

func (*ClusterClient) WatchContext

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

func (*ClusterClient) WithContext

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

func (ClusterClient) XAck

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

func (ClusterClient) XAdd

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

func (ClusterClient) XClaim

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

func (ClusterClient) XClaimJustID

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

func (ClusterClient) XDel

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

func (ClusterClient) XGroupCreate

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

func (ClusterClient) XGroupCreateMkStream

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

func (ClusterClient) XGroupDelConsumer

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

func (ClusterClient) XGroupDestroy

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

func (ClusterClient) XGroupSetID

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

func (ClusterClient) XInfoGroups

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

func (ClusterClient) XLen

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

func (ClusterClient) XPending

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

func (ClusterClient) XPendingExt

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

func (ClusterClient) XRange

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

func (ClusterClient) XRangeN

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

func (ClusterClient) XRead

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

func (ClusterClient) XReadGroup

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

func (ClusterClient) XReadStreams

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

func (ClusterClient) XRevRange

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

func (ClusterClient)