godis

README

godis

redis client implement by golang, refer to jedis.

Features

• cluster
• pipeline
• transaction
• distributed lock
• other feature under development

Installation

go get -u github.com/piaohao/godis

or use go.mod:

require github.com/piaohao/godis latest

Documentation

• ApiDoc

Quick Start

1. basic example

   package main
   
   import (
       "github.com/piaohao/godis"
   )
   
   func main() {
       redis := godis.NewRedis(&godis.Option{
           Host: "localhost",
           Port: 6379,
           Db:   0,
       })
       defer redis.Close()
       redis.Set("godis", "1")
       arr, _ := redis.Get("godis")
       println(string(arr))
   }
   

2. use pool

   package main
   
   import (
       "github.com/piaohao/godis"
   )
   
   func main() {
       option:=&godis.Option{
           Host: "localhost",
           Port: 6379,
           Db:   0,
       }
       pool := godis.NewPool(&godis.PoolConfig{}, option)
       redis, _ := pool.Get()
       defer redis.Close()
       redis.Set("godis", "1")
       arr, _ := redis.Get("godis")
       println(string(arr))
   }
   

3. pubsub

   package main
   
   import (
       "github.com/piaohao/godis"
       "time"
   )
   
   func main() {
       option:=&godis.Option{
           Host: "localhost",
           Port: 6379,
           Db:   0,
       }
       pool := godis.NewPool(&godis.PoolConfig{}, option)
       go func() {
           redis, _ := pool.Get()
           defer redis.Close()
           pubsub := &godis.RedisPubSub{
               OnMessage: func(channel, message string) {
                   println(channel, message)
               },
               OnSubscribe: func(channel string, subscribedChannels int) {
                   println(channel, subscribedChannels)
               },
               OnPong: func(channel string) {
                   println("recieve pong")
               },
           }
           redis.Subscribe(pubsub, "godis")
       }()
       time.Sleep(1 * time.Second)
       {
           redis, _ := pool.Get()
           defer redis.Close()
           redis.Publish("godis", "godis pubsub")
           redis.Close()
       }
       time.Sleep(1 * time.Second)
   }
   

4. cluster

   package main
   
   import (
       "github.com/piaohao/godis"
       "time"
   )
   
   func main() {
       cluster := godis.NewRedisCluster(&godis.ClusterOption{
           Nodes:             []string{"localhost:7000", "localhost:7001", "localhost:7002", "localhost:7003", "localhost:7004", "localhost:7005"},
           ConnectionTimeout: 0,
           SoTimeout:         0,
           MaxAttempts:       0,
           Password:          "",
           PoolConfig:        &godis.PoolConfig{},
       })
       cluster.Set("cluster", "godis cluster")
       reply, _ := cluster.Get("cluster")
       println(reply)
   }
   

5. pipeline

   package main
   
   import (
       "github.com/piaohao/godis"
       "time"
   )
   
   func main() {
       option:=&godis.Option{
           Host: "localhost",
           Port: 6379,
           Db:   0,
       }
       pool := godis.NewPool(&godis.PoolConfig{}, option)
       redis, _ := pool.Get()
       defer redis.Close()
       p := redis.Pipelined()
       infoResp, _ := p.Info()
       timeResp, _ := p.Time()
       p.Sync()
       timeList, _ := timeResp.Get()
       println(timeList)
       info, _ := infoResp.Get()
       println(info)
   }
   

6. transaction

   package main
   
   import (
       "github.com/piaohao/godis"
       "time"
   )
   
   func main() {
       option:=&godis.Option{
           Host: "localhost",
           Port: 6379,
           Db:   0,
       }
       pool := godis.NewPool(nil, option)
       redis, _ := pool.Get()
       defer redis.Close()
       p, _ := redis.Multi()
       infoResp, _ := p.Info()
       timeResp, _ := p.Time()
       p.Exec()
       timeList, _ := timeResp.Get()
       println(timeList)
       info, _ := infoResp.Get()
       println(info)
   }
   

7. distribute lock

   • single redis

        package main
     
        import (
            "github.com/piaohao/godis"
            "time"
        )
     
        func main() {
            locker := godis.NewLocker(&godis.Option{
                  Host: "localhost",
                  Port: 6379,
                  Db:   0,
              }, &godis.LockOption{
                  Timeout: 5*time.Second,
              })
            ok, err := locker.TryLock("lock")
            if err == nil && ok {
                //do something
            }
            locker.UnLock()
        }
     

   • redis cluster

        package main
     
        import (
            "github.com/piaohao/godis"
            "time"
        )
     
        func main() {
            locker := godis.NewClusterLocker(&godis.ClusterOption{
            	Nodes:             []string{"localhost:7000", "localhost:7001", "localhost:7002", "localhost:7003", "localhost:7004", "localhost:7005"},
                ConnectionTimeout: 0,
                SoTimeout:         0,
                MaxAttempts:       0,
                Password:          "",
                PoolConfig:        &godis.PoolConfig{},
            },&godis.LockOption{
                Timeout: 5*time.Second,
            })
            ok, err := locker.TryLock("lock")
            if err == nil && ok {
                //do something
            }
            locker.UnLock()
        }
     

License

godis is licensed under the MIT License, 100% free and open-source, forever.

Thanks

• jedis
• gf

Contact

piao.hao@qq.com

Documentation

Overview

godis

Index

• Constants
• Variables
• func BoolToByteArray(a bool) []byte
• func ByteArrayToFloat64(bytes []byte) float64
• func ByteArrayToInt64(bytes []byte) uint64
• func ByteToStringReply(reply []byte, err error) (string, error)
• func Float64ToByteArray(a float64) []byte
• func GoID() (int, error)
• func Int64ToBoolReply(reply int64, err error) (bool, error)
• func Int64ToByteArray(a int64) []byte
• func IntToByteArray(a int) []byte
• func NewClusterLocker(option *ClusterOption, lockOption *LockOption) *clusterLocker
• func NewLocker(option *Option, lockOption *LockOption) *locker
• func ObjectArrToMapArrayReply(reply []interface{}, err error) ([]map[string]string, error)
• func ObjectToEvalResult(reply interface{}, err error) (interface{}, error)
• func StringArrayToByteArray(arr []string) [][]byte
• func StringArrayToMapReply(reply []string, err error) (map[string]string, error)
• func StringStringArrayToByteArray(str string, arr []string) [][]byte
• func StringStringArrayToStringArray(str string, arr []string) []string
• func StringToFloat64Reply(reply string, err error) (float64, error)
• func ToBoolArrayReply(reply interface{}, err error) ([]bool, error)
• func ToBoolReply(reply interface{}, err error) (bool, error)
• func ToFloat64Reply(reply interface{}, err error) (float64, error)
• func ToInt64ArrayReply(reply interface{}, err error) ([]int64, error)
• func ToInt64Reply(reply interface{}, err error) (int64, error)
• func ToMapReply(reply interface{}, err error) (map[string]string, error)
• func ToStringArrayReply(reply interface{}, err error) ([]string, error)
• func ToStringReply(reply interface{}, err error) (string, error)
• type AskDataError
  • func NewAskDataError(message string, host string, port int, slot int) *AskDataError
  • func (e *AskDataError) Error() string
• type BitOP
  • func NewBitOP(name string) BitOP
  • func (g BitOP) GetRaw() []byte
• type BitPosParams
• type Builder
• type BusyError
  • func NewBusyError(message string) *BusyError
  • func (e *BusyError) Error() string
• type ClusterError
  • func NewClusterError(message string) *ClusterError
  • func (e *ClusterError) Error() string
• type ClusterOption
• type ConnectError
  • func NewConnectError(message string) *ConnectError
  • func (e *ConnectError) Error() string
• type DataError
  • func NewDataError(message string) *DataError
  • func (e *DataError) Error() string
• type DebugParams
  • func NewDebugParamsObject(key string) *DebugParams
  • func NewDebugParamsReload() *DebugParams
  • func NewDebugParamsSegfault() *DebugParams
• type GeoCoordinate
  • func ObjectArrToGeoCoordinateReply(reply []interface{}, err error) ([]*GeoCoordinate, error)
  • func ToGeoArrayReply(reply interface{}, err error) ([]*GeoCoordinate, error)
• type GeoRadiusParam
  • func (g GeoRadiusParam) Contains(key string) bool
  • func (g GeoRadiusParam) GetParams(args [][]byte) [][]byte
• type GeoRadiusResponse
• type GeoUnit
  • func NewGeoUnit(name string) GeoUnit
  • func (g GeoUnit) GetRaw() []byte
• type ListOption
  • func NewListOption(name string) ListOption
  • func (l ListOption) GetRaw() []byte
• type LockOption
• type Locker
• type MovedDataError
  • func NewMovedDataError(message string, host string, port int, slot int) *MovedDataError
  • func (e *MovedDataError) Error() string
• type NoReachableClusterNodeError
  • func NewNoReachableClusterNodeError(message string) *NoReachableClusterNodeError
  • func (e *NoReachableClusterNodeError) Error() string
• type NoScriptError
  • func NewNoScriptError(message string) *NoScriptError
  • func (e *NoScriptError) Error() string
• type Option
• type Pool
  • func NewPool(config *PoolConfig, option *Option) *Pool
  • func (p *Pool) Close(redis *Redis) error
  • func (p *Pool) Destroy() error
  • func (p *Pool) Get() (*Redis, error)
  • func (p *Pool) Put(redis *Redis) error
• type PoolConfig
• type Redis
  • func NewRedis(option *Option) *Redis
  • func (r *Redis) Append(key, value string) (int64, error)
  • func (r *Redis) Asking() (string, error)
  • func (r *Redis) Auth(password string) (string, error)
  • func (r *Redis) Bgrewriteaof() (string, error)
  • func (r *Redis) Bgsave() (string, error)
  • func (r *Redis) Bitcount(key string) (int64, error)
  • func (r *Redis) BitcountRange(key string, start, end int64) (int64, error)
  • func (r *Redis) Bitfield(key string, arguments ...string) ([]int64, error)
  • func (r *Redis) Bitop(op BitOP, destKey string, srcKeys ...string) (int64, error)
  • func (r *Redis) Bitpos(key string, value bool, params ...BitPosParams) (int64, error)
  • func (r *Redis) Blpop(args ...string) ([]string, error)
  • func (r *Redis) BlpopTimout(timeout int, keys ...string) ([]string, error)
  • func (r *Redis) Brpop(args ...string) ([]string, error)
  • func (r *Redis) BrpopTimout(timeout int, keys ...string) ([]string, error)
  • func (r *Redis) Brpoplpush(source, destination string, timeout int) (string, error)
  • func (r *Redis) Close() error
  • func (r *Redis) ClusterAddSlots(slots ...int) (string, error)
  • func (r *Redis) ClusterCountKeysInSlot(slot int) (int64, error)
  • func (r *Redis) ClusterDelSlots(slots ...int) (string, error)
  • func (r *Redis) ClusterFailover() (string, error)
  • func (r *Redis) ClusterFlushSlots() (string, error)
  • func (r *Redis) ClusterForget(nodeId string) (string, error)
  • func (r *Redis) ClusterGetKeysInSlot(slot int, count int) ([]string, error)
  • func (r *Redis) ClusterInfo() (string, error)
  • func (r *Redis) ClusterKeySlot(key string) (int64, error)
  • func (r *Redis) ClusterMeet(ip string, port int) (string, error)
  • func (r *Redis) ClusterNodes() (string, error)
  • func (r *Redis) ClusterReplicate(nodeId string) (string, error)
  • func (r *Redis) ClusterReset(resetType Reset) (string, error)
  • func (r *Redis) ClusterSaveConfig() (string, error)
  • func (r *Redis) ClusterSetSlotImporting(slot int, nodeId string) (string, error)
  • func (r *Redis) ClusterSetSlotMigrating(slot int, nodeId string) (string, error)
  • func (r *Redis) ClusterSetSlotNode(slot int, nodeId string) (string, error)
  • func (r *Redis) ClusterSetSlotStable(slot int) (string, error)
  • func (r *Redis) ClusterSlaves(nodeId string) ([]string, error)
  • func (r *Redis) ClusterSlots() ([]interface{}, error)
  • func (r *Redis) ConfigGet(pattern string) ([]string, error)
  • func (r *Redis) ConfigResetStat() (string, error)
  • func (r *Redis) ConfigSet(parameter, value string) (string, error)
  • func (r *Redis) Connect() error
  • func (r *Redis) DbSize() (int64, error)
  • func (r *Redis) Debug(params DebugParams) (string, error)
  • func (r *Redis) Decr(key string) (int64, error)
  • func (r *Redis) DecrBy(key string, decrement int64) (int64, error)
  • func (r *Redis) Del(key ...string) (int64, error)
  • func (r *Redis) Echo(string string) (string, error)
  • func (r *Redis) Eval(script string, keyCount int, params ...string) (interface{}, error)
  • func (r *Redis) EvalByKeyArgs(script string, keys []string, args []string) (interface{}, error)
  • func (r *Redis) Evalsha(sha1 string, keyCount int, params ...string) (interface{}, error)
  • func (r *Redis) Exists(keys ...string) (int64, error)
  • func (r *Redis) Expire(key string, seconds int) (int64, error)
  • func (r *Redis) ExpireAt(key string, unixtime int64) (int64, error)
  • func (r *Redis) FlushAll() (string, error)
  • func (r *Redis) FlushDB() (string, error)
  • func (r *Redis) Geoadd(key string, longitude, latitude float64, member string) (int64, error)
  • func (r *Redis) GeoaddByMap(key string, memberCoordinateMap map[string]GeoCoordinate) (int64, error)
  • func (r *Redis) Geodist(key, member1, member2 string, unit ...GeoUnit) (float64, error)
  • func (r *Redis) Geohash(key string, members ...string) ([]string, error)
  • func (r *Redis) Geopos(key string, members ...string) ([]*GeoCoordinate, error)
  • func (r *Redis) Georadius(key string, longitude, latitude, radius float64, unit GeoUnit, ...) ([]*GeoCoordinate, error)
  • func (r *Redis) GeoradiusByMember(key, member string, radius float64, unit GeoUnit, param ...GeoRadiusParam) ([]*GeoCoordinate, error)
  • func (r *Redis) Get(key string) (string, error)
  • func (r *Redis) GetDB() int
  • func (r *Redis) GetSet(key, value string) (string, error)
  • func (r *Redis) Getbit(key string, offset int64) (bool, error)
  • func (r *Redis) Getrange(key string, startOffset, endOffset int64) (string, error)
  • func (r *Redis) Hdel(key string, fields ...string) (int64, error)
  • func (r *Redis) Hexists(key, field string) (bool, error)
  • func (r *Redis) Hget(key, field string) (string, error)
  • func (r *Redis) HgetAll(key string) (map[string]string, error)
  • func (r *Redis) HincrBy(key, field string, value int64) (int64, error)
  • func (r *Redis) HincrByFloat(key, field string, value float64) (float64, error)
  • func (r *Redis) Hkeys(key string) ([]string, error)
  • func (r *Redis) Hlen(key string) (int64, error)
  • func (r *Redis) Hmget(key string, fields ...string) ([]string, error)
  • func (r *Redis) Hmset(key string, hash map[string]string) (string, error)
  • func (r *Redis) Hscan(key, cursor string, params ...ScanParams) (*ScanResult, error)
  • func (r *Redis) Hset(key, field, value string) (int64, error)
  • func (r *Redis) Hsetnx(key, field, value string) (int64, error)
  • func (r *Redis) Hvals(key string) ([]string, error)
  • func (r *Redis) Incr(key string) (int64, error)
  • func (r *Redis) IncrBy(key string, increment int64) (int64, error)
  • func (r *Redis) IncrByFloat(key string, increment float64) (float64, error)
  • func (r *Redis) Info(section ...string) (string, error)
  • func (r *Redis) Keys(pattern string) ([]string, error)
  • func (r *Redis) Lastsave() (int64, error)
  • func (r *Redis) Lindex(key string, index int64) (string, error)
  • func (r *Redis) Linsert(key string, where ListOption, pivot, value string) (int64, error)
  • func (r *Redis) Llen(key string) (int64, error)
  • func (r *Redis) Lpop(key string) (string, error)
  • func (r *Redis) Lpush(key string, strings ...string) (int64, error)
  • func (r *Redis) Lpushx(key string, string ...string) (int64, error)
  • func (r *Redis) Lrange(key string, start, stop int64) ([]string, error)
  • func (r *Redis) Lrem(key string, count int64, value string) (int64, error)
  • func (r *Redis) Lset(key string, index int64, value string) (string, error)
  • func (r *Redis) Ltrim(key string, start, stop int64) (string, error)
  • func (r *Redis) Mget(keys ...string) ([]string, error)
  • func (r *Redis) Move(key string, dbIndex int) (int64, error)
  • func (r *Redis) Mset(keysvalues ...string) (string, error)
  • func (r *Redis) Msetnx(keysvalues ...string) (int64, error)
  • func (r *Redis) Multi() (*transaction, error)
  • func (r *Redis) ObjectEncoding(str string) (string, error)
  • func (r *Redis) ObjectIdletime(str string) (int64, error)
  • func (r *Redis) ObjectRefcount(str string) (int64, error)
  • func (r *Redis) Persist(key string) (int64, error)
  • func (r *Redis) Pexpire(key string, milliseconds int64) (int64, error)
  • func (r *Redis) PexpireAt(key string, millisecondsTimestamp int64) (int64, error)
  • func (r *Redis) Pfadd(key string, elements ...string) (int64, error)
  • func (r *Redis) Pfcount(keys ...string) (int64, error)
  • func (r *Redis) Pfmerge(destkey string, sourcekeys ...string) (string, error)
  • func (r *Redis) Ping() (string, error)
  • func (r *Redis) Pipelined() *pipeline
  • func (r *Redis) Psetex(key string, milliseconds int64, value string) (string, error)
  • func (r *Redis) Psubscribe(redisPubSub *RedisPubSub, patterns ...string) error
  • func (r *Redis) Pttl(key string) (int64, error)
  • func (r *Redis) Publish(channel, message string) (int64, error)
  • func (r *Redis) PubsubChannels(pattern string) ([]string, error)
  • func (r *Redis) Quit() (string, error)
  • func (r *Redis) RandomKey() (string, error)
  • func (r *Redis) Readonly() (string, error)
  • func (r *Redis) Receive() error
  • func (r *Redis) Rename(oldkey, newkey string) (string, error)
  • func (r *Redis) Renamenx(oldkey, newkey string) (int64, error)
  • func (r *Redis) Rpop(key string) (string, error)
  • func (r *Redis) Rpoplpush(srckey, dstkey string) (string, error)
  • func (r *Redis) Rpush(key string, strings ...string) (int64, error)
  • func (r *Redis) Rpushx(key string, string ...string) (int64, error)
  • func (r *Redis) Sadd(key string, members ...string) (int64, error)
  • func (r *Redis) Save() (string, error)
  • func (r *Redis) Scan(cursor string, params ...ScanParams) (*ScanResult, error)
  • func (r *Redis) Scard(key string) (int64, error)
  • func (r *Redis) ScriptExists(sha1 ...string) ([]bool, error)
  • func (r *Redis) ScriptLoad(script string) (string, error)
  • func (r *Redis) Sdiff(keys ...string) ([]string, error)
  • func (r *Redis) Sdiffstore(dstkey string, keys ...string) (int64, error)
  • func (r *Redis) Select(index int) (string, error)
  • func (r *Redis) Send(command protocolCommand, args ...[]byte) error
  • func (r *Redis) SendByStr(command string, args ...[]byte) error
  • func (r *Redis) SentinelFailover(masterName string) (string, error)
  • func (r *Redis) SentinelGetMasterAddrByName(masterName string) ([]string, error)
  • func (r *Redis) SentinelMasters() ([]map[string]string, error)
  • func (r *Redis) SentinelMonitor(masterName, ip string, port, quorum int) (string, error)
  • func (r *Redis) SentinelRemove(masterName string) (string, error)
  • func (r *Redis) SentinelReset(pattern string) (int64, error)
  • func (r *Redis) SentinelSet(masterName string, parameterMap map[string]string) (string, error)
  • func (r *Redis) SentinelSlaves(masterName string) ([]map[string]string, error)
  • func (r *Redis) Set(key, value string) (string, error)
  • func (r *Redis) SetWithParams(key, value, nxxx string) (string, error)
  • func (r *Redis) SetWithParamsAndTime(key, value, nxxx, expx string, time int64) (string, error)
  • func (r *Redis) Setbit(key string, offset int64, value string) (bool, error)
  • func (r *Redis) SetbitWithBool(key string, offset int64, value bool) (bool, error)
  • func (r *Redis) Setex(key string, seconds int, value string) (string, error)
  • func (r *Redis) Setnx(key, value string) (int64, error)
  • func (r *Redis) Setrange(key string, offset int64, value string) (int64, error)
  • func (r *Redis) Shutdown() (string, error)
  • func (r *Redis) Sinter(keys ...string) ([]string, error)
  • func (r *Redis) Sinterstore(dstkey string, keys ...string) (int64, error)
  • func (r *Redis) Sismember(key, member string) (bool, error)
  • func (r *Redis) Slaveof(host string, port int) (string, error)
  • func (r *Redis) SlaveofNoOne() (string, error)
  • func (r *Redis) SlowlogGet(entries ...int64) ([]Slowlog, error)
  • func (r *Redis) SlowlogLen() (int64, error)
  • func (r *Redis) SlowlogReset() (string, error)
  • func (r *Redis) Smembers(key string) ([]string, error)
  • func (r *Redis) Smove(srckey, dstkey, member string) (int64, error)
  • func (r *Redis) Sort(key string, sortingParameters ...SortingParams) ([]string, error)
  • func (r *Redis) SortMulti(key, dstkey string, sortingParameters ...SortingParams) (int64, error)
  • func (r *Redis) Spop(key string) (string, error)
  • func (r *Redis) SpopBatch(key string, count int64) ([]string, error)
  • func (r *Redis) Srandmember(key string) (string, error)
  • func (r *Redis) SrandmemberBatch(key string, count int) ([]string, error)
  • func (r *Redis) Srem(key string, members ...string) (int64, error)
  • func (r *Redis) Sscan(key, cursor string, params ...ScanParams) (*ScanResult, error)
  • func (r *Redis) Strlen(key string) (int64, error)
  • func (r *Redis) Subscribe(redisPubSub *RedisPubSub, channels ...string) error
  • func (r *Redis) Substr(key string, start, end int) (string, error)
  • func (r *Redis) Sunion(keys ...string) ([]string, error)
  • func (r *Redis) Sunionstore(dstkey string, keys ...string) (int64, error)
  • func (r *Redis) Ttl(key string) (int64, error)
  • func (r *Redis) Type(key string) (string, error)
  • func (r *Redis) Unwatch() (string, error)
  • func (r *Redis) WaitReplicas(replicas int, timeout int64) (int64, error)
  • func (r *Redis) Watch(keys ...string) (string, error)
  • func (r *Redis) Zadd(key string, score float64, member string, mparams ...ZAddParams) (int64, error)
  • func (r *Redis) ZaddByMap(key string, scoreMembers map[string]float64, params ...ZAddParams) (int64, error)
  • func (r *Redis) Zcard(key string) (int64, error)
  • func (r *Redis) Zcount(key, min, max string) (int64, error)
  • func (r *Redis) Zincrby(key string, increment float64, member string, params ...ZAddParams) (float64, error)
  • func (r *Redis) Zinterstore(dstkey string, sets ...string) (int64, error)
  • func (r *Redis) ZinterstoreWithParams(dstkey string, params ZParams, sets ...string) (int64, error)
  • func (r *Redis) Zlexcount(key, min, max string) (int64, error)
  • func (r *Redis) Zrange(key string, start, stop int64) ([]string, error)
  • func (r *Redis) ZrangeByLex(key, min, max string) ([]string, error)
  • func (r *Redis) ZrangeByLexBatch(key, min, max string, offset, count int) ([]string, error)
  • func (r *Redis) ZrangeByScore(key, min, max string) ([]string, error)
  • func (r *Redis) ZrangeByScoreBatch(key, min, max string, offset, count int) ([]string, error)
  • func (r *Redis) ZrangeByScoreWithScores(key, min, max string) ([]Tuple, error)
  • func (r *Redis) ZrangeByScoreWithScoresBatch(key, min, max string, offset, count int) ([]Tuple, error)
  • func (r *Redis) ZrangeWithScores(key string, start, end int64) ([]Tuple, error)
  • func (r *Redis) Zrank(key, member string) (int64, error)
  • func (r *Redis) Zrem(key string, members ...string) (int64, error)
  • func (r *Redis) ZremrangeByLex(key, min, max string) (int64, error)
  • func (r *Redis) ZremrangeByRank(key string, start, stop int64) (int64, error)
  • func (r *Redis) ZremrangeByScore(key, start, end string) (int64, error)
  • func (r *Redis) Zrevrange(key string, start, stop int64) ([]string, error)
  • func (r *Redis) ZrevrangeByLex(key, max, min string) ([]string, error)
  • func (r *Redis) ZrevrangeByLexBatch(key, max, min string, offset, count int) ([]string, error)
  • func (r *Redis) ZrevrangeByScore(key, max, min string) ([]string, error)
  • func (r *Redis) ZrevrangeByScoreWithScores(key, max, min string) ([]Tuple, error)
  • func (r *Redis) ZrevrangeByScoreWithScoresBatch(key, max, min string, offset, count int) ([]Tuple, error)
  • func (r *Redis) ZrevrangeWithScores(key string, start, end int64) ([]Tuple, error)
  • func (r *Redis) Zrevrank(key, member string) (int64, error)
  • func (r *Redis) Zscan(key, cursor string, params ...ScanParams) (*ScanResult, error)
  • func (r *Redis) Zscore(key, member string) (float64, error)
  • func (r *Redis) Zunionstore(dstkey string, sets ...string) (int64, error)
  • func (r *Redis) ZunionstoreWithParams(dstkey string, params ZParams, sets ...string) (int64, error)
• type RedisCluster
  • func NewRedisCluster(option *ClusterOption) *RedisCluster
  • func (r *RedisCluster) Append(key, value string) (int64, error)
  • func (r *RedisCluster) Bitcount(key string) (int64, error)
  • func (r *RedisCluster) BitcountRange(key string, start int64, end int64) (int64, error)
  • func (r *RedisCluster) Bitfield(key string, arguments ...string) ([]int64, error)
  • func (r *RedisCluster) Bitop(op BitOP, destKey string, srcKeys ...string) (int64, error)
  • func (r *RedisCluster) Bitpos(key string, value bool, params ...BitPosParams) (int64, error)
  • func (r *RedisCluster) Blpop(args ...string) ([]string, error)
  • func (r *RedisCluster) BlpopTimout(timeout int, keys ...string) ([]string, error)
  • func (r *RedisCluster) Brpop(args ...string) ([]string, error)
  • func (r *RedisCluster) BrpopTimout(timeout int, keys ...string) ([]string, error)
  • func (r *RedisCluster) Brpoplpush(source, destination string, timeout int) (string, error)
  • func (r *RedisCluster) Decr(key string) (int64, error)
  • func (r *RedisCluster) DecrBy(key string, decrement int64) (int64, error)
  • func (r *RedisCluster) Del(keys ...string) (int64, error)
  • func (r *RedisCluster) Echo(str string) (string, error)
  • func (r *RedisCluster) Eval(script string, keyCount int, params ...string) (interface{}, error)
  • func (r *RedisCluster) Evalsha(sha1 string, keyCount int, params ...string) (interface{}, error)
  • func (r *RedisCluster) Exists(keys ...string) (int64, error)
  • func (r *RedisCluster) Expire(key string, seconds int) (int64, error)
  • func (r *RedisCluster) ExpireAt(key string, unixtime int64) (int64, error)
  • func (r *RedisCluster) Geoadd(key string, longitude, latitude float64, member string) (int64, error)
  • func (r *RedisCluster) GeoaddByMap(key string, memberCoordinateMap map[string]GeoCoordinate) (int64, error)
  • func (r *RedisCluster) Geodist(key string, member1, member2 string, unit ...GeoUnit) (float64, error)
  • func (r *RedisCluster) Geohash(key string, members ...string) ([]string, error)
  • func (r *RedisCluster) Geopos(key string, members ...string) ([]*GeoCoordinate, error)
  • func (r *RedisCluster) Georadius(key string, longitude, latitude, radius float64, unit GeoUnit, ...) ([]*GeoCoordinate, error)
  • func (r *RedisCluster) GeoradiusByMember(key string, member string, radius float64, unit GeoUnit, ...) ([]*GeoCoordinate, error)
  • func (r *RedisCluster) Get(key string) (string, error)
  • func (r *RedisCluster) GetSet(key, value string) (string, error)
  • func (r *RedisCluster) Getbit(key string, offset int64) (bool, error)
  • func (r *RedisCluster) Getrange(key string, startOffset, endOffset int64) (string, error)
  • func (r *RedisCluster) Hdel(key string, fields ...string) (int64, error)
  • func (r *RedisCluster) Hexists(key, field string) (bool, error)
  • func (r *RedisCluster) Hget(key, field string) (string, error)
  • func (r *RedisCluster) HgetAll(key string) (map[string]string, error)
  • func (r *RedisCluster) HincrBy(key, field string, value int64) (int64, error)
  • func (r *RedisCluster) HincrByFloat(key, field string, value float64) (float64, error)
  • func (r *RedisCluster) Hkeys(key string) ([]string, error)
  • func (r *RedisCluster) Hlen(key string) (int64, error)
  • func (r *RedisCluster) Hmget(key string, fields ...string) ([]string, error)
  • func (r *RedisCluster) Hmset(key string, hash map[string]string) (string, error)
  • func (r *RedisCluster) Hscan(key, cursor string, params ...ScanParams) (*ScanResult, error)
  • func (r *RedisCluster) Hset(key, field string, value string) (int64, error)
  • func (r *RedisCluster) Hsetnx(key, field, value string) (int64, error)
  • func (r *RedisCluster) Hvals(key string) ([]string, error)
  • func (r *RedisCluster) Incr(key string) (int64, error)
  • func (r *RedisCluster) IncrBy(key string, increment int64) (int64, error)
  • func (r *RedisCluster) IncrByFloat(key string, increment float64) (float64, error)
  • func (r *RedisCluster) Keys(pattern string) ([]string, error)
  • func (r *RedisCluster) Lindex(key string, index int64) (string, error)
  • func (r *RedisCluster) Linsert(key string, where ListOption, pivot, value string) (int64, error)
  • func (r *RedisCluster) Llen(key string) (int64, error)
  • func (r *RedisCluster) Lpop(key string) (string, error)
  • func (r *RedisCluster) Lpush(key string, strings ...string) (int64, error)
  • func (r *RedisCluster) Lpushx(key string, strs ...string) (int64, error)
  • func (r *RedisCluster) Lrange(key string, start, stop int64) ([]string, error)
  • func (r *RedisCluster) Lrem(key string, count int64, value string) (int64, error)
  • func (r *RedisCluster) Lset(key string, index int64, value string) (string, error)
  • func (r *RedisCluster) Ltrim(key string, start, stop int64) (string, error)
  • func (r *RedisCluster) Mget(keys ...string) ([]string, error)
  • func (r *RedisCluster) Move(key string, dbIndex int) (int64, error)
  • func (r *RedisCluster) Mset(keysvalues ...string) (string, error)
  • func (r *RedisCluster) Msetnx(keysvalues ...string) (int64, error)
  • func (r *RedisCluster) Persist(key string) (int64, error)
  • func (r *RedisCluster) Pexpire(key string, milliseconds int64) (int64, error)
  • func (r *RedisCluster) PexpireAt(key string, millisecondsTimestamp int64) (int64, error)
  • func (r *RedisCluster) Pfadd(key string, elements ...string) (int64, error)
  • func (r *RedisCluster) Pfcount(keys ...string) (int64, error)
  • func (r *RedisCluster) Pfmerge(destkey string, sourcekeys ...string) (string, error)
  • func (r *RedisCluster) Psetex(key string, milliseconds int64, value string) (string, error)
  • func (r *RedisCluster) Psubscribe(redisPubSub *RedisPubSub, patterns ...string) error
  • func (r *RedisCluster) Pttl(key string) (int64, error)
  • func (r *RedisCluster) Publish(channel, message string) (int64, error)
  • func (r *RedisCluster) RandomKey() (string, error)
  • func (r *RedisCluster) Rename(oldkey, newkey string) (string, error)
  • func (r *RedisCluster) Renamenx(oldkey, newkey string) (int64, error)
  • func (r *RedisCluster) Rpop(key string) (string, error)
  • func (r *RedisCluster) Rpoplpush(srckey, dstkey string) (string, error)
  • func (r *RedisCluster) Rpush(key string, strings ...string) (int64, error)
  • func (r *RedisCluster) Rpushx(key string, strs ...string) (int64, error)
  • func (r *RedisCluster) Sadd(key string, members ...string) (int64, error)
  • func (r *RedisCluster) Scan(cursor string, params ...ScanParams) (*ScanResult, error)
  • func (r *RedisCluster) Scard(key string) (int64, error)
  • func (r *RedisCluster) ScriptExists(key string, sha1 ...string) ([]bool, error)
  • func (r *RedisCluster) ScriptLoad(key, script string) (string, error)
  • func (r *RedisCluster) Sdiff(keys ...string) ([]string, error)
  • func (r *RedisCluster) Sdiffstore(dstkey string, keys ...string) (int64, error)
  • func (r *RedisCluster) Set(key, value string) (string, error)
  • func (r *RedisCluster) SetWithParams(key, value, nxxx string) (string, error)
  • func (r *RedisCluster) SetWithParamsAndTime(key, value, nxxx, expx string, time int64) (string, error)
  • func (r *RedisCluster) Setbit(key string, offset int64, value string) (bool, error)
  • func (r *RedisCluster) SetbitWithBool(key string, offset int64, value bool) (bool, error)
  • func (r *RedisCluster) Setex(key string, seconds int, value string) (string, error)
  • func (r *RedisCluster) Setnx(key, value string) (int64, error)
  • func (r *RedisCluster) Setrange(key string, offset int64, value string) (int64, error)
  • func (r *RedisCluster) Sinter(keys ...string) ([]string, error)
  • func (r *RedisCluster) Sinterstore(dstkey string, keys ...string) (int64, error)
  • func (r *RedisCluster) Sismember(key string, member string) (bool, error)
  • func (r *RedisCluster) Smembers(key string) ([]string, error)
  • func (r *RedisCluster) Smove(srckey, dstkey, member string) (int64, error)
  • func (r *RedisCluster) Sort(key string, sortingParameters ...SortingParams) ([]string, error)
  • func (r *RedisCluster) SortMulti(key, dstkey string, sortingParameters ...SortingParams) (int64, error)
  • func (r *RedisCluster) Spop(key string) (string, error)
  • func (r *RedisCluster) SpopBatch(key string, count int64) ([]string, error)
  • func (r *RedisCluster) Srandmember(key string) (string, error)
  • func (r *RedisCluster) SrandmemberBatch(key string, count int) ([]string, error)
  • func (r *RedisCluster) Srem(key string, members ...string) (int64, error)
  • func (r *RedisCluster) Sscan(key, cursor string, params ...ScanParams) (*ScanResult, error)
  • func (r *RedisCluster) Strlen(key string) (int64, error)
  • func (r *RedisCluster) Subscribe(redisPubSub *RedisPubSub, channels ...string) error
  • func (r *RedisCluster) Substr(key string, start, end int) (string, error)
  • func (r *RedisCluster) Sunion(keys ...string) ([]string, error)
  • func (r *RedisCluster) Sunionstore(dstkey string, keys ...string) (int64, error)
  • func (r *RedisCluster) Ttl(key string) (int64, error)
  • func (r *RedisCluster) Type(key string) (string, error)
  • func (r *RedisCluster) Unwatch() (string, error)
  • func (r *RedisCluster) Watch(keys ...string) (string, error)
  • func (r *RedisCluster) Zadd(key string, score float64, member string, params ...ZAddParams) (int64, error)
  • func (r *RedisCluster) ZaddByMap(key string, scoreMembers map[string]float64, params ...ZAddParams) (int64, error)
  • func (r *RedisCluster) Zcard(key string) (int64, error)
  • func (r *RedisCluster) Zcount(key string, min string, max string) (int64, error)
  • func (r *RedisCluster) Zincrby(key string, score float64, member string, params ...ZAddParams) (float64, error)
  • func (r *RedisCluster) Zinterstore(dstkey string, sets ...string) (int64, error)
  • func (r *RedisCluster) ZinterstoreWithParams(dstkey string, params ZParams, sets ...string) (int64, error)
  • func (r *RedisCluster) Zlexcount(key, min, max string) (int64, error)
  • func (r *RedisCluster) Zrange(key string, start, end int64) ([]string, error)
  • func (r *RedisCluster) ZrangeByLex(key, min, max string) ([]string, error)
  • func (r *RedisCluster) ZrangeByLexBatch(key, min, max string, offset, count int) ([]string, error)
  • func (r *RedisCluster) ZrangeByScore(key string, min string, max string) ([]string, error)
  • func (r *RedisCluster) ZrangeByScoreBatch(key string, min string, max string, offset int, count int) ([]string, error)
  • func (r *RedisCluster) ZrangeByScoreWithScores(key, min, max string) ([]Tuple, error)
  • func (r *RedisCluster) ZrangeByScoreWithScoresBatch(key, min, max string, offset, count int) ([]Tuple, error)
  • func (r *RedisCluster) ZrangeWithScores(key string, start, end int64) ([]Tuple, error)
  • func (r *RedisCluster) Zrank(key, member string) (int64, error)
  • func (r *RedisCluster) Zrem(key string, member ...string) (int64, error)
  • func (r *RedisCluster) ZremrangeByLex(key, min, max string) (int64, error)
  • func (r *RedisCluster) ZremrangeByRank(key string, start, end int64) (int64, error)
  • func (r *RedisCluster) ZremrangeByScore(key, start, end string) (int64, error)
  • func (r *RedisCluster) Zrevrange(key string, start, end int64) ([]string, error)
  • func (r *RedisCluster) ZrevrangeByLex(key, max, min string) ([]string, error)
  • func (r *RedisCluster) ZrevrangeByLexBatch(key, max, min string, offset, count int) ([]string, error)
  • func (r *RedisCluster) ZrevrangeByScore(key string, max string, min string) ([]string, error)
  • func (r *RedisCluster) ZrevrangeByScoreWithScores(key, max, min string) ([]Tuple, error)
  • func (r *RedisCluster) ZrevrangeByScoreWithScoresBatch(key, max, min string, offset, count int) ([]Tuple, error)
  • func (r *RedisCluster) ZrevrangeWithScores(key string, start, end int64) ([]Tuple, error)
  • func (r *RedisCluster) Zrevrank(key, member string) (int64, error)
  • func (r *RedisCluster) Zscan(key, cursor string, params ...ScanParams) (*ScanResult, error)
  • func (r *RedisCluster) Zscore(key, member string) (float64, error)
  • func (r *RedisCluster) Zunionstore(dstkey string, sets ...string) (int64, error)
  • func (r *RedisCluster) ZunionstoreWithParams(dstkey string, params ZParams, sets ...string) (int64, error)
• type RedisError
  • func NewRedisError(message string) *RedisError
  • func (e *RedisError) Error() string
• type RedisPubSub
  • func (r *RedisPubSub) Psubscribe(channels ...string) error
  • func (r *RedisPubSub) Punsubscribe(channels ...string) error
  • func (r *RedisPubSub) Subscribe(channels ...string) error
  • func (r *RedisPubSub) Unsubscribe(channels ...string) error
• type Reset
  • func NewReset(name string) Reset
  • func (g Reset) GetRaw() []byte
• type ScanParams
  • func NewScanParams() *ScanParams
  • func (s ScanParams) Count() int
  • func (s ScanParams) GetParams() [][]byte
  • func (s ScanParams) Match() string
• type ScanResult
  • func ObjectArrToScanResultReply(reply []interface{}, err error) (*ScanResult, error)
  • func ToScanResultReply(reply interface{}, err error) (*ScanResult, error)
• type Slowlog
• type SortingParams
• type Tuple
  • func StringArrToTupleReply(reply []string, err error) ([]Tuple, error)
  • func ToTupleArrayReply(reply interface{}, err error) ([]Tuple, error)
• type ZAddParams
  • func (p ZAddParams) Contains(key string) bool
  • func (p ZAddParams) GetByteParams(key []byte, args ...[]byte) [][]byte
• type ZParams
  • func NewZParams(name string) ZParams
  • func (g ZParams) GetParams() [][]byte
  • func (g ZParams) GetRaw() []byte

Constants

const (
	AskPrefix         = "ASK "
	MovedPrefix       = "MOVED "
	ClusterdownPrefix = "CLUSTERDOWN "
	BusyPrefix        = "BUSY "
	NoscriptPrefix    = "NOSCRIPT "

	DefaultHost         = "localhost"
	DefaultPort         = 6379
	DefaultSentinelPort = 26379
	DefaultTimeout      = 5 * time.Second
	DefaultDatabase     = 2 * time.Second

	DollarByte   = '$'
	AsteriskByte = '*'
	PlusByte     = '+'
	MinusByte    = '-'
	ColonByte    = ':'

	SentinelMasters             = "masters"
	SentinelGetMasterAddrByName = "get-master-addr-by-name"
	SentinelReset               = "reset"
	SentinelSlaves              = "slaves"
	SentinelFailover            = "failover"
	SentinelMonitor             = "monitor"
	SentinelRemove              = "remove"
	SentinelSet                 = "set"

	ClusterNodes            = "nodes"
	ClusterMeet             = "meet"
	ClusterReset            = "reset"
	ClusterAddslots         = "addslots"
	ClusterDelslots         = "delslots"
	ClusterInfo             = "info"
	ClusterGetkeysinslot    = "getkeysinslot"
	ClusterSetslot          = "setslot"
	ClusterSetslotNode      = "node"
	ClusterSetslotMigrating = "migrating"
	ClusterSetslotImporting = "importing"
	ClusterSetslotStable    = "stable"
	ClusterForget           = "forget"
	ClusterFlushslot        = "flushslots"
	ClusterKeyslot          = "keyslot"
	ClusterCountkeyinslot   = "countkeysinslot"
	ClusterSaveconfig       = "saveconfig"
	ClusterReplicate        = "replicate"
	ClusterSlaves           = "slaves"
	ClusterFailover         = "failover"
	ClusterSlots            = "slots"
	PubsubChannels          = "channels"
	PubsubNumsub            = "numsub"
	PubsubNumPat            = "numpat"
)

const (
	MasterNodeIndex = 2
)

Variables

var (
	ListoptionBefore = NewListOption("BEFORE")
	ListoptionAfter  = NewListOption("AFTER")
)

var (
	GeounitMi = NewGeoUnit("MI")
	GeounitM  = NewGeoUnit("M")
	GeounitKm = NewGeoUnit("KM")
	GeounitFt = NewGeoUnit("FT")
)

var (
	ZparamsSum = NewZParams("SUM")
	ZparamsMin = NewZParams("MIN")
	ZparamsMax = NewZParams("MAX")
)

var (
	BitopAnd = NewBitOP("AND")
	BitopOr  = NewBitOP("OR")
	BitopXor = NewBitOP("XOR")
	BitopNot = NewBitOP("NOT")
)

var (
	ResetSoft = NewReset("SOFT")
	ResetHard = NewReset("HARD")
)

var (
	//convert interface to string
	StringBuilder = newStringBuilder()
	//convert interface to int64
	Int64Builder = newInt64Builder()
	//convert interface to string array
	StringArrayBuilder = newStringArrayBuilder()
)

var (
	BytesTrue  = IntToByteArray(1)
	BytesFalse = IntToByteArray(0)
	BytesTilde = []byte("~")

	PositiveInfinityBytes = []byte("+inf")
	NegativeInfinityBytes = []byte("-inf")
)

var (
	CmdPing                = newProtocolCommand("PING")
	CmdSet                 = newProtocolCommand("SET")
	CmdGet                 = newProtocolCommand("GET")
	CmdQuit                = newProtocolCommand("QUIT")
	CmdExists              = newProtocolCommand("EXISTS")
	CmdDel                 = newProtocolCommand("DEL")
	CmdUnlink              = newProtocolCommand("UNLINK")
	CmdType                = newProtocolCommand("TYPE")
	CmdFlushdb             = newProtocolCommand("FLUSHDB")
	CmdKeys                = newProtocolCommand("KEYS")
	CmdRandomkey           = newProtocolCommand("RANDOMKEY")
	CmdRename              = newProtocolCommand("RENAME")
	CmdRenamenx            = newProtocolCommand("RENAMENX")
	CmdRenamex             = newProtocolCommand("RENAMEX")
	CmdDbsize              = newProtocolCommand("DBSIZE")
	CmdExpire              = newProtocolCommand("EXPIRE")
	CmdExpireat            = newProtocolCommand("EXPIREAT")
	CmdTtl                 = newProtocolCommand("TTL")
	CmdSelect              = newProtocolCommand("SELECT")
	CmdMove                = newProtocolCommand("MOVE")
	CmdFlushall            = newProtocolCommand("FLUSHALL")
	CmdGetset              = newProtocolCommand("GETSET")
	CmdMget                = newProtocolCommand("MGET")
	CmdSetnx               = newProtocolCommand("SETNX")
	CmdSetex               = newProtocolCommand("SETEX")
	CmdMset                = newProtocolCommand("MSET")
	CmdMsetnx              = newProtocolCommand("MSETNX")
	CmdDecrby              = newProtocolCommand("DECRBY")
	CmdDecr                = newProtocolCommand("DECR")
	CmdIncrby              = newProtocolCommand("INCRBY")
	CmdIncr                = newProtocolCommand("INCR")
	CmdAppend              = newProtocolCommand("APPEND")
	CmdSubstr              = newProtocolCommand("SUBSTR")
	CmdHset                = newProtocolCommand("HSET")
	CmdHget                = newProtocolCommand("HGET")
	CmdHsetnx              = newProtocolCommand("HSETNX")
	CmdHmset               = newProtocolCommand("HMSET")
	CmdHmget               = newProtocolCommand("HMGET")
	CmdHincrby             = newProtocolCommand("HINCRBY")
	CmdHexists             = newProtocolCommand("HEXISTS")
	CmdHdel                = newProtocolCommand("HDEL")
	CmdHlen                = newProtocolCommand("HLEN")
	CmdHkeys               = newProtocolCommand("HKEYS")
	CmdHvals               = newProtocolCommand("HVALS")
	CmdHgetall             = newProtocolCommand("HGETALL")
	CmdRpush               = newProtocolCommand("RPUSH")
	CmdLpush               = newProtocolCommand("LPUSH")
	CmdLlen                = newProtocolCommand("LLEN")
	CmdLrange              = newProtocolCommand("LRANGE")
	CmdLtrim               = newProtocolCommand("LTRIM")
	CmdLindex              = newProtocolCommand("LINDEX")
	CmdLset                = newProtocolCommand("LSET")
	CmdLrem                = newProtocolCommand("LREM")
	CmdLpop                = newProtocolCommand("LPOP")
	CmdRpop                = newProtocolCommand("RPOP")
	CmdRpoplpush           = newProtocolCommand("RPOPLPUSH")
	CmdSadd                = newProtocolCommand("SADD")
	CmdSmembers            = newProtocolCommand("SMEMBERS")
	CmdSrem                = newProtocolCommand("SREM")
	CmdSpop                = newProtocolCommand("SPOP")
	CmdSmove               = newProtocolCommand("SMOVE")
	CmdScard               = newProtocolCommand("SCARD")
	CmdSismember           = newProtocolCommand("SISMEMBER")
	CmdSinter              = newProtocolCommand("SINTER")
	CmdSinterstore         = newProtocolCommand("SINTERSTORE")
	CmdSunion              = newProtocolCommand("SUNION")
	CmdSunionstore         = newProtocolCommand("SUNIONSTORE")
	CmdSdiff               = newProtocolCommand("SDIFF")
	CmdSdiffstore          = newProtocolCommand("SDIFFSTORE")
	CmdSrandmember         = newProtocolCommand("SRANDMEMBER")
	CmdZadd                = newProtocolCommand("ZADD")
	CmdZrange              = newProtocolCommand("ZRANGE")
	CmdZrem                = newProtocolCommand("ZREM")
	CmdZincrby             = newProtocolCommand("ZINCRBY")
	CmdZrank               = newProtocolCommand("ZRANK")
	CmdZrevrank            = newProtocolCommand("ZREVRANK")
	CmdZrevrange           = newProtocolCommand("ZREVRANGE")
	CmdZcard               = newProtocolCommand("ZCARD")
	CmdZscore              = newProtocolCommand("ZSCORE")
	CmdMulti               = newProtocolCommand("MULTI")
	CmdDiscard             = newProtocolCommand("DISCARD")
	CmdExec                = newProtocolCommand("EXEC")
	CmdWatch               = newProtocolCommand("WATCH")
	CmdUnwatch             = newProtocolCommand("UNWATCH")
	CmdSort                = newProtocolCommand("SORT")
	CmdBlpop               = newProtocolCommand("BLPOP")
	CmdBrpop               = newProtocolCommand("BRPOP")
	CmdAuth                = newProtocolCommand("AUTH")
	CmdSubscribe           = newProtocolCommand("SUBSCRIBE")
	CmdPublish             = newProtocolCommand("PUBLISH")
	CmdUnsubscribe         = newProtocolCommand("UNSUBSCRIBE")
	CmdPsubscribe          = newProtocolCommand("PSUBSCRIBE")
	CmdPunsubscribe        = newProtocolCommand("PUNSUBSCRIBE")
	CmdPubsub              = newProtocolCommand("PUBSUB")
	CmdZcount              = newProtocolCommand("ZCOUNT")
	CmdZrangebyscore       = newProtocolCommand("ZRANGEBYSCORE")
	CmdZrevrangebyscore    = newProtocolCommand("ZREVRANGEBYSCORE")
	CmdZremrangebyrank     = newProtocolCommand("ZREMRANGEBYRANK")
	CmdZremrangebyscore    = newProtocolCommand("ZREMRANGEBYSCORE")
	CmdZunionstore         = newProtocolCommand("ZUNIONSTORE")
	CmdZinterstore         = newProtocolCommand("ZINTERSTORE")
	CmdZlexcount           = newProtocolCommand("ZLEXCOUNT")
	CmdZrangebylex         = newProtocolCommand("ZRANGEBYLEX")
	CmdZrevrangebylex      = newProtocolCommand("ZREVRANGEBYLEX")
	CmdZremrangebylex      = newProtocolCommand("ZREMRANGEBYLEX")
	CmdSave                = newProtocolCommand("SAVE")
	CmdBgsave              = newProtocolCommand("BGSAVE")
	CmdBgrewriteaof        = newProtocolCommand("BGREWRITEAOF")
	CmdLastsave            = newProtocolCommand("LASTSAVE")
	CmdShutdown            = newProtocolCommand("SHUTDOWN")
	CmdInfo                = newProtocolCommand("INFO")
	CmdMonitor             = newProtocolCommand("MONITOR")
	CmdSlaveof             = newProtocolCommand("SLAVEOF")
	CmdConfig              = newProtocolCommand("CONFIG")
	CmdStrlen              = newProtocolCommand("STRLEN")
	CmdSync                = newProtocolCommand("SYNC")
	CmdLpushx              = newProtocolCommand("LPUSHX")
	CmdPersist             = newProtocolCommand("PERSIST")
	CmdRpushx              = newProtocolCommand("RPUSHX")
	CmdEcho                = newProtocolCommand("ECHO")
	CmdLinsert             = newProtocolCommand("LINSERT")
	CmdDebug               = newProtocolCommand("DEBUG")
	CmdBrpoplpush          = newProtocolCommand("BRPOPLPUSH")
	CmdSetbit              = newProtocolCommand("SETBIT")
	CmdGetbit              = newProtocolCommand("GETBIT")
	CmdBitpos              = newProtocolCommand("BITPOS")
	CmdSetrange            = newProtocolCommand("SETRANGE")
	CmdGetrange            = newProtocolCommand("GETRANGE")
	CmdEval                = newProtocolCommand("EVAL")
	CmdEvalsha             = newProtocolCommand("EVALSHA")
	CmdScript              = newProtocolCommand("SCRIPT")
	CmdSlowlog             = newProtocolCommand("SLOWLOG")
	CmdObject              = newProtocolCommand("OBJECT")
	CmdBitcount            = newProtocolCommand("BITCOUNT")
	CmdBitop               = newProtocolCommand("BITOP")
	CmdSentinel            = newProtocolCommand("SENTINEL")
	CmdDump                = newProtocolCommand("DUMP")
	CmdRestore             = newProtocolCommand("RESTORE")
	CmdPexpire             = newProtocolCommand("PEXPIRE")
	CmdPexpireat           = newProtocolCommand("PEXPIREAT")
	CmdPttl                = newProtocolCommand("PTTL")
	CmdIncrbyfloat         = newProtocolCommand("INCRBYFLOAT")
	CmdPsetex              = newProtocolCommand("PSETEX")
	CmdClient              = newProtocolCommand("CLIENT")
	CmdTime                = newProtocolCommand("TIME")
	CmdMigrate             = newProtocolCommand("MIGRATE")
	CmdHincrbyfloat        = newProtocolCommand("HINCRBYFLOAT")
	CmdScan                = newProtocolCommand("SCAN")
	CmdHscan               = newProtocolCommand("HSCAN")
	CmdSscan               = newProtocolCommand("SSCAN")
	CmdZscan               = newProtocolCommand("ZSCAN")
	CmdWait                = newProtocolCommand("WAIT")
	CmdCluster             = newProtocolCommand("CLUSTER")
	CmdAsking              = newProtocolCommand("ASKING")
	CmdPfadd               = newProtocolCommand("PFADD")
	CmdPfcount             = newProtocolCommand("PFCOUNT")
	CmdPfmerge             = newProtocolCommand("PFMERGE")
	CmdReadonly            = newProtocolCommand("READONLY")
	CmdGeoadd              = newProtocolCommand("GEOADD")
	CmdGeodist             = newProtocolCommand("GEODIST")
	CmdGeohash             = newProtocolCommand("GEOHASH")
	CmdGeopos              = newProtocolCommand("GEOPOS")
	CmdGeoradius           = newProtocolCommand("GEORADIUS")
	CmdGeoradiusRo         = newProtocolCommand("GEORADIUS_RO")
	CmdGeoradiusbymember   = newProtocolCommand("GEORADIUSBYMEMBER")
	CmdGeoradiusbymemberRo = newProtocolCommand("GEORADIUSBYMEMBER_RO")
	CmdModule              = newProtocolCommand("MODULE")
	CmdBitfield            = newProtocolCommand("BITFIELD")
	CmdHstrlen             = newProtocolCommand("HSTRLEN")
	CmdTouch               = newProtocolCommand("TOUCH")
	CmdSwapdb              = newProtocolCommand("SWAPDB")
	CmdMemory              = newProtocolCommand("MEMORY")
	CmdXadd                = newProtocolCommand("XADD")
	CmdXlen                = newProtocolCommand("XLEN")
	CmdXdel                = newProtocolCommand("XDEL")
	CmdXtrim               = newProtocolCommand("XTRIM")
	CmdXrange              = newProtocolCommand("XRANGE")
	CmdXrevrange           = newProtocolCommand("XREVRANGE")
	CmdXread               = newProtocolCommand("XREAD")
	CmdXack                = newProtocolCommand("XACK")
	CmdXgroup              = newProtocolCommand("XGROUP")
	CmdXreadgroup          = newProtocolCommand("XREADGROUP")
	CmdXpending            = newProtocolCommand("XPENDING")
	CmdXclaim              = newProtocolCommand("XCLAIM")
)

var (
	KeywordAggregate    = newKeyword("AGGREGATE")
	KeywordAlpha        = newKeyword("ALPHA")
	KeywordAsc          = newKeyword("ASC")
	KeywordBy           = newKeyword("BY")
	KeywordDesc         = newKeyword("DESC")
	KeywordGet          = newKeyword("GET")
	KeywordLimit        = newKeyword("LIMIT")
	KeywordMessage      = newKeyword("MESSAGE")
	KeywordNo           = newKeyword("NO")
	KeywordNosort       = newKeyword("NOSORT")
	KeywordPmessage     = newKeyword("PMESSAGE")
	KeywordPsubscribe   = newKeyword("PSUBSCRIBE")
	KeywordPunsubscribe = newKeyword("PUNSUBSCRIBE")
	KeywordOk           = newKeyword("OK")
	KeywordOne          = newKeyword("ONE")
	KeywordQueued       = newKeyword("QUEUED")
	KeywordSet          = newKeyword("SET")
	KeywordStore        = newKeyword("STORE")
	KeywordSubscribe    = newKeyword("SUBSCRIBE")
	KeywordUnsubscribe  = newKeyword("UNSUBSCRIBE")
	KeywordWeights      = newKeyword("WEIGHTS")
	KeywordWithscores   = newKeyword("WITHSCORES")
	KeywordResetstat    = newKeyword("RESETSTAT")
	KeywordRewrite      = newKeyword("REWRITE")
	KeywordReset        = newKeyword("RESET")
	KeywordFlush        = newKeyword("FLUSH")
	KeywordExists       = newKeyword("EXISTS")
	KeywordLoad         = newKeyword("LOAD")
	KeywordKill         = newKeyword("KILL")
	KeywordLen          = newKeyword("LEN")
	KeywordRefcount     = newKeyword("REFCOUNT")
	KeywordEncoding     = newKeyword("ENCODING")
	KeywordIdletime     = newKeyword("IDLETIME")
	KeywordGetname      = newKeyword("GETNAME")
	KeywordSetname      = newKeyword("SETNAME")
	KeywordList         = newKeyword("LIST")
	KeywordMatch        = newKeyword("MATCH")
	KeywordCount        = newKeyword("COUNT")
	KeywordPing         = newKeyword("PING")
	KeywordPong         = newKeyword("PONG")
	KeywordUnload       = newKeyword("UNLOAD")
	KeywordReplace      = newKeyword("REPLACE")
	KeywordKeys         = newKeyword("KEYS")
	KeywordPause        = newKeyword("PAUSE")
	KeywordDoctor       = newKeyword("DOCTOR")
	KeywordBlock        = newKeyword("BLOCK")
	KeywordNoack        = newKeyword("NOACK")
	KeywordStreams      = newKeyword("STREAMS")
	KeywordKey          = newKeyword("KEY")
	KeywordCreate       = newKeyword("CREATE")
	KeywordMkstream     = newKeyword("MKSTREAM")
	KeywordSetid        = newKeyword("SETID")
	KeywordDestroy      = newKeyword("DESTROY")
	KeywordDelconsumer  = newKeyword("DELCONSUMER")
	KeywordMaxlen       = newKeyword("MAXLEN")
	KeywordGroup        = newKeyword("GROUP")
	KeywordIdle         = newKeyword("IDLE")
	KeywordTime         = newKeyword("TIME")
	KeywordRetrycount   = newKeyword("RETRYCOUNT")
	KeywordForce        = newKeyword("FORCE")
)

var (
	ErrClosed = errors.New("pool is closed")
)

var LockTimeoutErr = errors.New("get lock timeout")

var LookupTable = []uint16{}/* 256 elements not displayed */

Functions

func BoolToByteArray

func BoolToByteArray(a bool) []byte

BoolToByteArray ...

func ByteArrayToFloat64

func ByteArrayToFloat64(bytes []byte) float64

ByteArrayToFloat64 ...

func ByteArrayToInt64

func ByteArrayToInt64(bytes []byte) uint64

ByteArrayToInt64 ...

func ByteToStringReply

func ByteToStringReply(reply []byte, err error) (string, error)

ByteToStringReply ...

func Float64ToByteArray

func Float64ToByteArray(a float64) []byte

Float64ToByteArray ...

func GoID

func GoID() (int, error)

func Int64ToBoolReply

func Int64ToBoolReply(reply int64, err error) (bool, error)

Int64ToBoolReply ...

func Int64ToByteArray

func Int64ToByteArray(a int64) []byte

Int64ToByteArray ...

func IntToByteArray

func IntToByteArray(a int) []byte

IntToByteArray ...

func NewClusterLocker

func NewClusterLocker(option *ClusterOption, lockOption *LockOption) *clusterLocker

func NewLocker

func NewLocker(option *Option, lockOption *LockOption) *locker

func ObjectArrToMapArrayReply

func ObjectArrToMapArrayReply(reply []interface{}, err error) ([]map[string]string, error)

ObjectArrToMapArrayReply ...

func ObjectToEvalResult

func ObjectToEvalResult(reply interface{}, err error) (interface{}, error)

ObjectToEvalResult resolve response data when use script command

func StringArrayToByteArray

func StringArrayToByteArray(arr []string) [][]byte

StringArrayToByteArray ...

func StringArrayToMapReply

func StringArrayToMapReply(reply []string, err error) (map[string]string, error)

StringArrayToMapReply ...

func StringStringArrayToByteArray

func StringStringArrayToByteArray(str string, arr []string) [][]byte

StringStringArrayToByteArray ...

func StringStringArrayToStringArray

func StringStringArrayToStringArray(str string, arr []string) []string

StringStringArrayToStringArray ...

func StringToFloat64Reply

func StringToFloat64Reply(reply string, err error) (float64, error)

StringToFloat64Reply ...

func ToBoolArrayReply

func ToBoolArrayReply(reply interface{}, err error) ([]bool, error)

ToBoolArrayReply ...

func ToBoolReply

func ToBoolReply(reply interface{}, err error) (bool, error)

ToBoolReply ...

func ToFloat64Reply

func ToFloat64Reply(reply interface{}, err error) (float64, error)

ToFloat64Reply ...

func ToInt64ArrayReply

func ToInt64ArrayReply(reply interface{}, err error) ([]int64, error)

ToInt64ArrayReply ...

func ToInt64Reply

func ToInt64Reply(reply interface{}, err error) (int64, error)

ToInt64Reply ...

func ToMapReply

func ToMapReply(reply interface{}, err error) (map[string]string, error)

ToMapReply ...

func ToStringArrayReply

func ToStringArrayReply(reply interface{}, err error) ([]string, error)

ToStringArrayReply ...

func ToStringReply

func ToStringReply(reply interface{}, err error) (string, error)

ToStringReply ...

Types

type AskDataError

type AskDataError struct {
	Message string
	Host    string
	Port    int
	Slot    int
}

func NewAskDataError

func NewAskDataError(message string, host string, port int, slot int) *AskDataError

func (*AskDataError) Error

func (e *AskDataError) Error() string

type BitOP

type BitOP struct {
	//name  ...
	Name string
}

BitOP ...

func NewBitOP

func NewBitOP(name string) BitOP

NewBitOP ...

func (BitOP) GetRaw

func (g BitOP) GetRaw() []byte

GetRaw ...

type BitPosParams

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

BitPosParams

type Builder

type Builder interface {
	// contains filtered or unexported methods
}

Builder convert pipeline|transaction response data

type BusyError

type BusyError struct {
	Message string
}

func NewBusyError

func NewBusyError(message string) *BusyError

func (*BusyError) Error

func (e *BusyError) Error() string

type ClusterError

type ClusterError struct {
	Message string
}

func NewClusterError

func NewClusterError(message string) *ClusterError

func (*ClusterError) Error

func (e *ClusterError) Error() string

type ClusterOption

type ClusterOption struct {
	Nodes             []string
	ConnectionTimeout time.Duration
	SoTimeout         time.Duration
	MaxAttempts       int
	Password          string
	PoolConfig        *PoolConfig
}

type ConnectError

type ConnectError struct {
	Message string
}

func NewConnectError

func NewConnectError(message string) *ConnectError

func (*ConnectError) Error

func (e *ConnectError) Error() string

type DataError

type DataError struct {
	Message string
}

func NewDataError

func NewDataError(message string) *DataError

func (*DataError) Error

func (e *DataError) Error() string

type DebugParams

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

DebugParams ...

func NewDebugParamsObject

func NewDebugParamsObject(key string) *DebugParams

func NewDebugParamsReload

func NewDebugParamsReload() *DebugParams

func NewDebugParamsSegfault

func NewDebugParamsSegfault() *DebugParams

type GeoCoordinate

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

GeoCoordinate ...

func ObjectArrToGeoCoordinateReply

func ObjectArrToGeoCoordinateReply(reply []interface{}, err error) ([]*GeoCoordinate, error)

ObjectArrToGeoCoordinateReply ...

func ToGeoArrayReply

func ToGeoArrayReply(reply interface{}, err error) ([]*GeoCoordinate, error)

ToGeoArrayReply ...

type GeoRadiusParam

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

GeoRadiusParam

func (GeoRadiusParam) Contains

func (g GeoRadiusParam) Contains(key string) bool

Contains ...

func (GeoRadiusParam) GetParams

func (g GeoRadiusParam) GetParams(args [][]byte) [][]byte

GetParams ...

type GeoRadiusResponse

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

GeoRadiusResponse ...

type GeoUnit

type GeoUnit struct {
	// name ...
	Name string
}

GeoUnit

func NewGeoUnit

func NewGeoUnit(name string) GeoUnit

NewGeoUnit ...

func (GeoUnit) GetRaw

func (g GeoUnit) GetRaw() []byte

GetRaw ...

type ListOption

type ListOption struct {
	// name  ...
	Name string
}

ListOption ...

func NewListOption

func NewListOption(name string) ListOption

NewListOption ...

func (ListOption) GetRaw

func (l ListOption) GetRaw() []byte

GetRaw ...

type LockOption

type LockOption struct {
	Timeout time.Duration
}

type Locker

type Locker interface {
	TryLock(key string) (bool, error)
	UnLock() error
}

type MovedDataError

type MovedDataError struct {
	Message string
	Host    string
	Port    int
	Slot    int
}

func NewMovedDataError

func NewMovedDataError(message string, host string, port int, slot int) *MovedDataError

func (*MovedDataError) Error

func (e *MovedDataError) Error() string

type NoReachableClusterNodeError

type NoReachableClusterNodeError struct {
	Message string
}

func NewNoReachableClusterNodeError

func NewNoReachableClusterNodeError(message string) *NoReachableClusterNodeError

func (*NoReachableClusterNodeError) Error

func (e *NoReachableClusterNodeError) Error() string

type NoScriptError

type NoScriptError struct {
	Message string
}

func NewNoScriptError

func NewNoScriptError(message string) *NoScriptError

func (*NoScriptError) Error

func (e *NoScriptError) Error() string

type Option

type Option struct {
	// redis host
	Host string
	// redis port
	Port int
	// connect timeout
	ConnectionTimeout time.Duration
	// read timeout
	SoTimeout time.Duration
	// redis password,if empty,then without auth
	Password string
	// which db to connect
	Db int
}

Option connect options

type Pool

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

func NewPool

func NewPool(config *PoolConfig, option *Option) *Pool

NewPool create new pool

func (*Pool) Close

func (p *Pool) Close(redis *Redis) error

func (*Pool) Destroy

func (p *Pool) Destroy() error

func (*Pool) Get

func (p *Pool) Get() (*Redis, error)

func (*Pool) Put

func (p *Pool) Put(redis *Redis) error

type PoolConfig

type PoolConfig struct {
	MaxTotal             int
	MaxIdle              int
	MinIdle              int
	MinEvictableIdleTime time.Duration
	TestOnBorrow         bool
}

PoolConfig

type Redis

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

Redis redis client tool

func NewRedis

func NewRedis(option *Option) *Redis

constructor for creating new redis

func (*Redis) Append

func (r *Redis) Append(key, value string) (int64, error)

If the key already exists and is a string, this command appends the provided value at the end of the string. If the key does not exist it is created and set as an empty string, so APPEND will be very similar to SET in this special case.

Time complexity: O(1). The amortized time complexity is O(1) assuming the appended value is small and the already present value is of any size, since the dynamic string library used by Redis will double the free space available on every reallocation. param key param value return Integer reply, specifically the total length of the string after the append operation.

func (*Redis) Asking

func (r *Redis) Asking() (string, error)

Asking ...

func (*Redis) Auth

func (r *Redis) Auth(password string) (string, error)

Auth ...

func (*Redis) Bgrewriteaof

func (r *Redis) Bgrewriteaof() (string, error)

Bgrewriteaof ...

func (*Redis) Bgsave

func (r *Redis) Bgsave() (string, error)

Bgsave ...

func (*Redis) Bitcount

func (r *Redis) Bitcount(key string) (int64, error)

Count the number of set bits (population counting) in a string.

By default all the bytes contained in the string are examined. It is possible to specify the counting operation only in an interval passing the additional arguments start and end.

Like for the GETRANGE command start and end can contain negative values in order to index bytes starting from the end of the string, where -1 is the last byte, -2 is the penultimate, and so forth.

Non-existent keys are treated as empty strings, so the command will return zero.

Return value Integer reply

The number of bits set to 1.

func (*Redis) BitcountRange

func (r *Redis) BitcountRange(key string, start, end int64) (int64, error)

see Bitcount()

func (*Redis) Bitfield

func (r *Redis) Bitfield(key string, arguments ...string) ([]int64, error)

Bitfield The command treats a Redis string as a array of bits, and is capable of addressing specific integer fields of varying bit widths and arbitrary non (necessary) aligned offset.

func (*Redis) Bitop

func (r *Redis) Bitop(op BitOP, destKey string, srcKeys ...string) (int64, error)

Bitop ...

func (*Redis) Bitpos

func (r *Redis) Bitpos(key string, value bool, params ...BitPosParams) (int64, error)

Bitpos Return the position of the first bit set to 1 or 0 in a string.

func (*Redis) Blpop

func (r *Redis) Blpop(args ...string) ([]string, error)

BLPOP (and BRPOP) is a blocking list pop primitive. You can see this commands as blocking versions of LPOP and RPOP able to block if the specified keys don't exist or contain empty lists.

The following is a description of the exact semantic. We describe BLPOP but the two commands are identical, the only difference is that BLPOP pops the element from the left (head) of the list, and BRPOP pops from the right (tail).

<b>Non blocking behavior</b>

When BLPOP is called, if at least one of the specified keys contain a non empty list, an element is popped from the head of the list and returned to the caller together with the name of the key (BLPOP returns a two elements array, the first element is the key, the second the popped value).

Keys are scanned from left to right, so for instance if you issue BLPOP list1 list2 list3 0 against a dataset where list1 does not exist but list2 and list3 contain non empty lists, BLPOP guarantees to return an element from the list stored at list2 (since it is the first non empty list starting from the left).

<b>Blocking behavior</b>

If none of the specified keys exist or contain non empty lists, BLPOP blocks until some other client performs a LPUSH or an RPUSH operation against one of the lists.

Once new data is present on one of the lists, the client finally returns with the name of the key unblocking it and the popped value.

When blocking, if a non-zero timeout is specified, the client will unblock returning a nil special value if the specified amount of seconds passed without a push operation against at least one of the specified keys.

The timeout argument is interpreted as an integer value. A timeout of zero means instead to block forever.

<b>Multiple clients blocking for the same keys</b>

Multiple clients can block for the same key. They are put into a queue, so the first to be served will be the one that started to wait earlier, in a first-blpopping first-served fashion.

<b>blocking POP inside a MULTI/EXEC transaction</b>

BLPOP and BRPOP can be used with pipelining (sending multiple commands and reading the replies in batch), but it does not make sense to use BLPOP or BRPOP inside a MULTI/EXEC block (a Redis transaction).

The behavior of BLPOP inside MULTI/EXEC when the list is empty is to return a multi-bulk nil reply, exactly what happens when the timeout is reached. If you like science fiction, think at it like if inside MULTI/EXEC the time will flow at infinite speed :)

Time complexity: O(1) @see #brpop(int, String...) param timeout param keys return BLPOP returns a two-elements array via a multi bulk reply in order to return both the

unblocking key and the popped value.

When a non-zero timeout is specified, and the BLPOP operation timed out, the return
value is a nil multi bulk reply. Most client values will return false or nil
accordingly to the programming language used.

func (*Redis) BlpopTimout

func (r *Redis) BlpopTimout(timeout int, keys ...string) ([]string, error)

BlpopTimout ...

func (*Redis) Brpop

func (r *Redis) Brpop(args ...string) ([]string, error)

Brpop ...

func (*Redis) BrpopTimout

func (r *Redis) BrpopTimout(timeout int, keys ...string) ([]string, error)

BrpopTimout ...

func (*Redis) Brpoplpush

func (r *Redis) Brpoplpush(source, destination string, timeout int) (string, error)

Brpoplpush ...

func (*Redis) Close

func (r *Redis) Close() error

Close close redis connection

func (*Redis) ClusterAddSlots

func (r *Redis) ClusterAddSlots(slots ...int) (string, error)

ClusterAddSlots ...

func (*Redis) ClusterCountKeysInSlot

func (r *Redis) ClusterCountKeysInSlot(slot int) (int64, error)

ClusterCountKeysInSlot ...

func (*Redis) ClusterDelSlots

func (r *Redis) ClusterDelSlots(slots ...int) (string, error)

ClusterDelSlots ...

func (*Redis) ClusterFailover

func (r *Redis) ClusterFailover() (string, error)

ClusterFailover This command, that can only be sent to a Redis Cluster replica node, forces the replica to start a manual failover of its master instance.

func (*Redis) ClusterFlushSlots

func (r *Redis) ClusterFlushSlots() (string, error)

ClusterFlushSlots ...

func (*Redis) ClusterForget

func (r *Redis) ClusterForget(nodeId string) (string, error)

ClusterForget ...

func (*Redis) ClusterGetKeysInSlot

func (r *Redis) ClusterGetKeysInSlot(slot int, count int) ([]string, error)

ClusterGetKeysInSlot ...

func (*Redis) ClusterInfo

func (r *Redis) ClusterInfo() (string, error)

ClusterInfo ...

func (*Redis) ClusterKeySlot

func (r *Redis) ClusterKeySlot(key string) (int64, error)

ClusterKeySlot ...

func (*Redis) ClusterMeet

func (r *Redis) ClusterMeet(ip string, port int) (string, error)

ClusterMeet ...

func (*Redis) ClusterNodes

func (r *Redis) ClusterNodes() (string, error)

ClusterNodes Each node in a Redis Cluster has its view of the current cluster configuration, given by the set of known nodes, the state of the connection we have with such nodes, their flags, properties and assigned slots, and so forth.

func (*Redis) ClusterReplicate

func (r *Redis) ClusterReplicate(nodeId string) (string, error)

ClusterReplicate ...

func (*Redis) ClusterReset

func (r *Redis) ClusterReset(resetType Reset) (string, error)

ClusterReset ...

func (*Redis) ClusterSaveConfig

func (r *Redis) ClusterSaveConfig() (string, error)

ClusterSaveConfig ...

func (*Redis) ClusterSetSlotImporting

func (r *Redis) ClusterSetSlotImporting(slot int, nodeId string) (string, error)

ClusterSetSlotImporting ...

func (*Redis) ClusterSetSlotMigrating

func (r *Redis) ClusterSetSlotMigrating(slot int, nodeId string) (string, error)

ClusterSetSlotMigrating ...

func (*Redis) ClusterSetSlotNode

func (r *Redis) ClusterSetSlotNode(slot int, nodeId string) (string, error)

ClusterSetSlotNode ...

func (*Redis) ClusterSetSlotStable

func (r *Redis) ClusterSetSlotStable(slot int) (string, error)

ClusterSetSlotStable ...

func (*Redis) ClusterSlaves

func (r *Redis) ClusterSlaves(nodeId string) ([]string, error)

ClusterSlaves ...

func (*Redis) ClusterSlots

func (r *Redis) ClusterSlots() ([]interface{}, error)

ClusterSlots ...

func (*Redis) ConfigGet

func (r *Redis) ConfigGet(pattern string) ([]string, error)

ConfigGet ...

func (*Redis) ConfigResetStat

func (r *Redis) ConfigResetStat() (string, error)

ConfigResetStat ...

func (*Redis) ConfigSet

func (r *Redis) ConfigSet(parameter, value string) (string, error)

ConfigSet ...

func (*Redis) Connect

func (r *Redis) Connect() error

Connect connect to redis

func (*Redis) DbSize

func (r *Redis) DbSize() (int64, error)

DbSize ...

func (*Redis) Debug

func (r *Redis) Debug(params DebugParams) (string, error)

Debug ...

func (*Redis) Decr

func (r *Redis) Decr(key string) (int64, error)

Decrement the number stored at key by one. If the key does not exist or contains a value of a wrong type, set the key to the value of "0" before to perform the decrement operation.

INCR commands are limited to 64 bit signed integers.

Note: this is actually a string operation, that is, in Redis there are not "integer" types. Simply the string stored at the key is parsed as a base 10 64 bit signed integer, incremented, and then converted back as a string.

Time complexity: O(1) @see #incr(String) @see #incrBy(String, long) @see #decrBy(String, long) param key return Integer reply, this commands will reply with the new value of key after the increment.

func (*Redis) DecrBy

func (r *Redis) DecrBy(key string, decrement int64) (int64, error)

IDECRBY work just like {@link #decr(String) INCR} but instead to decrement by 1 the decrement is integer.

INCR commands are limited to 64 bit signed integers.

Note: this is actually a string operation, that is, in Redis there are not "integer" types. Simply the string stored at the key is parsed as a base 10 64 bit signed integer, incremented, and then converted back as a string.

Time complexity: O(1) @see #incr(String) @see #decr(String) @see #incrBy(String, long) param key param integer return Integer reply, this commands will reply with the new value of key after the increment.

func (*Redis) Del

func (r *Redis) Del(key ...string) (int64, error)

Remove the specified keys. If a given key does not exist no operation is performed for this key. The command returns the number of keys removed. Time complexity: O(1) param keys return Integer reply, specifically: an integer greater than 0 if one or more keys were removed

0 if none of the specified key existed

func (*Redis) Echo

func (r *Redis) Echo(string string) (string, error)

Echo Returns message.

Return value Bulk string reply

func (*Redis) Eval

func (r *Redis) Eval(script string, keyCount int, params ...string) (interface{}, error)

Eval evaluate scripts using the Lua interpreter built into Redis

func (*Redis) EvalByKeyArgs

func (r *Redis) EvalByKeyArgs(script string, keys []string, args []string) (interface{}, error)

EvalByKeyArgs evaluate scripts using the Lua interpreter built into Redis

func (*Redis) Evalsha

func (r *Redis) Evalsha(sha1 string, keyCount int, params ...string) (interface{}, error)

Evalsha Evaluates a script cached on the server side by its SHA1 digest. Scripts are cached on the server side using the SCRIPT LOAD command. The command is otherwise identical to EVAL.

func (*Redis) Exists

func (r *Redis) Exists(keys ...string) (int64, error)

Test if the specified key exists. The command returns the number of keys existed Time complexity: O(N) param keys return Integer reply, specifically: an integer greater than 0 if one or more keys were removed

0 if none of the specified key existed

func (*Redis) Expire

func (r *Redis) Expire(key string, seconds int) (int64, error)

Set a timeout on the specified key. After the timeout the key will be automatically deleted by the server. A key with an associated timeout is said to be volatile in Redis terminology.

Voltile keys are stored on disk like the other keys, the timeout is persistent too like all the other aspects of the dataset. Saving a dataset containing expires and stopping the server does not stop the flow of time as Redis stores on disk the time when the key will no longer be available as Unix time, and not the remaining seconds.

Since Redis 2.1.3 you can update the value of the timeout of a key already having an expire set. It is also possible to undo the expire at all turning the key into a normal key using the {@link #persist(String) PERSIST} command.

Time complexity: O(1) @see <a href="http://code.google.com/p/redis/wiki/ExpireCommand">ExpireCommand</a> param key param seconds return Integer reply, specifically: 1: the timeout was set. 0: the timeout was not set since

the key already has an associated timeout (this may happen only in Redis versions <
2.1.3, Redis >= 2.1.3 will happily update the timeout), or the key does not exist.

func (*Redis) ExpireAt

func (r *Redis) ExpireAt(key string, unixtime int64) (int64, error)

EXPIREAT works exctly like {@link #expire(String, int) EXPIRE} but instead to get the number of seconds representing the Time To Live of the key as a second argument (that is a relative way of specifying the TTL), it takes an absolute one in the form of a UNIX timestamp (Number of seconds elapsed since 1 Gen 1970).

EXPIREAT was introduced in order to implement the Append Only File persistence mode so that EXPIRE commands are automatically translated into EXPIREAT commands for the append only file. Of course EXPIREAT can also used by programmers that need a way to simply specify that a given key should expire at a given time in the future.

Since Redis 2.1.3 you can update the value of the timeout of a key already having an expire set. It is also possible to undo the expire at all turning the key into a normal key using the {@link #persist(String) PERSIST} command.

Time complexity: O(1) @see <a href="http://code.google.com/p/redis/wiki/ExpireCommand">ExpireCommand</a> param key param unixTime return Integer reply, specifically: 1: the timeout was set. 0: the timeout was not set since

the key already has an associated timeout (this may happen only in Redis versions <
2.1.3, Redis >= 2.1.3 will happily update the timeout), or the key does not exist.

func (*Redis) FlushAll

func (r *Redis) FlushAll() (string, error)

FlushAll ...

func (*Redis) FlushDB

func (r *Redis) FlushDB() (string, error)

FlushDB ...

func (*Redis) Geoadd

func (r *Redis) Geoadd(key string, longitude, latitude float64, member string) (int64, error)

Geoadd ...

func (*Redis) GeoaddByMap

func (r *Redis) GeoaddByMap(key string, memberCoordinateMap map[string]GeoCoordinate) (int64, error)

GeoaddByMap ...

func (*Redis) Geodist

func (r *Redis) Geodist(key, member1, member2 string, unit ...GeoUnit) (float64, error)

Geodist ...

func (*Redis) Geohash

func (r *Redis) Geohash(key string, members ...string) ([]string, error)

Geohash ...

func (*Redis) Geopos

func (r *Redis) Geopos(key string, members ...string) ([]*GeoCoordinate, error)

Geopos ...

func (*Redis) Georadius

func (r *Redis) Georadius(key string, longitude, latitude, radius float64, unit GeoUnit, param ...GeoRadiusParam) ([]*GeoCoordinate, error)

Georadius ...

func (*Redis) GeoradiusByMember

func (r *Redis) GeoradiusByMember(key, member string, radius float64, unit GeoUnit, param ...GeoRadiusParam) ([]*GeoCoordinate, error)

GeoradiusByMember ...

func (*Redis) Get

func (r *Redis) Get(key string) (string, error)

Get the value of the specified key. If the key does not exist null is returned. If the value stored at key is not a string an error is returned because GET can only handle string values. param key return Bulk reply

func (*Redis) GetDB

func (r *Redis) GetDB() int

GetDB ...

func (*Redis) GetSet

func (r *Redis) GetSet(key, value string) (string, error)

GETSET is an atomic set this value and return the old value command. Set key to the string value and return the old value stored at key. The string can't be longer than 1073741824 bytes (1 GB).

Time complexity: O(1) param key param value return Bulk reply

func (*Redis) Getbit

func (r *Redis) Getbit(key string, offset int64) (bool, error)

Returns the bit value at offset in the string value stored at key.

When offset is beyond the string length, the string is assumed to be a contiguous space with 0 bits. When key does not exist it is assumed to be an empty string, so offset is always out of range and the value is also assumed to be a contiguous space with 0 bits.

Return value Integer reply: the bit value stored at offset.

func (*Redis) Getrange

func (r *Redis) Getrange(key string, startOffset, endOffset int64) (string, error)

Getrange Warning: this command was renamed to GETRANGE, it is called SUBSTR in Redis versions <= 2.0. Returns the substring of the string value stored at key, determined by the offsets start and end (both are inclusive). Negative offsets can be used in order to provide an offset starting from the end of the string. So -1 means the last character, -2 the penultimate and so forth.

The function handles out of range requests by limiting the resulting range to the actual length of the string.

Return value Bulk string reply

func (*Redis) Hdel

func (r *Redis) Hdel(key string, fields ...string) (int64, error)

Remove the specified field from an hash stored at key.

<b>Time complexity:</b> O(1) param key param fields return If the field was present in the hash it is deleted and 1 is returned, otherwise 0 is

returned and no operation is performed.

func (*Redis) Hexists

func (r *Redis) Hexists(key, field string) (bool, error)

Test for existence of a specified field in a hash. <b>Time complexity:</b> O(1) param key param field return Return 1 if the hash stored at key contains the specified field. Return 0 if the key is

not found or the field is not present.

func (*Redis) Hget

func (r *Redis) Hget(key, field string) (string, error)

If key holds a hash, retrieve the value associated to the specified field.

If the field is not found or the key does not exist, a special 'nil' value is returned.

<b>Time complexity:</b> O(1) param key param field return Bulk reply

func (*Redis) HgetAll

func (r *Redis) HgetAll(key string) (map[string]string, error)

Return all the fields and associated values in a hash.

<b>Time complexity:</b> O(N), where N is the total number of entries param key return All the fields and values contained into a hash.

func (*Redis) HincrBy

func (r *Redis) HincrBy(key, field string, value int64) (int64, error)

Increment the number stored at field in the hash at key by value. If key does not exist, a new key holding a hash is created. If field does not exist or holds a string, the value is set to 0 before applying the operation. Since the value argument is signed you can use this command to perform both increments and decrements.

The range of values supported by HINCRBY is limited to 64 bit signed integers.

<b>Time complexity:</b> O(1) param key param field param value return Integer reply The new value at field after the increment operation.

func (*Redis) HincrByFloat

func (r *Redis) HincrByFloat(key, field string, value float64) (float64, error)

Increment the number stored at field in the hash at key by a double precision floating point value. If key does not exist, a new key holding a hash is created. If field does not exist or holds a string, the value is set to 0 before applying the operation. Since the value argument is signed you can use this command to perform both increments and decrements.

The range of values supported by HINCRBYFLOAT is limited to double precision floating point values.

<b>Time complexity:</b> O(1) param key param field param value return Double precision floating point reply The new value at field after the increment

operation.

func (*Redis) Hkeys

func (r *Redis) Hkeys(key string) ([]string, error)

Return all the fields in a hash.

<b>Time complexity:</b> O(N), where N is the total number of entries param key return All the fields names contained into a hash.

func (*Redis) Hlen

func (r *Redis) Hlen(key string) (int64, error)

Return the number of items in a hash.

<b>Time complexity:</b> O(1) param key return The number of entries (fields) contained in the hash stored at key. If the specified

key does not exist, 0 is returned assuming an empty hash.

func (*Redis) Hmget

func (r *Redis) Hmget(key string, fields ...string) ([]string, error)

Retrieve the values associated to the specified fields.

If some of the specified fields do not exist, nil values are returned. Non existing keys are considered like empty hashes.

<b>Time complexity:</b> O(N) (with N being the number of fields) param key param fields return Multi Bulk Reply specifically a list of all the values associated with the specified

fields, in the same order of the request.

func (*Redis) Hmset

func (r *Redis) Hmset(key string, hash map[string]string) (string, error)

Set the respective fields to the respective values. HMSET replaces old values with new values.

If key does not exist, a new key holding a hash is created.

<b>Time complexity:</b> O(N) (with N being the number of fields) param key param hash return Return OK or Exception if hash is empty

func (*Redis) Hscan

func (r *Redis) Hscan(key, cursor string, params ...ScanParams) (*ScanResult, error)

Hscan ...

func (*Redis) Hset

func (r *Redis) Hset(key, field, value string) (int64, error)

Set the specified hash field to the specified value.

If key does not exist, a new key holding a hash is created.

<b>Time complexity:</b> O(1) param key param field param value return If the field already exists, and the HSET just produced an update of the value, 0 is

returned, otherwise if a new field is created 1 is returned.

func (*Redis) Hsetnx

func (r *Redis) Hsetnx(key, field, value string) (int64, error)

Set the specified hash field to the specified value if the field not exists. <b>Time complexity:</b> O(1) param key param field param value return If the field already exists, 0 is returned, otherwise if a new field is created 1 is

returned.

func (*Redis) Hvals

func (r *Redis) Hvals(key string) ([]string, error)

Return all the values in a hash.

<b>Time complexity:</b> O(N), where N is the total number of entries param key return All the fields values contained into a hash.

func (*Redis) Incr

func (r *Redis) Incr(key string) (int64, error)

Increment the number stored at key by one. If the key does not exist or contains a value of a wrong type, set the key to the value of "0" before to perform the increment operation.

INCR commands are limited to 64 bit signed integers.

Note: this is actually a string operation, that is, in Redis there are not "integer" types. Simply the string stored at the key is parsed as a base 10 64 bit signed integer, incremented, and then converted back as a string.

Time complexity: O(1) @see #incrBy(String, long) @see #decr(String) @see #decrBy(String, long) param key return Integer reply, this commands will reply with the new value of key after the increment.

func (*Redis) IncrBy

func (r *Redis) IncrBy(key string, increment int64) (int64, error)

INCRBY work just like {@link #incr(String) INCR} but instead to increment by 1 the increment is integer.

INCR commands are limited to 64 bit signed integers.

Note: this is actually a string operation, that is, in Redis there are not "integer" types. Simply the string stored at the key is parsed as a base 10 64 bit signed integer, incremented, and then converted back as a string.

Time complexity: O(1) @see #incr(String) @see #decr(String) @see #decrBy(String, long) param key param integer return Integer reply, this commands will reply with the new value of key after the increment.

func (*Redis) IncrByFloat

func (r *Redis) IncrByFloat(key string, increment float64) (float64, error)

INCRBYFLOAT

INCRBYFLOAT commands are limited to double precision floating point values.

Note: this is actually a string operation, that is, in Redis there are not "double" types. Simply the string stored at the key is parsed as a base double precision floating point value, incremented, and then converted back as a string. There is no DECRYBYFLOAT but providing a negative value will work as expected.

Time complexity: O(1) param key param value return Double reply, this commands will reply with the new value of key after the increment.

func (*Redis) Info

func (r *Redis) Info(section ...string) (string, error)

Info ...

func (*Redis) Keys

func (r *Redis) Keys(pattern string) ([]string, error)

Returns all the keys matching the glob-style pattern as space separated strings. For example if you have in the database the keys "foo" and "foobar" the command "KEYS foo*" will return "foo foobar".

Note that while the time complexity for this operation is O(n) the constant times are pretty low. For example Redis running on an entry level laptop can scan a 1 million keys database in 40 milliseconds. <b>Still it's better to consider this one of the slow commands that may ruin the DB performance if not used with care.</b>

In other words this command is intended only for debugging and special operations like creating a script to change the DB schema. Don't use it in your normal code. Use Redis Sets in order to group together a subset of objects.

Glob style patterns examples: <ul> <li>h?llo will match hello hallo hhllo <li>h*llo will match hllo heeeello <li>h[ae]llo will match hello and hallo, but not hillo </ul>

Use \ to escape special chars if you want to match them verbatim.

Time complexity: O(n) (with n being the number of keys in the DB, and assuming keys and pattern of limited length) param pattern return Multi bulk reply

func (*Redis) Lastsave

func (r *Redis) Lastsave() (int64, error)

Lastsave ...

func (*Redis) Lindex

func (r *Redis) Lindex(key string, index int64) (string, error)

Return the specified element of the list stored at the specified key. 0 is the first element, 1 the second and so on. Negative indexes are supported, for example -1 is the last element, -2 the penultimate and so on.

If the value stored at key is not of list type an error is returned. If the index is out of range a 'nil' reply is returned.

Note that even if the average time complexity is O(n) asking for the first or the last element of the list is O(1).

Time complexity: O(n) (with n being the length of the list) param key param index return Bulk reply, specifically the requested element

func (*Redis) Linsert

func (r *Redis) Linsert(key string, where ListOption, pivot, value string) (int64, error)

Inserts value in the list stored at key either before or after the reference value pivot.

When key does not exist, it is considered an empty list and no operation is performed.

An error is returned when key exists but does not hold a list value.

Return value Integer reply: the length of the list after the insert operation, or -1 when the value pivot was not found.

func (*Redis) Llen

func (r *Redis) Llen(key string) (int64, error)

Return the length of the list stored at the specified key. If the key does not exist zero is returned (the same behaviour as for empty lists). If the value stored at key is not a list an error is returned.

Time complexity: O(1) param key return The length of the list.

func (*Redis) Lpop

func (r *Redis) Lpop(key string) (string, error)

Atomically return and remove the first (LPOP) or last (RPOP) element of the list. For example if the list contains the elements "a","b","c" LPOP will return "a" and the list will become "b","c".

If the key does not exist or the list is already empty the special value 'nil' is returned. @see #rpop(String) param key return Bulk reply

func (*Redis) Lpush

func (r *Redis) Lpush(key string, strings ...string) (int64, error)

Add the string value to the head (LPUSH) or tail (RPUSH) of the list stored at key. If the key does not exist an empty list is created just before the append operation. If the key exists but is not a List an error is returned.

Time complexity: O(1) param key param strings return Integer reply, specifically, the number of elements inside the list after the push

operation.

func (*Redis) Lpushx

func (r *Redis) Lpushx(key string, string ...string) (int64, error)

Lpushx Inserts value at the head of the list stored at key, only if key already exists and holds a list. In contrary to LPUSH, no operation will be performed when key does not yet exist. Return value Integer reply: the length of the list after the push operation.

func (*Redis) Lrange

func (r *Redis) Lrange(key string, start, stop int64) ([]string, error)

Return the specified elements of the list stored at the specified key. Start and end are zero-based indexes. 0 is the first element of the list (the list head), 1 the next element and so on.

For example LRANGE foobar 0 2 will return the first three elements of the list.

start and end can also be negative numbers indicating offsets from the end of the list. For example -1 is the last element of the list, -2 the penultimate element and so on.

<b>Consistency with range functions in various programming languages</b>

Note that if you have a list of numbers from 0 to 100, LRANGE 0 10 will return 11 elements, that is, rightmost item is included. This may or may not be consistent with behavior of range-related functions in your programming language of choice (think Ruby's Range.new, Array#slice or Python's range() function).

LRANGE behavior is consistent with one of Tcl.

<b>Out-of-range indexes</b>

Indexes out of range will not produce an error: if start is over the end of the list, or start &gt; end, an empty list is returned. If end is over the end of the list Redis will threat it just like the last element of the list.

Time complexity: O(start+n) (with n being the length of the range and start being the start offset) param key param start param end return Multi bulk reply, specifically a list of elements in the specified range.

func (*Redis) Lrem

func (r *Redis) Lrem(key string, count int64, value string) (int64, error)

Remove the first count occurrences of the value element from the list. If count is zero all the elements are removed. If count is negative elements are removed from tail to head, instead to go from head to tail that is the normal behaviour. So for example LREM with count -2 and hello as value to remove against the list (a,b,c,hello,x,hello,hello) will lave the list (a,b,c,hello,x). The number of removed elements is returned as an integer, see below for more information about the returned value. Note that non existing keys are considered like empty lists by LREM, so LREM against non existing keys will always return 0.

Time complexity: O(N) (with N being the length of the list) param key param count param value return Integer Reply, specifically: The number of removed elements if the operation succeeded

func (*Redis) Lset

func (r *Redis) Lset(key string, index int64, value string) (string, error)

Set a new value as the element at index position of the List at key.

Out of range indexes will generate an error.

Similarly to other list commands accepting indexes, the index can be negative to access elements starting from the end of the list. So -1 is the last element, -2 is the penultimate, and so forth.

<b>Time complexity:</b>

O(N) (with N being the length of the list), setting the first or last elements of the list is O(1). @see #lindex(String, long) param key param index param value return Status code reply

func (*Redis) Ltrim

func (r *Redis) Ltrim(key string, start, stop int64) (string, error)

Trim an existing list so that it will contain only the specified range of elements specified. Start and end are zero-based indexes. 0 is the first element of the list (the list head), 1 the next element and so on.

For example LTRIM foobar 0 2 will modify the list stored at foobar key so that only the first three elements of the list will remain.

start and end can also be negative numbers indicating offsets from the end of the list. For example -1 is the last element of the list, -2 the penultimate element and so on.

Indexes out of range will not produce an error: if start is over the end of the list, or start &gt; end, an empty list is left as value. If end over the end of the list Redis will threat it just like the last element of the list.

Hint: the obvious use of LTRIM is together with LPUSH/RPUSH. For example:

{@code lpush("mylist", "someelement"); ltrim("mylist", 0, 99); //}

The above two commands will push elements in the list taking care that the list will not grow without limits. This is very useful when using Redis to store logs for example. It is important to note that when used in this way LTRIM is an O(1) operation because in the average case just one element is removed from the tail of the list.

Time complexity: O(n) (with n being len of list - len of range) param key param start param end return Status code reply

func (*Redis) Mget

func (r *Redis) Mget(keys ...string) ([]string, error)

Get the values of all the specified keys. If one or more keys dont exist or is not of type String, a 'nil' value is returned instead of the value of the specified key, but the operation never fails.

Time complexity: O(1) for every key param keys return Multi bulk reply

func (*Redis) Move

func (r *Redis) Move(key string, dbIndex int) (int64, error)

Move key from the currently selected database (see SELECT) to the specified destination database. When key already exists in the destination database, or it does not exist in the source database, it does nothing. It is possible to use MOVE as a locking primitive because of this.

Return value Integer reply, specifically:

1 if key was moved. 0 if key was not moved.

func (*Redis) Mset

func (r *Redis) Mset(keysvalues ...string) (string, error)

Set the the respective keys to the respective values. MSET will replace old values with new values, while {@link #msetnx(String...) MSETNX} will not perform any operation at all even if just a single key already exists.

Because of this semantic MSETNX can be used in order to set different keys representing different fields of an unique logic object in a way that ensures that either all the fields or none at all are set.

Both MSET and MSETNX are atomic operations. This means that for instance if the keys A and B are modified, another client talking to Redis can either see the changes to both A and B at once, or no modification at all. @see #msetnx(String...) param keysvalues return Status code reply Basically +OK as MSET can't fail

func (*Redis) Msetnx

func (r *Redis) Msetnx(keysvalues ...string) (int64, error)

Set the the respective keys to the respective values. {@link #mset(String...) MSET} will replace old values with new values, while MSETNX will not perform any operation at all even if just a single key already exists.

Because of this semantic MSETNX can be used in order to set different keys representing different fields of an unique logic object in a way that ensures that either all the fields or none at all are set.

Both MSET and MSETNX are atomic operations. This means that for instance if the keys A and B are modified, another client talking to Redis can either see the changes to both A and B at once, or no modification at all. @see #mset(String...) param keysvalues return Integer reply, specifically: 1 if the all the keys were set 0 if no key was set (at

least one key already existed)

func (*Redis) Multi

func (r *Redis) Multi() (*transaction, error)

get transaction of redis client ,when use transaction mode, you need to invoke this first

func (*Redis) ObjectEncoding

func (r *Redis) ObjectEncoding(str string) (string, error)

ObjectEncoding ...

func (*Redis) ObjectIdletime

func (r *Redis) ObjectIdletime(str string) (int64, error)

ObjectIdletime ...

func (*Redis) ObjectRefcount

func (r *Redis) ObjectRefcount(str string) (int64, error)

objectRefcount ...

func (*Redis) Persist

func (r *Redis) Persist(key string) (int64, error)

Undo a {@link #expire(String, int) expire} at turning the expire key into a normal key.

Time complexity: O(1) param key return Integer reply, specifically: 1: the key is now persist. 0: the key is not persist (only

happens when key not set).

func (*Redis) Pexpire

func (r *Redis) Pexpire(key string, milliseconds int64) (int64, error)

This command works exactly like EXPIRE but the time to live of the key is specified in milliseconds instead of seconds.

Return value Integer reply, specifically:

1 if the timeout was set. 0 if key does not exist.

func (*Redis) PexpireAt

func (r *Redis) PexpireAt(key string, millisecondsTimestamp int64) (int64, error)

PEXPIREAT has the same effect and semantic as EXPIREAT, but the Unix time at which the key will expire is specified in milliseconds instead of seconds.

Return value Integer reply, specifically:

1 if the timeout was set. 0 if key does not exist.

func (*Redis) Pfadd

func (r *Redis) Pfadd(key string, elements ...string) (int64, error)

Pfadd ...

func (*Redis) Pfcount

func (r *Redis) Pfcount(keys ...string) (int64, error)

/Pfcount ...

func (*Redis) Pfmerge

func (r *Redis) Pfmerge(destkey string, sourcekeys ...string) (string, error)

Pfmerge ...

func (*Redis) Ping

func (r *Redis) Ping() (string, error)

Ping ...

func (*Redis) Pipelined

func (r *Redis) Pipelined() *pipeline

get pipeline of redis client ,when use pipeline mode, you need to invoke this first

func (*Redis) Psetex

func (r *Redis) Psetex(key string, milliseconds int64, value string) (string, error)

PSETEX works exactly like SETEX with the sole difference that the expire time is specified in milliseconds instead of seconds.

func (*Redis) Psubscribe

func (r *Redis) Psubscribe(redisPubSub *RedisPubSub, patterns ...string) error

Psubscribe ...

func (*Redis) Pttl

func (r *Redis) Pttl(key string) (int64, error)

Pttl Like TTL this command returns the remaining time to live of a key that has an expire set, with the sole difference that TTL returns the amount of remaining time in seconds while PTTL returns it in milliseconds. In Redis 2.6 or older the command returns -1 if the key does not exist or if the key exist but has no associated expire. Starting with Redis 2.8 the return value in case of error changed: The command returns -2 if the key does not exist. The command returns -1 if the key exists but has no associated expire.

Integer reply: TTL in milliseconds, or a negative value in order to signal an error (see the description above).

func (*Redis) Publish

func (r *Redis) Publish(channel, message string) (int64, error)

Publish ...

func (*Redis) PubsubChannels

func (r *Redis) PubsubChannels(pattern string) ([]string, error)

PubsubChannels ...

func (*Redis) Quit

func (r *Redis) Quit() (string, error)

Quit Ask the server to close the connection. The connection is closed as soon as all pending replies have been written to the client.

Return value Simple string reply: always OK.

func (*Redis) RandomKey

func (r *Redis) RandomKey() (string, error)

RandomKey ...

func (*Redis) Readonly

func (r *Redis) Readonly() (string, error)

Enables read queries for a connection to a Redis Cluster replica node.

Normally replica nodes will redirect clients to the authoritative master for the hash slot involved in a given command, however clients can use replicas in order to scale reads using the READONLY command.

READONLY tells a Redis Cluster replica node that the client is willing to read possibly stale data and is not interested in running write queries.

When the connection is in readonly mode, the cluster will send a redirection to the client only if the operation involves keys not served by the replica's master node. This may happen because:

The client sent a command about hash slots never served by the master of this replica. The cluster was reconfigured (for example resharded) and the replica is no longer able to serve commands for a given hash slot. Return value Simple string reply

func (*Redis) Receive

func (r *Redis) Receive() error

Receive receive reply from redis

func (*Redis) Rename

func (r *Redis) Rename(oldkey, newkey string) (string, error)

Atomically renames the key oldkey to newkey. If the source and destination name are the same an error is returned. If newkey already exists it is overwritten.

Time complexity: O(1) param oldkey param newkey return Status code repy

func (*Redis) Renamenx

func (r *Redis) Renamenx(oldkey, newkey string) (int64, error)

Rename oldkey into newkey but fails if the destination key newkey already exists.

Time complexity: O(1) param oldkey param newkey return Integer reply, specifically: 1 if the key was renamed 0 if the target key already exist

func (*Redis) Rpop

func (r *Redis) Rpop(key string) (string, error)

Atomically return and remove the first (LPOP) or last (RPOP) element of the list. For example if the list contains the elements "a","b","c" RPOP will return "c" and the list will become "a","b".

If the key does not exist or the list is already empty the special value 'nil' is returned. @see #lpop(String) param key return Bulk reply

func (*Redis) Rpoplpush

func (r *Redis) Rpoplpush(srckey, dstkey string) (string, error)

Atomically return and remove the last (tail) element of the srckey list, and push the element as the first (head) element of the dstkey list. For example if the source list contains the elements "a","b","c" and the destination list contains the elements "foo","bar" after an RPOPLPUSH command the content of the two lists will be "a","b" and "c","foo","bar".

If the key does not exist or the list is already empty the special value 'nil' is returned. If the srckey and dstkey are the same the operation is equivalent to removing the last element from the list and pusing it as first element of the list, so it's a "list rotation" command.

Time complexity: O(1) param srckey param dstkey return Bulk reply

func (*Redis) Rpush

func (r *Redis) Rpush(key string, strings ...string) (int64, error)

Add the string value to the head (LPUSH) or tail (RPUSH) of the list stored at key. If the key does not exist an empty list is created just before the append operation. If the key exists but is not a List an error is returned.

Time complexity: O(1) param key param strings return Integer reply, specifically, the number of elements inside the list after the push

operation.

func (*Redis) Rpushx

func (r *Redis) Rpushx(key string, string ...string) (int64, error)

Rpushx Inserts value at the tail of the list stored at key, only if key already exists and holds a list. In contrary to RPUSH, no operation will be performed when key does not yet exist.

Return value Integer reply: the length of the list after the push operation.

func (*Redis) Sadd

func (r *Redis) Sadd(key string, members ...string) (int64, error)

Add the specified member to the set value stored at key. If member is already a member of the set no operation is performed. If key does not exist a new set with the specified member as sole member is created. If the key exists but does not hold a set value an error is returned.

Time complexity O(1) param key param members return Integer reply, specifically: 1 if the new element was added 0 if the element was

already a member of the set

func (*Redis) Save

func (r *Redis) Save() (string, error)

Save ...

func (*Redis) Scan

func (r *Redis) Scan(cursor string, params ...ScanParams) (*ScanResult, error)

Scan ...

func (*Redis) Scard

func (r *Redis) Scard(key string) (int64, error)

Return the set cardinality (number of elements). If the key does not exist 0 is returned, like for empty sets. param key return Integer reply, specifically: the cardinality (number of elements) of the set as an

integer.

func (*Redis) ScriptExists

func (r *Redis) ScriptExists(sha1 ...string) ([]bool, error)

ScriptExists ...

func (*Redis) ScriptLoad

func (r *Redis) ScriptLoad(script string) (string, error)

ScriptLoad ...

func (*Redis) Sdiff

func (r *Redis) Sdiff(keys ...string) ([]string, error)

Return the difference between the Set stored at key1 and all the Sets key2, ..., keyN

<b>Example:</b> <pre> key1 = [x, a, b, c] key2 = [c] key3 = [a, d] SDIFF key1,key2,key3 =&gt; [x, b] </pre> Non existing keys are considered like empty sets.

<b>Time complexity:</b>

O(N) with N being the total number of elements of all the sets param keys return Return the members of a set resulting from the difference between the first set

provided and all the successive sets.

func (*Redis) Sdiffstore

func (r *Redis) Sdiffstore(dstkey string, keys ...string) (int64, error)

This command works exactly like {@link #sdiff(String...) SDIFF} but instead of being returned the resulting set is stored in dstkey. param dstkey param keys return Status code reply

func (*Redis) Select

func (r *Redis) Select(index int) (string, error)

Select ...

func (*Redis) Send

func (r *Redis) Send(command protocolCommand, args ...[]byte) error

Send send command to redis

func (*Redis) SendByStr

func (r *Redis) SendByStr(command string, args ...[]byte) error

SendByStr send command to redis

func (*Redis) SentinelFailover

func (r *Redis) SentinelFailover(masterName string) (string, error)

SentinelFailover ...

func (*Redis) SentinelGetMasterAddrByName

func (r *Redis) SentinelGetMasterAddrByName(masterName string) ([]string, error)

<pre> redis 127.0.0.1:26381&gt; sentinel get-master-addr-by-name mymaster 1) "127.0.0.1" 2) "6379" </pre> param masterName return two elements list of strings : host and port.

func (*Redis) SentinelMasters

func (r *Redis) SentinelMasters() ([]map[string]string, error)

<pre> redis 127.0.0.1:26381&gt; sentinel masters 1) 1) "name"

2. "mymaster"
3. "ip"
4. "127.0.0.1"
5. "port"
6. "6379"
7. "runid"
8. "93d4d4e6e9c06d0eea36e27f31924ac26576081d"
9. "flags"
10. "master"
11. "pending-commands"
12. "0"
13. "last-ok-ping-reply"
14. "423"
15. "last-ping-reply"
16. "423"
17. "info-refresh"
18. "6107"
19. "num-slaves"
20. "1"
21. "num-other-sentinels"
22. "2"
23. "quorum"
24. "2"

</pre> return

func (*Redis) SentinelMonitor

func (r *Redis) SentinelMonitor(masterName, ip string, port, quorum int) (string, error)

SentinelMonitor ...

func (*Redis) SentinelRemove

func (r *Redis) SentinelRemove(masterName string) (string, error)

SentinelRemove ...

func (*Redis) SentinelReset

func (r *Redis) SentinelReset(pattern string) (int64, error)

<pre> redis 127.0.0.1:26381&gt; sentinel reset mymaster (integer) 1 </pre> param pattern return

func (*Redis) SentinelSet

func (r *Redis) SentinelSet(masterName string, parameterMap map[string]string) (string, error)

SentinelSet ...

func (*Redis) SentinelSlaves

func (r *Redis) SentinelSlaves(masterName string) ([]map[string]string, error)

<pre> redis 127.0.0.1:26381&gt; sentinel slaves mymaster 1) 1) "name"

2. "127.0.0.1:6380"
3. "ip"
4. "127.0.0.1"
5. "port"
6. "6380"
7. "runid"
8. "d7f6c0ca7572df9d2f33713df0dbf8c72da7c039"
9. "flags"
10. "slave"
11. "pending-commands"
12. "0"
13. "last-ok-ping-reply"
14. "47"
15. "last-ping-reply"
16. "47"
17. "info-refresh"
18. "657"
19. "master-link-down-time"
20. "0"
21. "master-link-status"
22. "ok"
23. "master-host"
24. "localhost"
25. "master-port"
26. "6379"
27. "slave-priority"
28. "100"

</pre> param masterName return

func (*Redis) Set

func (r *Redis) Set(key, value string) (string, error)

Set the string value as value of the key. The string can't be longer than 1073741824 bytes (1 //GB) return Status code reply

func (*Redis) SetWithParams

func (r *Redis) SetWithParams(key, value, nxxx string) (string, error)

see SetWithParamsAndTime(key, value, nxxx, expx string, time int64)

func (*Redis) SetWithParamsAndTime

func (r *Redis) SetWithParamsAndTime(key, value, nxxx, expx string, time int64) (string, error)

Set the string value as value of the key. The string can't be longer than 1073741824 bytes (1 //GB). param nxxx NX|XX, NX -- Only set the key if it does not already exist. XX -- Only set the key if it already exist. param expx EX|PX, expire time units: EX = seconds; PX = milliseconds param time expire time in the units of <code>expx</code> return Status code reply

func (*Redis) Setbit

func (r *Redis) Setbit(key string, offset int64, value string) (bool, error)

Sets or clears the bit at offset in the string value stored at key.

The bit is either set or cleared depending on value, which can be either 0 or 1. When key does not exist, a new string value is created. The string is grown to make sure it can hold a bit at offset. The offset argument is required to be greater than or equal to 0, and smaller than 232 (this limits bitmaps to 512MB). When the string at key is grown, added bits are set to 0.

Warning: When setting the last possible bit (offset equal to 232 -1) and the string value stored at key does not yet hold a string value, or holds a small string value, Redis needs to allocate all intermediate memory which can block the server for some time. On a 2010 MacBook Pro, setting bit number 232 -1 (512MB allocation) takes ~300ms, setting bit number 230 -1 (128MB allocation) takes ~80ms, setting bit number 228 -1 (32MB allocation) takes ~30ms and setting bit number 226 -1 (8MB allocation) takes ~8ms. Note that once this first allocation is done, subsequent calls to SETBIT for the same key will not have the allocation overhead.

Return value Integer reply: the original bit value stored at offset.

func (*Redis) SetbitWithBool

func (r *Redis) SetbitWithBool(key string, offset int64, value bool) (bool, error)

see Setbit(key string, offset int64, value string)

func (*Redis) Setex

func (r *Redis) Setex(key string, seconds int, value string) (string, error)

The command is exactly equivalent to the following group of commands: {@link #set(String, String) SET} + {@link #expire(String, int) EXPIRE}. The operation is atomic.

Time complexity: O(1) param key param seconds param value return Status code reply

func (*Redis) Setnx

func (r *Redis) Setnx(key, value string) (int64, error)

SETNX works exactly like {@link #set(String, String) SET} with the only difference that if the key already exists no operation is performed. SETNX actually means "SET if Not eXists".

Time complexity: O(1) param key param value return Integer reply, specifically: 1 if the key was set 0 if the key was not set

func (*Redis) Setrange

func (r *Redis) Setrange(key string, offset int64, value string) (int64, error)

Setrange Overwrites part of the string stored at key, starting at the specified offset, for the entire length of value. If the offset is larger than the current length of the string at key, the string is padded with zero-bytes to make offset fit. Non-existing keys are considered as empty strings, so this command will make sure it holds a string large enough to be able to set value at offset. Note that the maximum offset that you can set is 229 -1 (536870911), as Redis Strings are limited to 512 megabytes. If you need to grow beyond this size, you can use multiple keys.

Warning: When setting the last possible byte and the string value stored at key does not yet hold a string value, or holds a small string value, Redis needs to allocate all intermediate memory which can block the server for some time. On a 2010 MacBook Pro, setting byte number 536870911 (512MB allocation) takes ~300ms, setting byte number 134217728 (128MB allocation) takes ~80ms, setting bit number 33554432 (32MB allocation) takes ~30ms and setting bit number 8388608 (8MB allocation) takes ~8ms. Note that once this first allocation is done, subsequent calls to SETRANGE for the same key will not have the allocation overhead.

Patterns Thanks to SETRANGE and the analogous GETRANGE commands, you can use Redis strings as a linear array with O(1) random access. This is a very fast and efficient storage in many real world use cases.

Return value Integer reply: the length of the string after it was modified by the command.

func (*Redis) Shutdown

func (r *Redis) Shutdown() (string, error)

Shutdown ...

func (*Redis) Sinter

func (r *Redis) Sinter(keys ...string) ([]string, error)

Return the members of a set resulting from the intersection of all the sets hold at the specified keys. Like in {@link #lrange(String, long, long) LRANGE} the result is sent to the client as a multi-bulk reply (see the protocol specification for more information). If just a single key is specified, then this command produces the same result as {@link #smembers(String) SMEMBERS}. Actually SMEMBERS is just syntax sugar for SINTER.

Non existing keys are considered like empty sets, so if one of the keys is missing an empty set is returned (since the intersection with an empty set always is an empty set).

Time complexity O(N*M) worst case where N is the cardinality of the smallest set and M the number of sets param keys return Multi bulk reply, specifically the list of common elements.

func (*Redis) Sinterstore

func (r *Redis) Sinterstore(dstkey string, keys ...string) (int64, error)

This commnad works exactly like {@link #sinter(String...) SINTER} but instead of being returned the resulting set is sotred as dstkey.

Time complexity O(N*M) worst case where N is the cardinality of the smallest set and M the number of sets param dstkey param keys return Status code reply

func (*Redis) Sismember

func (r *Redis) Sismember(key, member string) (bool, error)

Return 1 if member is a member of the set stored at key, otherwise 0 is returned.

Time complexity O(1) param key param member return Integer reply, specifically: 1 if the element is a member of the set 0 if the element

is not a member of the set OR if the key does not exist

func (*Redis) Slaveof

func (r *Redis) Slaveof(host string, port int) (string, error)

Slaveof ...

func (*Redis) SlaveofNoOne

func (r *Redis) SlaveofNoOne() (string, error)

SlaveofNoOne ...

func (*Redis) SlowlogGet

func (r *Redis) SlowlogGet(entries ...int64) ([]Slowlog, error)

SlowlogGet ...

func (*Redis) SlowlogLen

func (r *Redis) SlowlogLen() (int64, error)

SlowlogLen ...

func (*Redis) SlowlogReset

func (r *Redis) SlowlogReset() (string, error)

SlowlogReset ...

func (*Redis) Smembers

func (r *Redis) Smembers(key string) ([]string, error)

Return all the members (elements) of the set value stored at key. This is just syntax glue for {@link #sinter(String...) SINTER}.

Time complexity O(N) param key return Multi bulk reply

func (*Redis) Smove

func (r *Redis) Smove(srckey, dstkey, member string) (int64, error)

Move the specifided member from the set at srckey to the set at dstkey. This operation is atomic, in every given moment the element will appear to be in the source or destination set for accessing clients.

If the source set does not exist or does not contain the specified element no operation is performed and zero is returned, otherwise the element is removed from the source set and added to the destination set. On success one is returned, even if the element was already present in the destination set.

An error is raised if the source or destination keys contain a non Set value.

Time complexity O(1) param srckey param dstkey param member return Integer reply, specifically: 1 if the element was moved 0 if the element was not found

on the first set and no operation was performed

func (*Redis) Sort

func (r *Redis) Sort(key string, sortingParameters ...SortingParams) ([]string, error)

Sort a Set or a List.

Sort the elements contained in the List, Set, or Sorted Set value at key. By default sorting is numeric with elements being compared as double precision floating point numbers. This is the simplest form of SORT. @see #sort(String, String) @see #sort(String, SortingParams) @see #sort(String, SortingParams, String) param key return Assuming the Set/List at key contains a list of numbers, the return value will be the

list of numbers ordered from the smallest to the biggest number.

func (*Redis) SortMulti

func (r *Redis) SortMulti(key, dstkey string, sortingParameters ...SortingParams) (int64, error)

SortMulti ...

func (*Redis) Spop

func (r *Redis) Spop(key string) (string, error)

Remove a random element from a Set returning it as return value. If the Set is empty or the key does not exist, a nil object is returned.

The {@link #srandmember(String)} command does a similar work but the returned element is not removed from the Set.

Time complexity O(1) param key return Bulk reply

func (*Redis) SpopBatch

func (r *Redis) SpopBatch(key string, count int64) ([]string, error)

remove multi random element see Spop(key string)

func (*Redis) Srandmember

func (r *Redis) Srandmember(key string) (string, error)

Return a random element from a Set, without removing the element. If the Set is empty or the key does not exist, a nil object is returned.

The SPOP command does a similar work but the returned element is popped (removed) from the Set.

Time complexity O(1) param key return Bulk reply

func (*Redis) SrandmemberBatch

func (r *Redis) SrandmemberBatch(key string, count int) ([]string, error)

see Srandmember(key string)

func (*Redis) Srem

func (r *Redis) Srem(key string, members ...string) (int64, error)

Remove the specified member from the set value stored at key. If member was not a member of the set no operation is performed. If key does not hold a set value an error is returned.

Time complexity O(1) param key param members return Integer reply, specifically: 1 if the new element was removed 0 if the new element was

not a member of the set

func (*Redis) Sscan

func (r *Redis) Sscan(key, cursor string, params ...ScanParams) (*ScanResult, error)

Sscan ...

func (*Redis) Strlen

func (r *Redis) Strlen(key string) (int64, error)

Strlen Returns the length of the string value stored at key. An error is returned when key holds a non-string value. Return value Integer reply: the length of the string at key, or 0 when key does not exist.

func (*Redis) Subscribe

func (r *Redis) Subscribe(redisPubSub *RedisPubSub, channels ...string) error

Subscribe ...

func (*Redis) Substr

func (r *Redis) Substr(key string, start, end int) (string, error)

Return a subset of the string from offset start to offset end (both offsets are inclusive). Negative offsets can be used in order to provide an offset starting from the end of the string. So -1 means the last char, -2 the penultimate and so forth.

The function handles out of range requests without raising an error, but just limiting the resulting range to the actual length of the string.

Time complexity: O(start+n) (with start being the start index and n the total length of the requested range). Note that the lookup part of this command is O(1) so for small strings this is actually an O(1) command. param key param start param end return Bulk reply

func (*Redis) Sunion

func (r *Redis) Sunion(keys ...string) ([]string, error)

Return the members of a set resulting from the union of all the sets hold at the specified keys. Like in {@link #lrange(String, long, long) LRANGE} the result is sent to the client as a multi-bulk reply (see the protocol specification for more information). If just a single key is specified, then this command produces the same result as {@link #smembers(String) SMEMBERS}.

Non existing keys are considered like empty sets.

Time complexity O(N) where N is the total number of elements in all the provided sets param keys return Multi bulk reply, specifically the list of common elements.

func (*Redis) Sunionstore

func (r *Redis) Sunionstore(dstkey string, keys ...string) (int64, error)

This command works exactly like {@link #sunion(String...) SUNION} but instead of being returned the resulting set is stored as dstkey. Any existing value in dstkey will be over-written.

Time complexity O(N) where N is the total number of elements in all the provided sets param dstkey param keys return Status code reply

func (*Redis) Ttl

func (r *Redis) Ttl(key string) (int64, error)

The TTL command returns the remaining time to live in seconds of a key that has an {@link #expire(String, int) EXPIRE} set. This introspection capability allows a Redis client to check how many seconds a given key will continue to be part of the dataset. param key return Integer reply, returns the remaining time to live in seconds of a key that has an

EXPIRE. In Redis 2.6 or older, if the Key does not exists or does not have an
associated expire, -1 is returned. In Redis 2.8 or newer, if the Key does not have an
associated expire, -1 is returned or if the Key does not exists, -2 is returned.

func (*Redis) Type

func (r *Redis) Type(key string) (string, error)

Return the type of the value stored at key in form of a string. The type can be one of "none", "string", "list", "set". "none" is returned if the key does not exist. Time complexity: O(1) param key return Status code reply, specifically: "none" if the key does not exist "string" if the key

contains a String value "list" if the key contains a List value "set" if the key
contains a Set value "zset" if the key contains a Sorted Set value "hash" if the key
contains a Hash value

func (*Redis) Unwatch

func (r *Redis) Unwatch() (string, error)

Unwatch ...

func (*Redis) WaitReplicas

func (r *Redis) WaitReplicas(replicas int, timeout int64) (int64, error)

WaitReplicas ...

func (*Redis) Watch

func (r *Redis) Watch(keys ...string) (string, error)

Marks the given keys to be watched for conditional execution of a transaction.

Return value Simple string reply: always OK.

func (*Redis) Zadd

func (r *Redis) Zadd(key string, score float64, member string, mparams ...ZAddParams) (int64, error)

Add the specified member having the specifeid score to the sorted set stored at key. If member is already a member of the sorted set the score is updated, and the element reinserted in the right position to ensure sorting. If key does not exist a new sorted set with the specified member as sole member is crated. If the key exists but does not hold a sorted set value an error is returned.

The score value can be the string representation of a double precision floating point number.

Time complexity O(log(N)) with N being the number of elements in the sorted set param key param score param member return Integer reply, specifically: 1 if the new element was added 0 if the element was

already a member of the sorted set and the score was updated

func (*Redis) ZaddByMap

func (r *Redis) ZaddByMap(key string, scoreMembers map[string]float64, params ...ZAddParams) (int64, error)

see Zadd(key string, score float64, member string, mparams ...ZAddParams)

func (*Redis) Zcard

func (r *Redis) Zcard(key string) (int64, error)

Return the sorted set cardinality (number of elements). If the key does not exist 0 is returned, like for empty sorted sets.

Time complexity O(1) param key return the cardinality (number of elements) of the set as an integer.

func (*Redis) Zcount

func (r *Redis) Zcount(key, min, max string) (int64, error)

Zcount Returns the number of elements in the sorted set at key with a score between min and max. The min and max arguments have the same semantic as described for ZRANGEBYSCORE. Note: the command has a complexity of just O(log(N)) because it uses elements ranks (see ZRANK) to get an idea of the range. Because of this there is no need to do a work proportional to the size of the range.

Return value Integer reply: the number of elements in the specified score range.

func (*Redis) Zincrby

func (r *Redis) Zincrby(key string, increment float64, member string, params ...ZAddParams) (float64, error)

If member already exists in the sorted set adds the increment to its score and updates the position of the element in the sorted set accordingly. If member does not already exist in the sorted set it is added with increment as score (that is, like if the previous score was virtually zero). If key does not exist a new sorted set with the specified member as sole member is crated. If the key exists but does not hold a sorted set value an error is returned.

The score value can be the string representation of a double precision floating point number. It's possible to provide a negative value to perform a decrement.

For an introduction to sorted sets check the Introduction to Redis data types page.

Time complexity O(log(N)) with N being the number of elements in the sorted set param key param score param member return The new score

func (*Redis) Zinterstore

func (r *Redis) Zinterstore(dstkey string, sets ...string) (int64, error)

Creates a union or intersection of N sorted sets given by keys k1 through kN, and stores it at dstkey. It is mandatory to provide the number of input keys N, before passing the input keys and the other (optional) arguments.

As the terms imply, the {@link #zinterstore(String, String...) ZINTERSTORE} command requires an element to be present in each of the given inputs to be inserted in the result. The {@link #zunionstore(String, String...) ZUNIONSTORE} command inserts all elements across all inputs.

Using the WEIGHTS option, it is possible to add weight to each input sorted set. This means that the score of each element in the sorted set is first multiplied by this weight before being passed to the aggregation. When this option is not given, all weights default to 1.

With the AGGREGATE option, it's possible to specify how the results of the union or intersection are aggregated. This option defaults to SUM, where the score of an element is summed across the inputs where it exists. When this option is set to be either MIN or MAX, the resulting set will contain the minimum or maximum score of an element across the inputs where it exists.

<b>Time complexity:</b> O(N) + O(M log(M)) with N being the sum of the sizes of the input sorted sets, and M being the number of elements in the resulting sorted set @see #zunionstore(String, String...) @see #zunionstore(String, ZParams, String...) @see #zinterstore(String, String...) @see #zinterstore(String, ZParams, String...) param dstkey param sets return Integer reply, specifically the number of elements in the sorted set at dstkey

func (*Redis) ZinterstoreWithParams

func (r *Redis) ZinterstoreWithParams(dstkey string, params ZParams, sets ...string) (int64, error)

ZinterstoreWithParams ...

func (*Redis) Zlexcount

func (r *Redis) Zlexcount(key, min, max string) (int64, error)

When all the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering, this command returns the number of elements in the sorted set at key with a value between min and max.

The min and max arguments have the same meaning as described for ZRANGEBYLEX.

Note: the command has a complexity of just O(log(N)) because it uses elements ranks (see ZRANK) to get an idea of the range. Because of this there is no need to do a work proportional to the size of the range.

Return value Integer reply: the number of elements in the specified score range.

func (*Redis) Zrange

func (r *Redis) Zrange(key string, start, stop int64) ([]string, error)

Returns the specified range of elements in the sorted set stored at key. The elements are considered to be ordered from the lowest to the highest score. Lexicographical order is used for elements with equal score. See ZREVRANGE when you need the elements ordered from highest to lowest score (and descending lexicographical order for elements with equal score). Both start and stop are zero-based indexes, where 0 is the first element, 1 is the next element and so on. They can also be negative numbers indicating offsets from the end of the sorted set, with -1 being the last element of the sorted set, -2 the penultimate element and so on. start and stop are inclusive ranges, so for example ZRANGE myzset 0 1 will return both the first and the second element of the sorted set. Out of range indexes will not produce an error. If start is larger than the largest index in the sorted set, or start > stop, an empty list is returned. If stop is larger than the end of the sorted set Redis will treat it like it is the last element of the sorted set. It is possible to pass the WITHSCORES option in order to return the scores of the elements together with the elements. The returned list will contain value1,score1,...,valueN,scoreN instead of value1,...,valueN. Client libraries are free to return a more appropriate data type (suggestion: an array with (value, score) arrays/tuples). Return value Array reply: list of elements in the specified range (optionally with their scores, in case the WITHSCORES option is given).

func (*Redis) ZrangeByLex

func (r *Redis) ZrangeByLex(key, min, max string) ([]string, error)

When all the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering, this command returns all the elements in the sorted set at key with a value between min and max.

If the elements in the sorted set have different scores, the returned elements are unspecified.

The elements are considered to be ordered from lower to higher strings as compared byte-by-byte using the memcmp() C function. Longer strings are considered greater than shorter strings if the common part is identical.

The optional LIMIT argument can be used to only get a range of the matching elements (similar to SELECT LIMIT offset, count in SQL). A negative count returns all elements from the offset. Keep in mind that if offset is large, the sorted set needs to be traversed for offset elements before getting to the elements to return, which can add up to O(N) time complexity. Return value Array reply: list of elements in the specified score range.

func (*Redis) ZrangeByLexBatch

func (r *Redis) ZrangeByLexBatch(key, min, max string, offset, count int) ([]string, error)

see ZrangeByLex()

func (*Redis) ZrangeByScore

func (r *Redis) ZrangeByScore(key, min, max string) ([]string, error)

Return the all the elements in the sorted set at key with a score between min and max (including elements with score equal to min or max).

The elements having the same score are returned sorted lexicographically as ASCII strings (this follows from a property of Redis sorted sets and does not involve further computation).

Using the optional {@link #zrangeByScore(String, double, double, int, int) LIMIT} it's possible to get only a range of the matching elements in an SQL-alike way. Note that if offset is large the commands needs to traverse the list for offset elements and this adds up to the O(M) figure.

The {@link #zcount(String, double, double) ZCOUNT} command is similar to {@link #zrangeByScore(String, double, double) ZRANGEBYSCORE} but instead of returning the actual elements in the specified interval, it just returns the number of matching elements.

<b>Exclusive intervals and infinity</b>

min and max can be -inf and +inf, so that you are not required to know what's the greatest or smallest element in order to take, for instance, elements "up to a given value".

Also while the interval is for default closed (inclusive) it's possible to specify open intervals prefixing the score with a "(" character, so for instance:

{@code ZRANGEBYSCORE zset (1.3 5}

Will return all the values with score &gt; 1.3 and &lt;= 5, while for instance:

{@code ZRANGEBYSCORE zset (5 (10}

Will return all the values with score &gt; 5 and &lt; 10 (5 and 10 excluded).

<b>Time complexity:</b>

O(log(N))+O(M) with N being the number of elements in the sorted set and M the number of elements returned by the command, so if M is constant (for instance you always ask for the first ten elements with LIMIT) you can consider it O(log(N)) @see #zrangeByScore(String, double, double) @see #zrangeByScore(String, double, double, int, int) @see #zrangeByScoreWithScores(String, double, double) @see #zrangeByScoreWithScores(String, String, String) @see #zrangeByScoreWithScores(String, double, double, int, int) @see #zcount(String, double, double) param key param min a double or Double.MIN_VALUE for "-inf" param max a double or Double.MAX_VALUE for "+inf" return Multi bulk reply specifically a list of elements in the specified score range.

func (*Redis) ZrangeByScoreBatch

func (r *Redis) ZrangeByScoreBatch(key, min, max string, offset, count int) ([]string, error)

see Zrange()

func (*Redis) ZrangeByScoreWithScores

func (r *Redis) ZrangeByScoreWithScores(key, min, max string) ([]Tuple, error)

Return the all the elements in the sorted set at key with a score between min and max (including elements with score equal to min or max).

The elements having the same score are returned sorted lexicographically as ASCII strings (this follows from a property of Redis sorted sets and does not involve further computation).

Using the optional {@link #zrangeByScore(String, double, double, int, int) LIMIT} it's possible to get only a range of the matching elements in an SQL-alike way. Note that if offset is large the commands needs to traverse the list for offset elements and this adds up to the O(M) figure.

The {@link #zcount(String, double, double) ZCOUNT} command is similar to {@link #zrangeByScore(String, double, double) ZRANGEBYSCORE} but instead of returning the actual elements in the specified interval, it just returns the number of matching elements.

<b>Exclusive intervals and infinity</b>

min and max can be -inf and +inf, so that you are not required to know what's the greatest or smallest element in order to take, for instance, elements "up to a given value".

Also while the interval is for default closed (inclusive) it's possible to specify open intervals prefixing the score with a "(" character, so for instance:

{@code ZRANGEBYSCORE zset (1.3 5}

Will return all the values with score &gt; 1.3 and &lt;= 5, while for instance:

{@code ZRANGEBYSCORE zset (5 (10}

Will return all the values with score &gt; 5 and &lt; 10 (5 and 10 excluded).

<b>Time complexity:</b>

O(log(N))+O(M) with N being the number of elements in the sorted set and M the number of elements returned by the command, so if M is constant (for instance you always ask for the first ten elements with LIMIT) you can consider it O(log(N)) @see #zrangeByScore(String, double, double) @see #zrangeByScore(String, double, double, int, int) @see #zrangeByScoreWithScores(String, double, double) @see #zrangeByScoreWithScores(String, double, double, int, int) @see #zcount(String, double, double) param key param min param max return Multi bulk reply specifically a list of elements in the specified score range.

func (*Redis) ZrangeByScoreWithScoresBatch

func (r *Redis) ZrangeByScoreWithScoresBatch(key, min, max string, offset, count int) ([]Tuple, error)

see Zrange()

func (*Redis) ZrangeWithScores

func (r *Redis) ZrangeWithScores(key string, start, end int64) ([]Tuple, error)

see Zrange()

func (*Redis) Zrank

func (r *Redis) Zrank(key, member string) (int64, error)

Return the rank (or index) or member in the sorted set at key, with scores being ordered from low to high.

When the given member does not exist in the sorted set, the special value 'nil' is returned. The returned rank (or index) of the member is 0-based for both commands.

<b>Time complexity:</b>

O(log(N)) @see #zrevrank(String, String) param key param member return Integer reply or a nil bulk reply, specifically: the rank of the element as an integer

reply if the element exists. A nil bulk reply if there is no such element.

func (*Redis) Zrem

func (r *Redis) Zrem(key string, members ...string) (int64, error)

Remove the specified member from the sorted set value stored at key. If member was not a member of the set no operation is performed. If key does not not hold a set value an error is returned.

Time complexity O(log(N)) with N being the number of elements in the sorted set param key param members return Integer reply, specifically: 1 if the new element was removed 0 if the new element was

not a member of the set

func (*Redis) ZremrangeByLex

func (r *Redis) ZremrangeByLex(key, min, max string) (int64, error)

When all the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering, this command removes all elements in the sorted set stored at key between the lexicographical range specified by min and max.

The meaning of min and max are the same of the ZRANGEBYLEX command. Similarly, this command actually returns the same elements that ZRANGEBYLEX would return if called with the same min and max arguments.

Return value Integer reply: the number of elements removed.

func (*Redis) ZremrangeByRank

func (r *Redis) ZremrangeByRank(key string, start, stop int64) (int64, error)

Remove all elements in the sorted set at key with rank between start and end. Start and end are 0-based with rank 0 being the element with the lowest score. Both start and end can be negative numbers, where they indicate offsets starting at the element with the highest rank. For example: -1 is the element with the highest score, -2 the element with the second highest score and so forth.

<b>Time complexity:</b> O(log(N))+O(M) with N being the number of elements in the sorted set and M the number of elements removed by the operation

func (*Redis) ZremrangeByScore

func (r *Redis) ZremrangeByScore(key, start, end string) (int64, error)

Removes all elements in the sorted set stored at key with a score between min and max (inclusive).

Since version 2.1.6, min and max can be exclusive, following the syntax of ZRANGEBYSCORE.

Return value Integer reply: the number of elements removed.

func (*Redis) Zrevrange

func (r *Redis) Zrevrange(key string, start, stop int64) ([]string, error)

Returns the specified range of elements in the sorted set stored at key. The elements are considered to be ordered from the highest to the lowest score. Descending lexicographical order is used for elements with equal score. Apart from the reversed ordering, ZREVRANGE is similar to ZRANGE. Return value Array reply: list of elements in the specified range (optionally with their scores).

func (*Redis) ZrevrangeByLex

func (r *Redis) ZrevrangeByLex(key, max, min string) ([]string, error)

When all the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering, this command returns all the elements in the sorted set at key with a value between max and min.

Apart from the reversed ordering, ZREVRANGEBYLEX is similar to ZRANGEBYLEX.

Return value Array reply: list of elements in the specified score range.

func (*Redis) ZrevrangeByLexBatch

func (r *Redis) ZrevrangeByLexBatch(key, max, min string, offset, count int) ([]string, error)

see ZrevrangeByLex()

func (*Redis) ZrevrangeByScore

func (r *Redis) ZrevrangeByScore(key, max, min string) ([]string, error)

ZrevrangeByScore Returns all the elements in the sorted set at key with a score between max and min (including elements with score equal to max or min). In contrary to the default ordering of sorted sets, for this command the elements are considered to be ordered from high to low scores. The elements having the same score are returned in reverse lexicographical order. Apart from the reversed ordering, ZREVRANGEBYSCORE is similar to ZRANGEBYSCORE.

Return value Array reply: list of elements in the specified score range (optionally with their scores).

func (*Redis) ZrevrangeByScoreWithScores

func (r *Redis) ZrevrangeByScoreWithScores(key, max, min string) ([]Tuple, error)

see ZrevrangeByScore(key, max, min string)

func (*Redis) ZrevrangeByScoreWithScoresBatch

func (r *Redis) ZrevrangeByScoreWithScoresBatch(key, max, min string, offset, count int) ([]Tuple, error)

see Zrevrange()

func (*Redis) ZrevrangeWithScores

func (r *Redis) ZrevrangeWithScores(key string, start, end int64) ([]Tuple, error)

see Zrevrange()

func (*Redis) Zrevrank

func (r *Redis) Zrevrank(key, member string) (int64, error)

Return the rank (or index) or member in the sorted set at key, with scores being ordered from high to low.

When the given member does not exist in the sorted set, the special value 'nil' is returned. The returned rank (or index) of the member is 0-based for both commands.

<b>Time complexity:</b>

O(log(N)) @see #zrank(String, String) param key param member return Integer reply or a nil bulk reply, specifically: the rank of the element as an integer

reply if the element exists. A nil bulk reply if there is no such element.

func (*Redis) Zscan

func (r *Redis) Zscan(key, cursor string, params ...ScanParams) (*ScanResult, error)

Zscan ...

func (*Redis) Zscore

func (r *Redis) Zscore(key, member string) (float64, error)

Return the score of the specified element of the sorted set at key. If the specified element does not exist in the sorted set, or the key does not exist at all, a special 'nil' value is returned.

<b>Time complexity:</b> O(1) param key param member return the score

func (*Redis) Zunionstore

func (r *Redis) Zunionstore(dstkey string, sets ...string) (int64, error)

Creates a union or intersection of N sorted sets given by keys k1 through kN, and stores it at dstkey. It is mandatory to provide the number of input keys N, before passing the input keys and the other (optional) arguments.

As the terms imply, the {@link #zinterstore(String, String...) ZINTERSTORE} command requires an element to be present in each of the given inputs to be inserted in the result. The {@link #zunionstore(String, String...) ZUNIONSTORE} command inserts all elements across all inputs.

Using the WEIGHTS option, it is possible to add weight to each input sorted set. This means that the score of each element in the sorted set is first multiplied by this weight before being passed to the aggregation. When this option is not given, all weights default to 1.

With the AGGREGATE option, it's possible to specify how the results of the union or intersection are aggregated. This option defaults to SUM, where the score of an element is summed across the inputs where it exists. When this option is set to be either MIN or MAX, the resulting set will contain the minimum or maximum score of an element across the inputs where it exists.

<b>Time complexity:</b> O(N) + O(M log(M)) with N being the sum of the sizes of the input sorted sets, and M being the number of elements in the resulting sorted set @see #zunionstore(String, String...) @see #zunionstore(String, ZParams, String...) @see #zinterstore(String, String...) @see #zinterstore(String, ZParams, String...) param dstkey param sets return Integer reply, specifically the number of elements in the sorted set at dstkey

func (*Redis) ZunionstoreWithParams

func (r *Redis) ZunionstoreWithParams(dstkey string, params ZParams, sets ...string) (int64, error)

ZunionstoreWithParams ...

type RedisCluster

type RedisCluster struct {
	MaxAttempts       int
	ConnectionHandler *redisClusterConnectionHandler
}

RedisCluster redis cluster tool

func NewRedisCluster

func NewRedisCluster(option *ClusterOption) *RedisCluster

NewRedisCluster constructor

func (*RedisCluster) Append

func (r *RedisCluster) Append(key, value string) (int64, error)

Append ...

func (*RedisCluster) Bitcount

func (r *RedisCluster) Bitcount(key string) (int64, error)

Bitcount wait complete

func (*RedisCluster) BitcountRange

func (r *RedisCluster) BitcountRange(key string, start int64, end int64) (int64, error)

BitcountRange wait complete

func (*RedisCluster) Bitfield

func (r *RedisCluster) Bitfield(key string, arguments ...string) ([]int64, error)

Bitfield wait complete

func (*RedisCluster) Bitop

func (r *RedisCluster) Bitop(op BitOP, destKey string, srcKeys ...string) (int64, error)

Bitop ...

func (*RedisCluster) Bitpos

func (r *RedisCluster) Bitpos(key string, value bool, params ...BitPosParams) (int64, error)

Bitpos wait complete

func (*RedisCluster) Blpop

func (r *RedisCluster) Blpop(args ...string) ([]string, error)

Blpop wait complete

func (*RedisCluster) BlpopTimout

func (r *RedisCluster) BlpopTimout(timeout int, keys ...string) ([]string, error)

BlpopTimout wait complete

func (*RedisCluster) Brpop

func (r *RedisCluster) Brpop(args ...string) ([]string, error)

Brpop wait complete

func (*RedisCluster) BrpopTimout

func (r *RedisCluster) BrpopTimout(timeout int, keys ...string) ([]string, error)

BrpopTimout wait complete

func (*RedisCluster) Brpoplpush

func (r *RedisCluster) Brpoplpush(source, destination string, timeout int) (string, error)

Brpoplpush ...

func (*RedisCluster) Decr

func (r *RedisCluster) Decr(key string) (int64, error)

Decr ...

func (*RedisCluster) DecrBy

func (r *RedisCluster) DecrBy(key string, decrement int64) (int64, error)

DecrBy ...

func (*RedisCluster) Del

func (r *RedisCluster) Del(keys ...string) (int64, error)

Del delete one or more keys return the number of deleted keys

func (*RedisCluster) Echo

func (r *RedisCluster) Echo(str string) (string, error)

Echo wait complete

func (*RedisCluster) Eval

func (r *RedisCluster) Eval(script string, keyCount int, params ...string) (interface{}, error)

Eval ...

func (*RedisCluster) Evalsha

func (r *RedisCluster) Evalsha(sha1 string, keyCount int, params ...string) (interface{}, error)

Evalsha ...

func (*RedisCluster) Exists

func (r *RedisCluster) Exists(keys ...string) (int64, error)

Exists wait complete

func (*RedisCluster) Expire

func (r *RedisCluster) Expire(key string, seconds int) (int64, error)

Expire ...

func (*RedisCluster) ExpireAt

func (r *RedisCluster) ExpireAt(key string, unixtime int64) (int64, error)

ExpireAt ...

func (*RedisCluster) Geoadd

func (r *RedisCluster) Geoadd(key string, longitude, latitude float64, member string) (int64, error)

Geoadd wait complete

func (*RedisCluster) GeoaddByMap

func (r *RedisCluster) GeoaddByMap(key string, memberCoordinateMap map[string]GeoCoordinate) (int64, error)

GeoaddByMap wait complete

func (*RedisCluster) Geodist

func (r *RedisCluster) Geodist(key string, member1, member2 string, unit ...GeoUnit) (float64, error)

Geodist wait complete

func (*RedisCluster) Geohash

func (r *RedisCluster) Geohash(key string, members ...string) ([]string, error)

Geohash wait complete

func (*RedisCluster) Geopos

func (r *RedisCluster) Geopos(key string, members ...string) ([]*GeoCoordinate, error)

Geopos wait complete

func (*RedisCluster) Georadius

func (r *RedisCluster) Georadius(key string, longitude, latitude, radius float64, unit GeoUnit, param ...GeoRadiusParam) ([]*GeoCoordinate, error)

Georadius wait complete

func (*RedisCluster) GeoradiusByMember

func (r *RedisCluster) GeoradiusByMember(key string, member string, radius float64, unit GeoUnit, param ...GeoRadiusParam) ([]*GeoCoordinate, error)

GeoradiusByMember wait complete

func (*RedisCluster) Get

func (r *RedisCluster) Get(key string) (string, error)

Get ...

func (*RedisCluster) GetSet

func (r *RedisCluster) GetSet(key, value string) (string, error)

GetSet ...

func (*RedisCluster) Getbit

func (r *RedisCluster) Getbit(key string, offset int64) (bool, error)

Getbit ...

func (*RedisCluster) Getrange

func (r *RedisCluster) Getrange(key string, startOffset, endOffset int64) (string, error)

Getrange ...

func (*RedisCluster) Hdel

func (r *RedisCluster) Hdel(key string, fields ...string) (int64, error)

Hdel ...

func (*RedisCluster) Hexists

func (r *RedisCluster) Hexists(key, field string) (bool, error)

Hexists ...

func (*RedisCluster) Hget

func (r *RedisCluster) Hget(key, field string) (string, error)

Hget ...

func (*RedisCluster) HgetAll

func (r *RedisCluster) HgetAll(key string) (map[string]string, error)

HgetAll ...

func (*RedisCluster) HincrBy

func (r *RedisCluster) HincrBy(key, field string, value int64) (int64, error)

HincrBy ...

func (*RedisCluster) HincrByFloat

func (r *RedisCluster) HincrByFloat(key, field string, value float64) (float64, error)

HincrByFloat ...

func (*RedisCluster) Hkeys

func (r *RedisCluster) Hkeys(key string) ([]string, error)

Hkeys ...

func (*RedisCluster) Hlen

func (r *RedisCluster) Hlen(key string) (int64, error)

Hlen ...

func (*RedisCluster) Hmget

func (r *RedisCluster) Hmget(key string, fields ...string) ([]string, error)

Hmget ...

func (*RedisCluster) Hmset

func (r *RedisCluster) Hmset(key string, hash map[string]string) (string, error)

Hmset ...

func (*RedisCluster) Hscan

func (r *RedisCluster) Hscan(key, cursor string, params ...ScanParams) (*ScanResult, error)

Hscan wait complete

func (*RedisCluster) Hset

func (r *RedisCluster) Hset(key, field string, value string) (int64, error)

Hset ...

func (*RedisCluster) Hsetnx

func (r *RedisCluster) Hsetnx(key, field, value string) (int64, error)

Hsetnx ...

func (*RedisCluster) Hvals

func (r *RedisCluster) Hvals(key string) ([]string, error)

Hvals ...

func (*RedisCluster) Incr

func (r *RedisCluster) Incr(key string) (int64, error)

Incr ...

func (*RedisCluster) IncrBy

func (r *RedisCluster) IncrBy(key string, increment int64) (int64, error)

IncrBy ...

func (*RedisCluster) IncrByFloat

func (r *RedisCluster) IncrByFloat(key string, increment float64) (float64, error)

IncrByFloat ...

func (*RedisCluster) Keys

func (r *RedisCluster) Keys(pattern string) ([]string, error)

Deprecated do not use

func (*RedisCluster) Lindex

func (r *RedisCluster) Lindex(key string, index int64) (string, error)

Lindex ...

func (*RedisCluster) Linsert

func (r *RedisCluster) Linsert(key string, where ListOption, pivot, value string) (int64, error)

Linsert wait complete

func (*RedisCluster) Llen

func (r *RedisCluster) Llen(key string) (int64, error)

Llen ...

func (*RedisCluster) Lpop

func (r *RedisCluster) Lpop(key string) (string, error)

Lpop ...

func (*RedisCluster) Lpush

func (r *RedisCluster) Lpush(key string, strings ...string) (int64, error)

Lpush ...

func (*RedisCluster) Lpushx

func (r *RedisCluster) Lpushx(key string, strs ...string) (int64, error)

Lpushx wait complete

func (*RedisCluster) Lrange

func (r *RedisCluster) Lrange(key string, start, stop int64) ([]string, error)

Lrange ...

func (*RedisCluster) Lrem

func (r *RedisCluster) Lrem(key string, count int64, value string) (int64, error)

Lrem ...

func (*RedisCluster) Lset

func (r *RedisCluster) Lset(key string, index int64, value string) (string, error)

Lset ...

func (*RedisCluster) Ltrim

func (r *RedisCluster) Ltrim(key string, start, stop int64) (string, error)

Ltrim ...

func (*RedisCluster) Mget

func (r *RedisCluster) Mget(keys ...string) ([]string, error)

Mget wait complete

func (*RedisCluster) Move

func (r *RedisCluster) Move(key string, dbIndex int) (int64, error)

Deprecated

func (*RedisCluster) Mset

func (r *RedisCluster) Mset(keysvalues ...string) (string, error)

Mset wait complete

func (*RedisCluster) Msetnx

func (r *RedisCluster) Msetnx(keysvalues ...string) (int64, error)

Msetnx wait complete

func (*RedisCluster) Persist

func (r *RedisCluster) Persist(key string) (int64, error)

Persist ...

func (*RedisCluster) Pexpire

func (r *RedisCluster) Pexpire(key string, milliseconds int64) (int64, error)

Pexpire ...

func (*RedisCluster) PexpireAt

func (r *RedisCluster) PexpireAt(key string, millisecondsTimestamp int64) (int64, error)

PexpireAt ...

func (*RedisCluster) Pfadd

func (r *RedisCluster) Pfadd(key string, elements ...string) (int64, error)

Pfadd wait complete

func (*RedisCluster) Pfcount

func (r *RedisCluster) Pfcount(keys ...string) (int64, error)

Pfcount ...

func (*RedisCluster) Pfmerge

func (r *RedisCluster) Pfmerge(destkey string, sourcekeys ...string) (string, error)

Pfmerge ...

func (*RedisCluster) Psetex

func (r *RedisCluster) Psetex(key string, milliseconds int64, value string) (string, error)

Psetex ...

func (*RedisCluster) Psubscribe

func (r *RedisCluster) Psubscribe(redisPubSub *RedisPubSub, patterns ...string) error

Psubscribe ...

func (*RedisCluster) Pttl

func (r *RedisCluster) Pttl(key string) (int64, error)

Pttl ...

func (*RedisCluster) Publish

func (r *RedisCluster) Publish(channel, message string) (int64, error)

Publish ...

func (*RedisCluster) RandomKey

func (r *RedisCluster) RandomKey() (string, error)

Deprecated do not use

func (*RedisCluster) Rename

func (r *RedisCluster) Rename(oldkey, newkey string) (string, error)

Rename wait complete

func (*RedisCluster) Renamenx

func (r *RedisCluster) Renamenx(oldkey, newkey string) (int64, error)

Renamenx wait complete

func (*RedisCluster) Rpop

func (r *RedisCluster) Rpop(key string) (string, error)

Rpop ...

func (*RedisCluster) Rpoplpush

func (r *RedisCluster) Rpoplpush(srckey, dstkey string) (string, error)

Rpoplpush wait complete

func (*RedisCluster) Rpush

func (r *RedisCluster) Rpush(key string, strings ...string) (int64, error)

Rpush ...

func (*RedisCluster) Rpushx

func (r *RedisCluster) Rpushx(key string, strs ...string) (int64, error)

Rpushx wait complete

func (*RedisCluster) Sadd

func (r *RedisCluster) Sadd(key string, members ...string) (int64, error)

Sadd ...

func (*RedisCluster) Scan

func (r *RedisCluster) Scan(cursor string, params ...ScanParams) (*ScanResult, error)

Scan ...

func (*RedisCluster) Scard

func (r *RedisCluster) Scard(key string) (int64, error)

Scard wait complete

func (*RedisCluster) ScriptExists

func (r *RedisCluster) ScriptExists(key string, sha1 ...string) ([]bool, error)

ScriptExists ...

func (*RedisCluster) ScriptLoad

func (r *RedisCluster) ScriptLoad(key, script string) (string, error)

ScriptLoad ...

func (*RedisCluster) Sdiff

func (r *RedisCluster) Sdiff(keys ...string) ([]string, error)

Sdiff wait complete

func (*RedisCluster) Sdiffstore

func (r *RedisCluster) Sdiffstore(dstkey string, keys ...string) (int64, error)

Sdiffstore wait complete

func (*RedisCluster) Set

func (r *RedisCluster) Set(key, value string) (string, error)

Set ...

func (*RedisCluster) SetWithParams

func (r *RedisCluster) SetWithParams(key, value, nxxx string) (string, error)

SetWithParams ...

func (*RedisCluster) SetWithParamsAndTime

func (r *RedisCluster) SetWithParamsAndTime(key, value, nxxx, expx string, time int64) (string, error)

SetWithParamsAndTime ...

func (*RedisCluster) Setbit

func (r *RedisCluster) Setbit(key string, offset int64, value string) (bool, error)

Setbit ...

func (*RedisCluster) SetbitWithBool

func (r *RedisCluster) SetbitWithBool(key string, offset int64, value bool) (bool, error)

SetbitWithBool ...

func (*RedisCluster) Setex

func (r *RedisCluster) Setex(key string, seconds int, value string) (string, error)

Setex ...

func (*RedisCluster) Setnx

func (r *RedisCluster) Setnx(key, value string) (int64, error)

Setnx ...

func (*RedisCluster) Setrange

func (r *RedisCluster) Setrange(key string, offset int64, value string) (int64, error)

Setrange ...

func (*RedisCluster) Sinter

func (r *RedisCluster) Sinter(keys ...string) ([]string, error)

Sinter wait complete

func (*RedisCluster) Sinterstore

func (r *RedisCluster) Sinterstore(dstkey string, keys ...string) (int64, error)

Sinterstore wait complete

func (*RedisCluster) Sismember

func (r *RedisCluster) Sismember(key string, member string) (bool, error)

Sismember wait complete

func (*RedisCluster) Smembers

func (r *RedisCluster) Smembers(key string) ([]string, error)

Smembers ...

func (*RedisCluster) Smove

func (r *RedisCluster) Smove(srckey, dstkey, member string) (int64, error)

Smove wait complete

func (*RedisCluster) Sort

func (r *RedisCluster) Sort(key string, sortingParameters ...SortingParams) ([]string, error)

Sort wait complete

func (*RedisCluster) SortMulti

func (r *RedisCluster) SortMulti(key, dstkey string, sortingParameters ...SortingParams) (int64, error)

SortMulti wait complete

func (*RedisCluster) Spop

func (r *RedisCluster) Spop(key string) (string, error)

Spop ...

func (*RedisCluster) SpopBatch

func (r *RedisCluster) SpopBatch(key string, count int64) ([]string, error)

SpopBatch wait complete

func (*RedisCluster) Srandmember

func (r *RedisCluster) Srandmember(key string) (string, error)

Srandmember wait complete

func (*RedisCluster) SrandmemberBatch

func (r *RedisCluster) SrandmemberBatch(key string, count int) ([]string, error)

SrandmemberBatch wait complete

func (*RedisCluster) Srem

func (r *RedisCluster) Srem(key string, members ...string) (int64, error)

Srem ...

func (*RedisCluster) Sscan

func (r *RedisCluster) Sscan(key, cursor string, params ...ScanParams) (*ScanResult, error)

Sscan wait complete

func (*RedisCluster) Strlen

func (r *RedisCluster) Strlen(key string) (int64, error)

Strlen wait complete

func (*RedisCluster) Subscribe

func (r *RedisCluster) Subscribe(redisPubSub *RedisPubSub, channels ...string) error

Subscribe ...

func (*RedisCluster) Substr

func (r *RedisCluster) Substr(key string, start, end int) (string, error)

Substr ...

func (*RedisCluster) Sunion

func (r *RedisCluster) Sunion(keys ...string) ([]string, error)

Sunion wait complete

func (*RedisCluster) Sunionstore

func (r *RedisCluster) Sunionstore(dstkey string, keys ...string) (int64, error)

Sunionstore wait complete

func (*RedisCluster) Ttl

func (r *RedisCluster) Ttl(key string) (int64, error)

Ttl ...

func (*RedisCluster) Type

func (r *RedisCluster) Type(key string) (string, error)

Type ...

func (*RedisCluster) Unwatch

func (r *RedisCluster) Unwatch() (string, error)

Deprecated do not use

func (*RedisCluster) Watch

func (r *RedisCluster) Watch(keys ...string) (string, error)

Deprecated do not use

func (*RedisCluster) Zadd

func (r *RedisCluster) Zadd(key string, score float64, member string, params ...ZAddParams) (int64, error)

Zadd wait complete

func (*RedisCluster) ZaddByMap

func (r *RedisCluster) ZaddByMap(key string, scoreMembers map[string]float64, params ...ZAddParams) (int64, error)

ZaddByMap wait complete

func (*RedisCluster) Zcard

func (r *RedisCluster) Zcard(key string) (int64, error)

Zcard wait complete

func (*RedisCluster) Zcount

func (r *RedisCluster) Zcount(key string, min string, max string) (int64, error)

Zcount wait complete

func (*RedisCluster) Zincrby

func (r *RedisCluster) Zincrby(key string, score float64, member string, params ...ZAddParams) (float64, error)

Zincrby wait complete

func (*RedisCluster) Zinterstore

func (r *RedisCluster) Zinterstore(dstkey string, sets ...string) (int64, error)

Zinterstore wait complete

func (*RedisCluster) ZinterstoreWithParams

func (r *RedisCluster) ZinterstoreWithParams(dstkey string, params ZParams, sets ...string) (int64, error)

ZinterstoreWithParams ...

func (*RedisCluster) Zlexcount

func (r *RedisCluster) Zlexcount(key, min, max string) (int64, error)

Zlexcount wait complete

func (*RedisCluster) Zrange

func (r *RedisCluster) Zrange(key string, start, end int64) ([]string, error)

Zrange wait complete

func (*RedisCluster) ZrangeByLex

func (r *RedisCluster) ZrangeByLex(key, min, max string) ([]string, error)

ZrangeByLex wait complete

func (*RedisCluster) ZrangeByLexBatch

func (r *RedisCluster) ZrangeByLexBatch(key, min, max string, offset, count int) ([]string, error)

ZrangeByLexBatch wait complete

func (*RedisCluster) ZrangeByScore

func (r *RedisCluster) ZrangeByScore(key string, min string, max string) ([]string, error)

ZrangeByScore wait complete

func (*RedisCluster) ZrangeByScoreBatch

func (r *RedisCluster) ZrangeByScoreBatch(key string, min string, max string, offset int, count int) ([]string, error)

ZrangeByScoreBatch wait complete

func (*RedisCluster) ZrangeByScoreWithScores

func (r *RedisCluster) ZrangeByScoreWithScores(key, min, max string) ([]Tuple, error)

ZrangeByScoreWithScores wait complete

func (*RedisCluster) ZrangeByScoreWithScoresBatch

func (r *RedisCluster) ZrangeByScoreWithScoresBatch(key, min, max string, offset, count int) ([]Tuple, error)

ZrangeByScoreWithScoresBatch wait complete

func (*RedisCluster) ZrangeWithScores

func (r *RedisCluster) ZrangeWithScores(key string, start, end int64) ([]Tuple, error)

ZrangeWithScores wait complete

func (*RedisCluster) Zrank

func (r *RedisCluster) Zrank(key, member string) (int64, error)

Zrank wait complete

func (*RedisCluster) Zrem

func (r *RedisCluster) Zrem(key string, member ...string) (int64, error)

Zrem wait complete

func (*RedisCluster) ZremrangeByLex

func (r *RedisCluster) ZremrangeByLex(key, min, max string) (int64, error)

ZremrangeByLex wait complete

func (*RedisCluster) ZremrangeByRank

func (r *RedisCluster) ZremrangeByRank(key string, start, end int64) (int64, error)

ZremrangeByRank wait complete

func (*RedisCluster) ZremrangeByScore

func (r *RedisCluster) ZremrangeByScore(key, start, end string) (int64, error)

ZremrangeByScore wait complete

func (*RedisCluster) Zrevrange

func (r *RedisCluster) Zrevrange(key string, start, end int64) ([]string, error)

Zrevrange wait complete

func (*RedisCluster) ZrevrangeByLex

func (r *RedisCluster) ZrevrangeByLex(key, max, min string) ([]string, error)

ZrevrangeByLex wait complete

func (*RedisCluster) ZrevrangeByLexBatch

func (r *RedisCluster) ZrevrangeByLexBatch(key, max, min string, offset, count int) ([]string, error)

ZrevrangeByLexBatch wait complete

func (*RedisCluster) ZrevrangeByScore

func (r *RedisCluster) ZrevrangeByScore(key string, max string, min string) ([]string, error)

ZrevrangeByScore wait complete

func (*RedisCluster) ZrevrangeByScoreWithScores

func (r *RedisCluster) ZrevrangeByScoreWithScores(key, max, min string) ([]Tuple, error)

ZrevrangeByScoreWithScores wait complete

func (*RedisCluster) ZrevrangeByScoreWithScoresBatch

func (r *RedisCluster) ZrevrangeByScoreWithScoresBatch(key, max, min string, offset, count int) ([]Tuple, error)

ZrevrangeByScoreWithScoresBatch wait complete

func (*RedisCluster) ZrevrangeWithScores

func (r *RedisCluster) ZrevrangeWithScores(key string, start, end int64) ([]Tuple, error)

ZrevrangeWithScores wait complete

func (*RedisCluster) Zrevrank

func (r *RedisCluster) Zrevrank(key, member string) (int64, error)

Zrevrank wait complete

func (*RedisCluster) Zscan

func (r *RedisCluster) Zscan(key, cursor string, params ...ScanParams) (*ScanResult, error)

Zscan wait complete

func (*RedisCluster) Zscore

func (r *RedisCluster) Zscore(key, member string) (float64, error)

Zscore wait complete

func (*RedisCluster) Zunionstore

func (r *RedisCluster) Zunionstore(dstkey string, sets ...string) (int64, error)

Zunionstore ...

func (*RedisCluster) ZunionstoreWithParams

func (r *RedisCluster) ZunionstoreWithParams(dstkey string, params ZParams, sets ...string) (int64, error)

ZunionstoreWithParams ...

type RedisError

type RedisError struct {
	Message string
}

RedisError basic redis error

func NewRedisError

func NewRedisError(message string) *RedisError

func (*RedisError) Error

func (e *RedisError) Error() string

type RedisPubSub

type RedisPubSub struct {
	OnMessage      func(channel, message string)
	OnPMessage     func(pattern string, channel, message string)
	OnSubscribe    func(channel string, subscribedChannels int)
	OnUnsubscribe  func(channel string, subscribedChannels int)
	OnPUnsubscribe func(pattern string, subscribedChannels int)
	OnPSubscribe   func(pattern string, subscribedChannels int)
	OnPong         func(channel string)
	// contains filtered or unexported fields
}

RedisPubSub ...

func (*RedisPubSub) Psubscribe

func (r *RedisPubSub) Psubscribe(channels ...string) error

Psubscribe ...

func (*RedisPubSub) Punsubscribe

func (r *RedisPubSub) Punsubscribe(channels ...string) error

Punsubscribe ...

func (*RedisPubSub) Subscribe

func (r *RedisPubSub) Subscribe(channels ...string) error

Subscribe ...

func (*RedisPubSub) Unsubscribe

func (r *RedisPubSub) Unsubscribe(channels ...string) error

Unsubscribe ...

type Reset

type Reset struct {
	//name  ...
	Name string
}

Reset ...

func NewReset

func NewReset(name string) Reset

NewReset ...

func (Reset) GetRaw

func (g Reset) GetRaw() []byte

GetRaw ...

type ScanParams

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

ScanParams

func NewScanParams

func NewScanParams() *ScanParams

NewScanParams ...

func (ScanParams) Count

func (s ScanParams) Count() int

Count ...

func (ScanParams) GetParams

func (s ScanParams) GetParams() [][]byte

GetParams ...

func (ScanParams) Match

func (s ScanParams) Match() string

Match ...

type ScanResult

type ScanResult struct {
	Cursor  string
	Results []string
}

ScanResult ...

func ObjectArrToScanResultReply

func ObjectArrToScanResultReply(reply []interface{}, err error) (*ScanResult, error)

ObjectArrToScanResultReply ...

func ToScanResultReply

func ToScanResultReply(reply interface{}, err error) (*ScanResult, error)

ToScanResultReply ...

type Slowlog

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

Slowlog ...

type SortingParams

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

SortingParams

type Tuple

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

Tuple ...

func StringArrToTupleReply

func StringArrToTupleReply(reply []string, err error) ([]Tuple, error)

StringArrToTupleReply ...

func ToTupleArrayReply

func ToTupleArrayReply(reply interface{}, err error) ([]Tuple, error)

ToTupleArrayReply ...

type ZAddParams

type ZAddParams struct {
	XX bool
	NX bool
	CH bool
	// contains filtered or unexported fields
}

ZAddParams ...

func (ZAddParams) Contains

func (p ZAddParams) Contains(key string) bool

Contains ...

func (ZAddParams) GetByteParams

func (p ZAddParams) GetByteParams(key []byte, args ...[]byte) [][]byte

GetByteParams ...

type ZParams

type ZParams struct {
	//name  ...
	Name string
	// contains filtered or unexported fields
}

ZParams ...

func NewZParams

func NewZParams(name string) ZParams

NewZParams ...

func (ZParams) GetParams

func (g ZParams) GetParams() [][]byte

GetParams ...

func (ZParams) GetRaw

func (g ZParams) GetRaw() []byte

GetRaw ...