godis

package module

Go to main page

Versions in this module

v0

v0.0.18

May 12, 2020

v0.0.17

Aug 16, 2019

v0.0.16

Jul 17, 2019

v0.0.15

Jul 17, 2019

v0.0.14

Jul 17, 2019

v0.0.13

Jul 16, 2019

v0.0.12

Jul 16, 2019

v0.0.11

Jul 3, 2019

Changes in this version

+ var AggregateMax = newAggregate("MAX")

+ var AggregateMin = newAggregate("MIN")

+ var AggregateSum = newAggregate("SUM")

+ var BitOpAnd = newBitOP("AND")

+ var BitOpNot = newBitOP("NOT")

+ var BitOpOr = newBitOP("OR")

+ var BitOpXor = newBitOP("XOR")

+ var ErrLockTimeOut = errors.New("get lock timeout")

+ var GeoUnitFt = newGeoUnit("ft")

+ var GeoUnitKm = newGeoUnit("km")

+ var GeoUnitM = newGeoUnit("m")

+ var GeoUnitMi = newGeoUnit("mi")

+ var ListOptionAfter = newListOption("AFTER")

+ var ListOptionBefore = newListOption("BEFORE")

+ var StrArrBuilder = newStringArrayBuilder()

+ var StrBuilder = newStrBuilder()

+ func BoolToByteArr(a bool) []byte

+ func ByteArrToFloat64(bytes []byte) float64

+ func ByteArrToStrReply(reply []byte, err error) (string, error)

+ func Float64ToByteArr(a float64) []byte

+ func Float64ToStr(a float64) string

+ func Int64ToByteArr(a int64) []byte

+ func IntToByteArr(a int) []byte

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

+ func ObjToEvalResult(reply interface{}, err error) (interface{}, error)

+ func StrArrToByteArrArr(arr []string) [][]byte

+ func StrArrToMapReply(reply []string, err error) (map[string]string, error)

+ func StrStrArrToByteArrArr(str string, arr []string) [][]byte

+ func StrStrArrToStrArr(str string, arr []string) []string

+ func StrToFloat64Reply(reply string, err error) (float64, error)

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

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

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

+ func ToStrReply(reply interface{}, err error) (string, error)

+ type Aggregate struct

+ type ClusterLocker struct

+ func (l *ClusterLocker) TryLock(key string) (*Lock, error)

+ func (l *ClusterLocker) UnLock(lock *Lock) error

type GeoCoordinate

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

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

+ type GeoRadiusParams struct

+ func (p *GeoRadiusParams) Contains(key string) bool

+ func (p *GeoRadiusParams) Count(count int) *GeoRadiusParams

+ func (p *GeoRadiusParams) SortAscending() *GeoRadiusParams

+ func (p *GeoRadiusParams) SortDescending() *GeoRadiusParams

+ func (p *GeoRadiusParams) WithCoord() *GeoRadiusParams

+ func (p *GeoRadiusParams) WithDist() *GeoRadiusParams

type GeoRadiusResponse

+ func ObjArrToGeoRadiusResponseReply(reply []interface{}, err error) ([]GeoRadiusResponse, error)

+ func ToGeoRespArrReply(reply interface{}, err error) ([]GeoRadiusResponse, error)

+ type Lock struct

type Pipeline

+ func (p Pipeline) BLPop(args ...string) (*Response, error)

+ func (p Pipeline) BLPopTimeout(timeout int, keys ...string) (*Response, error)

+ func (p Pipeline) BRPop(args ...string) (*Response, error)

+ func (p Pipeline) BRPopLPush(source, destination string, timeout int) (*Response, error)

+ func (p Pipeline) BRPopTimeout(timeout int, keys ...string) (*Response, error)

+ func (p Pipeline) BgRewriteAof() (*Response, error)

+ func (p Pipeline) BgSave() (*Response, error)

+ func (p Pipeline) BitOp(op BitOP, destKey string, srcKeys ...string) (*Response, error)

+ func (p Pipeline) ClusterAddSlots(slots ...int) (*Response, error)

+ func (p Pipeline) ClusterDelSlots(slots ...int) (*Response, error)

+ func (p Pipeline) ClusterGetKeysInSlot(slot int, count int) (*Response, error)

+ func (p Pipeline) ClusterInfo() (*Response, error)

+ func (p Pipeline) ClusterMeet(ip string, port int) (*Response, error)

+ func (p Pipeline) ClusterNodes() (*Response, error)

+ func (p Pipeline) ClusterSetSlotImporting(slot int, nodeID string) (*Response, error)

+ func (p Pipeline) ClusterSetSlotMigrating(slot int, nodeID string) (*Response, error)

+ func (p Pipeline) ClusterSetSlotNode(slot int, nodeID string) (*Response, error)

+ func (p Pipeline) ConfigGet(pattern string) (*Response, error)

+ func (p Pipeline) ConfigResetStat() (*Response, error)

+ func (p Pipeline) ConfigSet(parameter, value string) (*Response, error)

+ func (p Pipeline) DbSize() (*Response, error)

+ func (p Pipeline) Del(keys ...string) (*Response, error)

+ func (p Pipeline) Eval(script string, keyCount int, params ...string) (*Response, error)

+ func (p Pipeline) EvalSha(sha1 string, keyCount int, params ...string) (*Response, error)

+ func (p Pipeline) Exists(keys ...string) (*Response, error)

+ func (p Pipeline) FlushAll() (*Response, error)

+ func (p Pipeline) FlushDB() (*Response, error)

+ func (p Pipeline) Info() (*Response, error)

+ func (p Pipeline) Keys(pattern string) (*Response, error)

+ func (p Pipeline) LastSave() (*Response, error)

+ func (p Pipeline) MGet(keys ...string) (*Response, error)

+ func (p Pipeline) MSet(kvs ...string) (*Response, error)

+ func (p Pipeline) MSetNx(kvs ...string) (*Response, error)

+ func (p Pipeline) PfCount(keys ...string) (*Response, error)

+ func (p Pipeline) PfMerge(destKey string, srcKeys ...string) (*Response, error)

+ func (p Pipeline) Ping() (*Response, error)

+ func (p Pipeline) Publish(channel, message string) (*Response, error)

+ func (p Pipeline) RPopLPush(srcKey, destKey string) (*Response, error)

+ func (p Pipeline) RandomKey() (*Response, error)

+ func (p Pipeline) Rename(oldkey, newkey string) (*Response, error)

+ func (p Pipeline) RenameNx(oldkey, newkey string) (*Response, error)

+ func (p Pipeline) SDiff(keys ...string) (*Response, error)

+ func (p Pipeline) SDiffStore(destKey string, keys ...string) (*Response, error)

+ func (p Pipeline) SInter(keys ...string) (*Response, error)

+ func (p Pipeline) SInterStore(destKey string, keys ...string) (*Response, error)

+ func (p Pipeline) SMove(srcKey, destKey, member string) (*Response, error)

+ func (p Pipeline) SUnion(keys ...string) (*Response, error)

+ func (p Pipeline) SUnionStore(destKey string, keys ...string) (*Response, error)

+ func (p Pipeline) Save() (*Response, error)

+ func (p Pipeline) Select(index int) (*Response, error)

+ func (p Pipeline) Shutdown() (*Response, error)

+ func (p Pipeline) SortStore(key string, destKey string, params ...*SortParams) (*Response, error)

+ func (p Pipeline) Time() (*Response, error)

+ func (p Pipeline) Watch(keys ...string) (*Response, error)

+ func (p Pipeline) ZInterStore(destKey string, sets ...string) (*Response, error)

+ func (p Pipeline) ZInterStoreWithParams(destKey string, params *ZParams, sets ...string) (*Response, error)

+ func (p Pipeline) ZUnionStore(destKey string, sets ...string) (*Response, error)

+ func (p Pipeline) ZUnionStoreWithParams(destKey string, params *ZParams, sets ...string) (*Response, error)

type PoolConfig

+ BlockWhenExhausted bool

+ EvictionPolicyName string

+ LIFO bool

+ NumTestsPerEvictionRun int

+ SoftMinEvictableIdleTime time.Duration

+ TestOnCreate bool

+ TestOnReturn bool

+ TestWhileIdle bool

+ TimeBetweenEvictionRuns time.Duration

type Redis

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

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

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

+ func (r *Redis) BRPopLPush(srcKey, destKey string, timeout int) (string, error)

+ func (r *Redis) BRPopTimeout(timeout int, keys ...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) ClusterFailOver() (string, error)

+ func (r *Redis) EvalSha(sha1 string, keyCount int, params ...string) (interface{}, 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, ...) ([]GeoRadiusResponse, error)

+ func (r *Redis) GeoRadiusByMember(key, member string, radius float64, unit *GeoUnit, param ...*GeoRadiusParams) ([]GeoRadiusResponse, error)

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

+ func (r *Redis) GetRange(key string, start, end 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, increment 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) 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, members ...string) (int64, error)

+ func (r *Redis) LPushX(key string, members ...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) LastSave() (int64, error)

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

+ func (r *Redis) MSet(kvs ...string) (string, error)

+ func (r *Redis) MSetNx(kvs ...string) (int64, error)

+ func (r *Redis) ObjectIdleTime(str string) (int64, error)

+ func (r *Redis) ObjectRefCount(str 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) 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) PfAdd(key string, elements ...string) (int64, error)

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

+ func (r *Redis) PfMerge(destKey string, srcKeys ...string) (string, error)

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

+ func (r *Redis) RPop(key string) (string, error)

+ func (r *Redis) RPopLPush(srcKey, destKey string) (string, error)

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

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

+ func (r *Redis) RenameNx(oldKey, newKey string) (int64, error)

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

+ func (r *Redis) SCard(key string) (int64, error)

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

+ func (r *Redis) SDiffStore(destKey string, srcKeys ...string) (int64, error)

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

+ func (r *Redis) SInterStore(destKey string, srcKeys ...string) (int64, error)

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

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

+ func (r *Redis) SMove(srcKey, destKey, member string) (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) SUnion(keys ...string) ([]string, error)

+ func (r *Redis) SUnionStore(destKey string, srcKeys ...string) (int64, error)

+ func (r *Redis) SentinelFailOver(masterName string) (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) 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) StrLen(key string) (int64, error)

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

+ func (r *Redis) TTL(key string) (int64, error)

+ func (r *Redis) ZAdd(key string, score float64, member string, params ...*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 string, min, max float64) (int64, error)

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

+ func (r *Redis) ZInterStore(destKey string, srcKeys ...string) (int64, error)

+ func (r *Redis) ZInterStoreWithParams(destKey string, params *ZParams, srcKeys ...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 string, min, max float64) ([]string, error)

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

+ func (r *Redis) ZRangeByScoreWithScores(key string, min, max float64) ([]Tuple, error)

+ func (r *Redis) ZRangeByScoreWithScoresBatch(key string, min, max float64, 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 string, min, max float64) (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 string, max, min float64) ([]string, error)

+ func (r *Redis) ZRevRangeByScoreWithScores(key string, max, min float64) ([]Tuple, error)

+ func (r *Redis) ZRevRangeByScoreWithScoresBatch(key string, max, min float64, 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(destKey string, srcKeys ...string) (int64, error)

+ func (r *Redis) ZUnionStoreWithParams(destKey string, params *ZParams, srcKeys ...string) (int64, error)

type RedisCluster

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

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

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

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

+ func (r *RedisCluster) BRPopTimeout(timeout int, keys ...string) ([]string, 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) EvalSha(sha1 string, keyCount int, params ...string) (interface{}, 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, ...) ([]GeoRadiusResponse, error)

+ func (r *RedisCluster) GeoRadiusByMember(key string, member string, radius float64, unit *GeoUnit, ...) ([]GeoRadiusResponse, 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) 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) MSet(kvs ...string) (string, error)

+ func (r *RedisCluster) MSetNx(kvs ...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) 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) 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) RPop(key string) (string, error)

+ func (r *RedisCluster) RPopLPush(srcKey, destKey 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) RenameNx(oldKey, newKey string) (int64, error)

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

+ func (r *RedisCluster) SCard(key string) (int64, error)

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

+ func (r *RedisCluster) SDiffStore(destKey string, keys ...string) (int64, error)

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

+ func (r *RedisCluster) SInterStore(destKey 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, destKey, member string) (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) SUnion(keys ...string) ([]string, error)

+ func (r *RedisCluster) SUnionStore(destKey string, keys ...string) (int64, 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) StrLen(key string) (int64, error)

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

+ func (r *RedisCluster) TTL(key string) (int64, 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, max float64) (int64, error)

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

+ func (r *RedisCluster) ZInterStore(destKey string, sets ...string) (int64, error)

+ func (r *RedisCluster) ZInterStoreWithParams(destKey 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, max float64) ([]string, error)

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

+ func (r *RedisCluster) ZRangeByScoreWithScores(key string, min, max float64) ([]Tuple, error)

+ func (r *RedisCluster) ZRangeByScoreWithScoresBatch(key string, min, max float64, 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 string, min, max float64) (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, min float64) ([]string, error)

+ func (r *RedisCluster) ZRevRangeByScoreWithScores(key string, max, min float64) ([]Tuple, error)

+ func (r *RedisCluster) ZRevRangeByScoreWithScoresBatch(key string, max, min float64, 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(destKey string, sets ...string) (int64, error)

+ func (r *RedisCluster) ZUnionStoreWithParams(destKey string, params *ZParams, sets ...string) (int64, error)

type RedisPubSub

+ OnPUnSubscribe func(pattern string, subscribedChannels int)

+ OnUnSubscribe func(channel string, subscribedChannels int)

+ func (r *RedisPubSub) PSubscribe(channels ...string) error

+ func (r *RedisPubSub) PUnSubscribe(channels ...string) error

+ func (r *RedisPubSub) UnSubscribe(channels ...string) error

type ScanParams

+ func (s ScanParams) GetMatch() string

type ScanResult

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

+ type SlowLog struct

+ type SortParams struct

+ func NewSortParams() *SortParams

+ func (p *SortParams) Alpha() *SortParams

+ func (p *SortParams) Asc() *SortParams

+ func (p *SortParams) By(pattern string) *SortParams

+ func (p *SortParams) Desc() *SortParams

+ func (p *SortParams) Get(patterns ...string) *SortParams

+ func (p *SortParams) Limit(start, count int) *SortParams

+ func (p *SortParams) NoSort() *SortParams

type Transaction

+ func (p Transaction) BLPop(args ...string) (*Response, error)

+ func (p Transaction) BLPopTimeout(timeout int, keys ...string) (*Response, error)

+ func (p Transaction) BRPop(args ...string) (*Response, error)

+ func (p Transaction) BRPopLPush(source, destination string, timeout int) (*Response, error)

+ func (p Transaction) BRPopTimeout(timeout int, keys ...string) (*Response, error)

+ func (p Transaction) BgRewriteAof() (*Response, error)

+ func (p Transaction) BgSave() (*Response, error)

+ func (p Transaction) BitOp(op BitOP, destKey string, srcKeys ...string) (*Response, error)

+ func (p Transaction) ClusterAddSlots(slots ...int) (*Response, error)

+ func (p Transaction) ClusterDelSlots(slots ...int) (*Response, error)

+ func (p Transaction) ClusterGetKeysInSlot(slot int, count int) (*Response, error)

+ func (p Transaction) ClusterInfo() (*Response, error)

+ func (p Transaction) ClusterMeet(ip string, port int) (*Response, error)

+ func (p Transaction) ClusterNodes() (*Response, error)

+ func (p Transaction) ClusterSetSlotImporting(slot int, nodeID string) (*Response, error)

+ func (p Transaction) ClusterSetSlotMigrating(slot int, nodeID string) (*Response, error)

+ func (p Transaction) ClusterSetSlotNode(slot int, nodeID string) (*Response, error)

+ func (p Transaction) ConfigGet(pattern string) (*Response, error)

+ func (p Transaction) ConfigResetStat() (*Response, error)

+ func (p Transaction) ConfigSet(parameter, value string) (*Response, error)

+ func (p Transaction) DbSize() (*Response, error)

+ func (p Transaction) Del(keys ...string) (*Response, error)

+ func (p Transaction) Eval(script string, keyCount int, params ...string) (*Response, error)

+ func (p Transaction) EvalSha(sha1 string, keyCount int, params ...string) (*Response, error)

+ func (p Transaction) Exists(keys ...string) (*Response, error)

+ func (p Transaction) FlushAll() (*Response, error)

+ func (p Transaction) FlushDB() (*Response, error)

+ func (p Transaction) Info() (*Response, error)

+ func (p Transaction) Keys(pattern string) (*Response, error)

+ func (p Transaction) LastSave() (*Response, error)

+ func (p Transaction) MGet(keys ...string) (*Response, error)

+ func (p Transaction) MSet(kvs ...string) (*Response, error)

+ func (p Transaction) MSetNx(kvs ...string) (*Response, error)

+ func (p Transaction) PfCount(keys ...string) (*Response, error)

+ func (p Transaction) PfMerge(destKey string, srcKeys ...string) (*Response, error)

+ func (p Transaction) Ping() (*Response, error)

+ func (p Transaction) Publish(channel, message string) (*Response, error)

+ func (p Transaction) RPopLPush(srcKey, destKey string) (*Response, error)

+ func (p Transaction) RandomKey() (*Response, error)

+ func (p Transaction) Rename(oldkey, newkey string) (*Response, error)

+ func (p Transaction) RenameNx(oldkey, newkey string) (*Response, error)

+ func (p Transaction) SDiff(keys ...string) (*Response, error)

+ func (p Transaction) SDiffStore(destKey string, keys ...string) (*Response, error)

+ func (p Transaction) SInter(keys ...string) (*Response, error)

+ func (p Transaction) SInterStore(destKey string, keys ...string) (*Response, error)

+ func (p Transaction) SMove(srcKey, destKey, member string) (*Response, error)

+ func (p Transaction) SUnion(keys ...string) (*Response, error)

+ func (p Transaction) SUnionStore(destKey string, keys ...string) (*Response, error)

+ func (p Transaction) Save() (*Response, error)

+ func (p Transaction) Select(index int) (*Response, error)

+ func (p Transaction) Shutdown() (*Response, error)

+ func (p Transaction) SortStore(key string, destKey string, params ...*SortParams) (*Response, error)

+ func (p Transaction) Time() (*Response, error)

+ func (p Transaction) Watch(keys ...string) (*Response, error)

+ func (p Transaction) ZInterStore(destKey string, sets ...string) (*Response, error)

+ func (p Transaction) ZInterStoreWithParams(destKey string, params *ZParams, sets ...string) (*Response, error)

+ func (p Transaction) ZUnionStore(destKey string, sets ...string) (*Response, error)

+ func (p Transaction) ZUnionStoreWithParams(destKey string, params *ZParams, sets ...string) (*Response, error)

type Tuple

+ func StrArrToTupleReply(reply []string, err error) ([]Tuple, error)

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

type ZParams

+ func (g *ZParams) Aggregate(aggregate *Aggregate) *ZParams

+ func (g *ZParams) WeightsByDouble(weights ...float64) *ZParams

v0.0.10

Jun 30, 2019

Changes in this version

type Redis

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

type RedisCluster

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

type SortingParams

+ func NewSortingParams() *SortingParams

+ func (p *SortingParams) Alpha() *SortingParams

+ func (p *SortingParams) Asc() *SortingParams

+ func (p *SortingParams) By(pattern string) *SortingParams

+ func (p *SortingParams) Desc() *SortingParams

+ func (p *SortingParams) Get(patterns ...string) *SortingParams

+ func (p *SortingParams) GetParams() [][]byte

+ func (p *SortingParams) Limit(start, count int) *SortingParams

+ func (p *SortingParams) NoSort() *SortingParams

v0.0.9

Jun 28, 2019

Changes in this version

+ const MaxInt

+ const MaxUint

+ const MinInt

+ const MinUint

+ var DigitOnes = []byte

+ var DigitTens = []byte

v0.0.8

Jun 28, 2019

v0.0.7

Jun 28, 2019

Changes in this version

+ func ByteArrToStringReply(reply []byte, err error) (string, error)

+ type ClusterMaxAttemptsError struct

+ Message string

+ func (e *ClusterMaxAttemptsError) Error() string

+ type ClusterOperationError struct

+ Message string

+ func (e *ClusterOperationError) Error() string

type GeoRadiusParam

+ func NewGeoRadiusParam() *GeoRadiusParam

+ func (p *GeoRadiusParam) Count(count int) *GeoRadiusParam

+ func (p *GeoRadiusParam) SortAscending() *GeoRadiusParam

+ func (p *GeoRadiusParam) SortDescending() *GeoRadiusParam

+ func (p *GeoRadiusParam) WithCoord() *GeoRadiusParam

+ func (p *GeoRadiusParam) WithDist() *GeoRadiusParam

type GeoRadiusResponse

+ func ObjectArrToGeoRadiusResponseReply(reply []interface{}, err error) ([]GeoRadiusResponse, error)

+ func ToGeoRespArrayReply(reply interface{}, err error) ([]GeoRadiusResponse, error)

+ type RedirectError struct

+ Message string

+ func (e *RedirectError) Error() string

type ZAddParams

+ func NewZAddParams() *ZAddParams

v0.0.6

Jun 26, 2019

Changes in this version

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

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

+ func GoID() (int, error)

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

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

+ type ClusterOption struct

+ ConnectionTimeout time.Duration

+ MaxAttempts int

+ Nodes []string

+ Password string

+ PoolConfig *PoolConfig

+ SoTimeout time.Duration

+ type NoReachableClusterNodeError struct

+ Message string

+ func NewNoReachableClusterNodeError(message string) *NoReachableClusterNodeError

+ func (e *NoReachableClusterNodeError) Error() string

type Pool

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

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

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

v0.0.5

Jun 23, 2019

Changes in this version

+ const AskPrefix

+ const AsteriskByte

+ const BusyPrefix

+ const ClusterAddslots

+ const ClusterCountkeyinslot

+ const ClusterDelslots

+ const ClusterFailover

+ const ClusterFlushslot

+ const ClusterForget

+ const ClusterGetkeysinslot

+ const ClusterInfo

+ const ClusterKeyslot

+ const ClusterMeet

+ const ClusterNodes

+ const ClusterReplicate

+ const ClusterReset

+ const ClusterSaveconfig

+ const ClusterSetslot

+ const ClusterSetslotImporting

+ const ClusterSetslotMigrating

+ const ClusterSetslotNode

+ const ClusterSetslotStable

+ const ClusterSlaves

+ const ClusterSlots

+ const ClusterdownPrefix

+ const ColonByte

+ const DefaultDatabase

+ const DefaultHost

+ const DefaultPort

+ const DefaultSentinelPort

+ const DefaultTimeout

+ const DollarByte

+ const MasterNodeIndex

+ const MinusByte

+ const MovedPrefix

+ const NoscriptPrefix

+ const PlusByte

+ const PubsubChannels

+ const PubsubNumPat

+ const PubsubNumsub

+ const SentinelFailover

+ const SentinelGetMasterAddrByName

+ const SentinelMasters

+ const SentinelMonitor

+ const SentinelRemove

+ const SentinelReset

+ const SentinelSet

+ const SentinelSlaves

+ var BitopAnd = NewBitOP("AND")

+ var BitopNot = NewBitOP("NOT")

+ var BitopOr = NewBitOP("OR")

+ var BitopXor = NewBitOP("XOR")

+ var BytesFalse = []byte

+ var BytesTilde = []byte("~")

+ var BytesTrue = []byte

+ var CmdAppend = newProtocolCommand("APPEND")

+ var CmdAsking = newProtocolCommand("ASKING")

+ var CmdAuth = newProtocolCommand("AUTH")

+ var CmdBgrewriteaof = newProtocolCommand("BGREWRITEAOF")

+ var CmdBgsave = newProtocolCommand("BGSAVE")

+ var CmdBitcount = newProtocolCommand("BITCOUNT")

+ var CmdBitfield = newProtocolCommand("BITFIELD")

+ var CmdBitop = newProtocolCommand("BITOP")

+ var CmdBitpos = newProtocolCommand("BITPOS")

+ var CmdBlpop = newProtocolCommand("BLPOP")

+ var CmdBrpop = newProtocolCommand("BRPOP")

+ var CmdBrpoplpush = newProtocolCommand("BRPOPLPUSH")

+ var CmdClient = newProtocolCommand("CLIENT")

+ var CmdCluster = newProtocolCommand("CLUSTER")

+ var CmdConfig = newProtocolCommand("CONFIG")

+ var CmdDbsize = newProtocolCommand("DBSIZE")

+ var CmdDebug = newProtocolCommand("DEBUG")

+ var CmdDecr = newProtocolCommand("DECR")

+ var CmdDecrby = newProtocolCommand("DECRBY")

+ var CmdDel = newProtocolCommand("DEL")

+ var CmdDiscard = newProtocolCommand("DISCARD")

+ var CmdDump = newProtocolCommand("DUMP")

+ var CmdEcho = newProtocolCommand("ECHO")

+ var CmdEval = newProtocolCommand("EVAL")

+ var CmdEvalsha = newProtocolCommand("EVALSHA")

+ var CmdExec = newProtocolCommand("EXEC")

+ var CmdExists = newProtocolCommand("EXISTS")

+ var CmdExpire = newProtocolCommand("EXPIRE")

+ var CmdExpireat = newProtocolCommand("EXPIREAT")

+ var CmdFlushall = newProtocolCommand("FLUSHALL")

+ var CmdFlushdb = newProtocolCommand("FLUSHDB")

+ var CmdGeoadd = newProtocolCommand("GEOADD")

+ var CmdGeodist = newProtocolCommand("GEODIST")

+ var CmdGeohash = newProtocolCommand("GEOHASH")

+ var CmdGeopos = newProtocolCommand("GEOPOS")

+ var CmdGeoradius = newProtocolCommand("GEORADIUS")

+ var CmdGeoradiusRo = newProtocolCommand("GEORADIUS_RO")

+ var CmdGeoradiusbymember = newProtocolCommand("GEORADIUSBYMEMBER")

+ var CmdGeoradiusbymemberRo = newProtocolCommand("GEORADIUSBYMEMBER_RO")

+ var CmdGet = newProtocolCommand("GET")

+ var CmdGetbit = newProtocolCommand("GETBIT")

+ var CmdGetrange = newProtocolCommand("GETRANGE")

+ var CmdGetset = newProtocolCommand("GETSET")

+ var CmdHdel = newProtocolCommand("HDEL")

+ var CmdHexists = newProtocolCommand("HEXISTS")

+ var CmdHget = newProtocolCommand("HGET")

+ var CmdHgetall = newProtocolCommand("HGETALL")

+ var CmdHincrby = newProtocolCommand("HINCRBY")

+ var CmdHincrbyfloat = newProtocolCommand("HINCRBYFLOAT")

+ var CmdHkeys = newProtocolCommand("HKEYS")

+ var CmdHlen = newProtocolCommand("HLEN")

+ var CmdHmget = newProtocolCommand("HMGET")

+ var CmdHmset = newProtocolCommand("HMSET")

+ var CmdHscan = newProtocolCommand("HSCAN")

+ var CmdHset = newProtocolCommand("HSET")

+ var CmdHsetnx = newProtocolCommand("HSETNX")

+ var CmdHstrlen = newProtocolCommand("HSTRLEN")

+ var CmdHvals = newProtocolCommand("HVALS")

+ var CmdIncr = newProtocolCommand("INCR")

+ var CmdIncrby = newProtocolCommand("INCRBY")

+ var CmdIncrbyfloat = newProtocolCommand("INCRBYFLOAT")

+ var CmdInfo = newProtocolCommand("INFO")

+ var CmdKeys = newProtocolCommand("KEYS")

+ var CmdLastsave = newProtocolCommand("LASTSAVE")

+ var CmdLindex = newProtocolCommand("LINDEX")

+ var CmdLinsert = newProtocolCommand("LINSERT")

+ var CmdLlen = newProtocolCommand("LLEN")

+ var CmdLpop = newProtocolCommand("LPOP")

+ var CmdLpush = newProtocolCommand("LPUSH")

+ var CmdLpushx = newProtocolCommand("LPUSHX")

+ var CmdLrange = newProtocolCommand("LRANGE")

+ var CmdLrem = newProtocolCommand("LREM")

+ var CmdLset = newProtocolCommand("LSET")

+ var CmdLtrim = newProtocolCommand("LTRIM")

+ var CmdMemory = newProtocolCommand("MEMORY")

+ var CmdMget = newProtocolCommand("MGET")

+ var CmdMigrate = newProtocolCommand("MIGRATE")

+ var CmdModule = newProtocolCommand("MODULE")

+ var CmdMonitor = newProtocolCommand("MONITOR")

+ var CmdMove = newProtocolCommand("MOVE")

+ var CmdMset = newProtocolCommand("MSET")

+ var CmdMsetnx = newProtocolCommand("MSETNX")

+ var CmdMulti = newProtocolCommand("MULTI")

+ var CmdObject = newProtocolCommand("OBJECT")

+ var CmdPersist = newProtocolCommand("PERSIST")

+ var CmdPexpire = newProtocolCommand("PEXPIRE")

+ var CmdPexpireat = newProtocolCommand("PEXPIREAT")

+ var CmdPfadd = newProtocolCommand("PFADD")

+ var CmdPfcount = newProtocolCommand("PFCOUNT")

+ var CmdPfmerge = newProtocolCommand("PFMERGE")

+ var CmdPing = newProtocolCommand("PING")

+ var CmdPsetex = newProtocolCommand("PSETEX")

+ var CmdPsubscribe = newProtocolCommand("PSUBSCRIBE")

+ var CmdPttl = newProtocolCommand("PTTL")

+ var CmdPublish = newProtocolCommand("PUBLISH")

+ var CmdPubsub = newProtocolCommand("PUBSUB")

+ var CmdPunsubscribe = newProtocolCommand("PUNSUBSCRIBE")

+ var CmdQuit = newProtocolCommand("QUIT")

+ var CmdRandomkey = newProtocolCommand("RANDOMKEY")

+ var CmdReadonly = newProtocolCommand("READONLY")

+ var CmdRename = newProtocolCommand("RENAME")

+ var CmdRenamenx = newProtocolCommand("RENAMENX")

+ var CmdRenamex = newProtocolCommand("RENAMEX")

+ var CmdRestore = newProtocolCommand("RESTORE")

+ var CmdRpop = newProtocolCommand("RPOP")

+ var CmdRpoplpush = newProtocolCommand("RPOPLPUSH")

+ var CmdRpush = newProtocolCommand("RPUSH")

+ var CmdRpushx = newProtocolCommand("RPUSHX")

+ var CmdSadd = newProtocolCommand("SADD")

+ var CmdSave = newProtocolCommand("SAVE")

+ var CmdScan = newProtocolCommand("SCAN")

+ var CmdScard = newProtocolCommand("SCARD")

+ var CmdScript = newProtocolCommand("SCRIPT")

+ var CmdSdiff = newProtocolCommand("SDIFF")

+ var CmdSdiffstore = newProtocolCommand("SDIFFSTORE")

+ var CmdSelect = newProtocolCommand("SELECT")

+ var CmdSentinel = newProtocolCommand("SENTINEL")

+ var CmdSet = newProtocolCommand("SET")

+ var CmdSetbit = newProtocolCommand("SETBIT")

+ var CmdSetex = newProtocolCommand("SETEX")

+ var CmdSetnx = newProtocolCommand("SETNX")

+ var CmdSetrange = newProtocolCommand("SETRANGE")

+ var CmdShutdown = newProtocolCommand("SHUTDOWN")

+ var CmdSinter = newProtocolCommand("SINTER")

+ var CmdSinterstore = newProtocolCommand("SINTERSTORE")

+ var CmdSismember = newProtocolCommand("SISMEMBER")

+ var CmdSlaveof = newProtocolCommand("SLAVEOF")

+ var CmdSlowlog = newProtocolCommand("SLOWLOG")

+ var CmdSmembers = newProtocolCommand("SMEMBERS")

+ var CmdSmove = newProtocolCommand("SMOVE")

+ var CmdSort = newProtocolCommand("SORT")

+ var CmdSpop = newProtocolCommand("SPOP")

+ var CmdSrandmember = newProtocolCommand("SRANDMEMBER")

+ var CmdSrem = newProtocolCommand("SREM")

+ var CmdSscan = newProtocolCommand("SSCAN")

+ var CmdStrlen = newProtocolCommand("STRLEN")

+ var CmdSubscribe = newProtocolCommand("SUBSCRIBE")

+ var CmdSubstr = newProtocolCommand("SUBSTR")

+ var CmdSunion = newProtocolCommand("SUNION")

+ var CmdSunionstore = newProtocolCommand("SUNIONSTORE")

+ var CmdSwapdb = newProtocolCommand("SWAPDB")

+ var CmdSync = newProtocolCommand("SYNC")

+ var CmdTime = newProtocolCommand("TIME")

+ var CmdTouch = newProtocolCommand("TOUCH")

+ var CmdTtl = newProtocolCommand("TTL")

+ var CmdType = newProtocolCommand("TYPE")

+ var CmdUnlink = newProtocolCommand("UNLINK")

+ var CmdUnsubscribe = newProtocolCommand("UNSUBSCRIBE")

+ var CmdUnwatch = newProtocolCommand("UNWATCH")

+ var CmdWait = newProtocolCommand("WAIT")

+ var CmdWatch = newProtocolCommand("WATCH")

+ var CmdXack = newProtocolCommand("XACK")

+ var CmdXadd = newProtocolCommand("XADD")

+ var CmdXclaim = newProtocolCommand("XCLAIM")

+ var CmdXdel = newProtocolCommand("XDEL")

+ var CmdXgroup = newProtocolCommand("XGROUP")

+ var CmdXlen = newProtocolCommand("XLEN")

+ var CmdXpending = newProtocolCommand("XPENDING")

+ var CmdXrange = newProtocolCommand("XRANGE")

+ var CmdXread = newProtocolCommand("XREAD")

+ var CmdXreadgroup = newProtocolCommand("XREADGROUP")

+ var CmdXrevrange = newProtocolCommand("XREVRANGE")

+ var CmdXtrim = newProtocolCommand("XTRIM")

+ var CmdZadd = newProtocolCommand("ZADD")

+ var CmdZcard = newProtocolCommand("ZCARD")

+ var CmdZcount = newProtocolCommand("ZCOUNT")

+ var CmdZincrby = newProtocolCommand("ZINCRBY")

+ var CmdZinterstore = newProtocolCommand("ZINTERSTORE")

+ var CmdZlexcount = newProtocolCommand("ZLEXCOUNT")

+ var CmdZrange = newProtocolCommand("ZRANGE")

+ var CmdZrangebylex = newProtocolCommand("ZRANGEBYLEX")

+ var CmdZrangebyscore = newProtocolCommand("ZRANGEBYSCORE")

+ var CmdZrank = newProtocolCommand("ZRANK")

+ var CmdZrem = newProtocolCommand("ZREM")

+ var CmdZremrangebylex = newProtocolCommand("ZREMRANGEBYLEX")

+ var CmdZremrangebyrank = newProtocolCommand("ZREMRANGEBYRANK")

+ var CmdZremrangebyscore = newProtocolCommand("ZREMRANGEBYSCORE")

+ var CmdZrevrange = newProtocolCommand("ZREVRANGE")

+ var CmdZrevrangebylex = newProtocolCommand("ZREVRANGEBYLEX")

+ var CmdZrevrangebyscore = newProtocolCommand("ZREVRANGEBYSCORE")

+ var CmdZrevrank = newProtocolCommand("ZREVRANK")

+ var CmdZscan = newProtocolCommand("ZSCAN")

+ var CmdZscore = newProtocolCommand("ZSCORE")

+ var CmdZunionstore = newProtocolCommand("ZUNIONSTORE")

+ var GeounitFt = NewGeoUnit("FT")

+ var GeounitKm = NewGeoUnit("KM")

+ var GeounitM = NewGeoUnit("M")

+ var GeounitMi = NewGeoUnit("MI")

+ var Int64Builder = newInt64Builder()

+ var KeywordAggregate = newKeyword("AGGREGATE")

+ var KeywordAlpha = newKeyword("ALPHA")

+ var KeywordAsc = newKeyword("ASC")

+ var KeywordBlock = newKeyword("BLOCK")

+ var KeywordBy = newKeyword("BY")

+ var KeywordCount = newKeyword("COUNT")

+ var KeywordCreate = newKeyword("CREATE")

+ var KeywordDelconsumer = newKeyword("DELCONSUMER")

+ var KeywordDesc = newKeyword("DESC")

+ var KeywordDestroy = newKeyword("DESTROY")

+ var KeywordDoctor = newKeyword("DOCTOR")

+ var KeywordEncoding = newKeyword("ENCODING")

+ var KeywordExists = newKeyword("EXISTS")

+ var KeywordFlush = newKeyword("FLUSH")

+ var KeywordForce = newKeyword("FORCE")

+ var KeywordGet = newKeyword("GET")

+ var KeywordGetname = newKeyword("GETNAME")

+ var KeywordGroup = newKeyword("GROUP")

+ var KeywordIdle = newKeyword("IDLE")

+ var KeywordIdletime = newKeyword("IDLETIME")

+ var KeywordKey = newKeyword("KEY")

+ var KeywordKeys = newKeyword("KEYS")

+ var KeywordKill = newKeyword("KILL")

+ var KeywordLen = newKeyword("LEN")

+ var KeywordLimit = newKeyword("LIMIT")

+ var KeywordList = newKeyword("LIST")

+ var KeywordLoad = newKeyword("LOAD")

+ var KeywordMatch = newKeyword("MATCH")

+ var KeywordMaxlen = newKeyword("MAXLEN")

+ var KeywordMessage = newKeyword("MESSAGE")

+ var KeywordMkstream = newKeyword("MKSTREAM")

+ var KeywordNo = newKeyword("NO")

+ var KeywordNoack = newKeyword("NOACK")

+ var KeywordNosort = newKeyword("NOSORT")

+ var KeywordOk = newKeyword("OK")

+ var KeywordOne = newKeyword("ONE")

+ var KeywordPause = newKeyword("PAUSE")

+ var KeywordPing = newKeyword("PING")

+ var KeywordPmessage = newKeyword("PMESSAGE")

+ var KeywordPong = newKeyword("PONG")

+ var KeywordPsubscribe = newKeyword("PSUBSCRIBE")

+ var KeywordPunsubscribe = newKeyword("PUNSUBSCRIBE")

+ var KeywordQueued = newKeyword("QUEUED")

+ var KeywordRefcount = newKeyword("REFCOUNT")

+ var KeywordReplace = newKeyword("REPLACE")

+ var KeywordReset = newKeyword("RESET")

+ var KeywordResetstat = newKeyword("RESETSTAT")

+ var KeywordRetrycount = newKeyword("RETRYCOUNT")

+ var KeywordRewrite = newKeyword("REWRITE")

+ var KeywordSet = newKeyword("SET")

+ var KeywordSetid = newKeyword("SETID")

+ var KeywordSetname = newKeyword("SETNAME")

+ var KeywordStore = newKeyword("STORE")

+ var KeywordStreams = newKeyword("STREAMS")

+ var KeywordSubscribe = newKeyword("SUBSCRIBE")

+ var KeywordTime = newKeyword("TIME")

+ var KeywordUnload = newKeyword("UNLOAD")

+ var KeywordUnsubscribe = newKeyword("UNSUBSCRIBE")

+ var KeywordWeights = newKeyword("WEIGHTS")

+ var KeywordWithscores = newKeyword("WITHSCORES")

+ var ListoptionAfter = NewListOption("AFTER")

+ var ListoptionBefore = NewListOption("BEFORE")

+ var LookupTable = []uint16

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

+ var PositiveInfinityBytes = []byte("+inf")

+ var ResetHard = NewReset("HARD")

+ var ResetSoft = NewReset("SOFT")

+ var StringArrayBuilder = newStringArrayBuilder()

+ var StringBuilder = newStringBuilder()

+ var ZparamsMax = NewZParams("MAX")

+ var ZparamsMin = NewZParams("MIN")

+ var ZparamsSum = NewZParams("SUM")

+ type AskDataError struct

+ Host string

+ Message string

+ Port int

+ Slot int

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

+ func (e *AskDataError) Error() string

+ type BusyError struct

+ Message string

+ func NewBusyError(message string) *BusyError

+ func (e *BusyError) Error() string

+ type ClusterError struct

+ Message string

+ func NewClusterError(message string) *ClusterError

+ func (e *ClusterError) Error() string

+ type ConnectError struct

+ Message string

+ func NewConnectError(message string) *ConnectError

+ func (e *ConnectError) Error() string

+ type DataError struct

+ Message string

+ func NewDataError(message string) *DataError

+ func (e *DataError) Error() string

type DebugParams

+ func NewDebugParamsObject(key string) *DebugParams

+ func NewDebugParamsReload() *DebugParams

+ func NewDebugParamsSegfault() *DebugParams

+ type LockOption struct

+ RetryCount int

+ RetryDelay time.Duration

+ Timeout time.Duration

+ type Locker interface

+ TryLock func(key string) (bool, error)

+ UnLock func() error

+ type MovedDataError struct

+ Host string

+ Message string

+ Port int

+ Slot int

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

+ func (e *MovedDataError) Error() string

+ type NoScriptError struct

+ Message string

+ func NewNoScriptError(message string) *NoScriptError

+ func (e *NoScriptError) Error() string

type Redis

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

+ func (r *Redis) Receive() error

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

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

+ type RedisError struct

+ Message string

+ func NewRedisError(message string) *RedisError

+ func (e *RedisError) Error() string

v0.0.4

Jun 21, 2019

v0.0.3

Jun 21, 2019

Changes in this version

+ var INT64_BUILDER = newInt64Builder()

+ func ByteArrayToInt64(bytes []byte) uint64

type BitOP

+ func NewBitOP(name string) BitOP

type Client

+ func (c *Client) Receive() (interface{}, error)

+ func (c Client) SendCommand(cmd protocolCommand, args ...[]byte) error

type GeoRadiusParam

+ func (g GeoRadiusParam) Contains(key string) bool

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

type GeoUnit

+ func NewGeoUnit(name string) GeoUnit

type ListOption

+ func NewListOption(name string) ListOption

+ type Option struct

+ ConnectionTimeout int

+ Db int

+ Host string

+ Password string

+ Port int

+ SoTimeout int

type Reset

+ func NewReset(name string) Reset

type ScanParams

+ func (s ScanParams) Count() int

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

+ func (s ScanParams) Match() string

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

v0.0.2

Jun 20, 2019

v0.0.1

Jun 20, 2019

Changes in this version

+ const ASK_PREFIX

+ const ASTERISK_BYTE

+ const BUSY_PREFIX

+ const CHARSET

+ const CLUSTERDOWN_PREFIX

+ const CLUSTER_ADDSLOTS

+ const CLUSTER_COUNTKEYINSLOT

+ const CLUSTER_DELSLOTS

+ const CLUSTER_FAILOVER

+ const CLUSTER_FLUSHSLOT

+ const CLUSTER_FORGET

+ const CLUSTER_GETKEYSINSLOT

+ const CLUSTER_INFO

+ const CLUSTER_KEYSLOT

+ const CLUSTER_MEET

+ const CLUSTER_NODES

+ const CLUSTER_REPLICATE

+ const CLUSTER_RESET

+ const CLUSTER_SAVECONFIG

+ const CLUSTER_SETSLOT

+ const CLUSTER_SETSLOT_IMPORTING

+ const CLUSTER_SETSLOT_MIGRATING

+ const CLUSTER_SETSLOT_NODE

+ const CLUSTER_SETSLOT_STABLE

+ const CLUSTER_SLAVES

+ const CLUSTER_SLOTS

+ const COLON_BYTE

+ const COMMA

+ const DEFAULT_DATABASE

+ const DEFAULT_HOST

+ const DEFAULT_PORT

+ const DEFAULT_SENTINEL_PORT

+ const DEFAULT_TIMEOUT

+ const DOLLAR_BYTE

+ const MASTER_NODE_INDEX

+ const MINUS_BYTE

+ const MOVED_PREFIX

+ const NOSCRIPT_PREFIX

+ const PLUS_BYTE

+ const PUBSUB_CHANNELS

+ const PUBSUB_NUMSUB

+ const PUBSUB_NUM_PAT

+ const SENTINEL_FAILOVER

+ const SENTINEL_GET_MASTER_ADDR_BY_NAME

+ const SENTINEL_MASTERS

+ const SENTINEL_MONITOR

+ const SENTINEL_REMOVE

+ const SENTINEL_RESET

+ const SENTINEL_SET

+ const SENTINEL_SLAVES

+ var BYTES_FALSE = []byte

+ var BYTES_TILDE = []byte("~")

+ var BYTES_TRUE = []byte

+ var BitOP_AND = newBitOP("AND")

+ var BitOP_NOT = newBitOP("NOT")

+ var BitOP_OR = newBitOP("OR")

+ var BitOP_XOR = newBitOP("XOR")

+ var CMD_APPEND = newProtocolCommand("APPEND")

+ var CMD_ASKING = newProtocolCommand("ASKING")

+ var CMD_AUTH = newProtocolCommand("AUTH")

+ var CMD_BGREWRITEAOF = newProtocolCommand("BGREWRITEAOF")

+ var CMD_BGSAVE = newProtocolCommand("BGSAVE")

+ var CMD_BITCOUNT = newProtocolCommand("BITCOUNT")

+ var CMD_BITFIELD = newProtocolCommand("BITFIELD")

+ var CMD_BITOP = newProtocolCommand("BITOP")

+ var CMD_BITPOS = newProtocolCommand("BITPOS")

+ var CMD_BLPOP = newProtocolCommand("BLPOP")

+ var CMD_BRPOP = newProtocolCommand("BRPOP")

+ var CMD_BRPOPLPUSH = newProtocolCommand("BRPOPLPUSH")

+ var CMD_CLIENT = newProtocolCommand("CLIENT")

+ var CMD_CLUSTER = newProtocolCommand("CLUSTER")

+ var CMD_CONFIG = newProtocolCommand("CONFIG")

+ var CMD_DBSIZE = newProtocolCommand("DBSIZE")

+ var CMD_DEBUG = newProtocolCommand("DEBUG")

+ var CMD_DECR = newProtocolCommand("DECR")

+ var CMD_DECRBY = newProtocolCommand("DECRBY")

+ var CMD_DEL = newProtocolCommand("DEL")

+ var CMD_DISCARD = newProtocolCommand("DISCARD")

+ var CMD_DUMP = newProtocolCommand("DUMP")

+ var CMD_ECHO = newProtocolCommand("ECHO")

+ var CMD_EVAL = newProtocolCommand("EVAL")

+ var CMD_EVALSHA = newProtocolCommand("EVALSHA")

+ var CMD_EXEC = newProtocolCommand("EXEC")

+ var CMD_EXISTS = newProtocolCommand("EXISTS")

+ var CMD_EXPIRE = newProtocolCommand("EXPIRE")

+ var CMD_EXPIREAT = newProtocolCommand("EXPIREAT")

+ var CMD_FLUSHALL = newProtocolCommand("FLUSHALL")

+ var CMD_FLUSHDB = newProtocolCommand("FLUSHDB")

+ var CMD_GEOADD = newProtocolCommand("GEOADD")

+ var CMD_GEODIST = newProtocolCommand("GEODIST")

+ var CMD_GEOHASH = newProtocolCommand("GEOHASH")

+ var CMD_GEOPOS = newProtocolCommand("GEOPOS")

+ var CMD_GEORADIUS = newProtocolCommand("GEORADIUS")

+ var CMD_GEORADIUSBYMEMBER = newProtocolCommand("GEORADIUSBYMEMBER")

+ var CMD_GEORADIUSBYMEMBER_RO = newProtocolCommand("GEORADIUSBYMEMBER_RO")

+ var CMD_GEORADIUS_RO = newProtocolCommand("GEORADIUS_RO")

+ var CMD_GET = newProtocolCommand("GET")

+ var CMD_GETBIT = newProtocolCommand("GETBIT")

+ var CMD_GETRANGE = newProtocolCommand("GETRANGE")

+ var CMD_GETSET = newProtocolCommand("GETSET")

+ var CMD_HDEL = newProtocolCommand("HDEL")

+ var CMD_HEXISTS = newProtocolCommand("HEXISTS")

+ var CMD_HGET = newProtocolCommand("HGET")

+ var CMD_HGETALL = newProtocolCommand("HGETALL")

+ var CMD_HINCRBY = newProtocolCommand("HINCRBY")

+ var CMD_HINCRBYFLOAT = newProtocolCommand("HINCRBYFLOAT")

+ var CMD_HKEYS = newProtocolCommand("HKEYS")

+ var CMD_HLEN = newProtocolCommand("HLEN")

+ var CMD_HMGET = newProtocolCommand("HMGET")

+ var CMD_HMSET = newProtocolCommand("HMSET")

+ var CMD_HSCAN = newProtocolCommand("HSCAN")

+ var CMD_HSET = newProtocolCommand("HSET")

+ var CMD_HSETNX = newProtocolCommand("HSETNX")

+ var CMD_HSTRLEN = newProtocolCommand("HSTRLEN")

+ var CMD_HVALS = newProtocolCommand("HVALS")

+ var CMD_INCR = newProtocolCommand("INCR")

+ var CMD_INCRBY = newProtocolCommand("INCRBY")

+ var CMD_INCRBYFLOAT = newProtocolCommand("INCRBYFLOAT")

+ var CMD_INFO = newProtocolCommand("INFO")

+ var CMD_KEYS = newProtocolCommand("KEYS")

+ var CMD_LASTSAVE = newProtocolCommand("LASTSAVE")

+ var CMD_LINDEX = newProtocolCommand("LINDEX")

+ var CMD_LINSERT = newProtocolCommand("LINSERT")

+ var CMD_LLEN = newProtocolCommand("LLEN")

+ var CMD_LPOP = newProtocolCommand("LPOP")

+ var CMD_LPUSH = newProtocolCommand("LPUSH")

+ var CMD_LPUSHX = newProtocolCommand("LPUSHX")

+ var CMD_LRANGE = newProtocolCommand("LRANGE")

+ var CMD_LREM = newProtocolCommand("LREM")

+ var CMD_LSET = newProtocolCommand("LSET")

+ var CMD_LTRIM = newProtocolCommand("LTRIM")

+ var CMD_MEMORY = newProtocolCommand("MEMORY")

+ var CMD_MGET = newProtocolCommand("MGET")

+ var CMD_MIGRATE = newProtocolCommand("MIGRATE")

+ var CMD_MODULE = newProtocolCommand("MODULE")

+ var CMD_MONITOR = newProtocolCommand("MONITOR")

+ var CMD_MOVE = newProtocolCommand("MOVE")

+ var CMD_MSET = newProtocolCommand("MSET")

+ var CMD_MSETNX = newProtocolCommand("MSETNX")

+ var CMD_MULTI = newProtocolCommand("MULTI")

+ var CMD_OBJECT = newProtocolCommand("OBJECT")

+ var CMD_PERSIST = newProtocolCommand("PERSIST")

+ var CMD_PEXPIRE = newProtocolCommand("PEXPIRE")

+ var CMD_PEXPIREAT = newProtocolCommand("PEXPIREAT")

+ var CMD_PFADD = newProtocolCommand("PFADD")

+ var CMD_PFCOUNT = newProtocolCommand("PFCOUNT")

+ var CMD_PFMERGE = newProtocolCommand("PFMERGE")

+ var CMD_PING = newProtocolCommand("PING")

+ var CMD_PSETEX = newProtocolCommand("PSETEX")

+ var CMD_PSUBSCRIBE = newProtocolCommand("PSUBSCRIBE")

+ var CMD_PTTL = newProtocolCommand("PTTL")

+ var CMD_PUBLISH = newProtocolCommand("PUBLISH")

+ var CMD_PUBSUB = newProtocolCommand("PUBSUB")

+ var CMD_PUNSUBSCRIBE = newProtocolCommand("PUNSUBSCRIBE")

+ var CMD_QUIT = newProtocolCommand("QUIT")

+ var CMD_RANDOMKEY = newProtocolCommand("RANDOMKEY")

+ var CMD_READONLY = newProtocolCommand("READONLY")

+ var CMD_RENAME = newProtocolCommand("RENAME")

+ var CMD_RENAMENX = newProtocolCommand("RENAMENX")

+ var CMD_RENAMEX = newProtocolCommand("RENAMEX")

+ var CMD_RESTORE = newProtocolCommand("RESTORE")

+ var CMD_RPOP = newProtocolCommand("RPOP")

+ var CMD_RPOPLPUSH = newProtocolCommand("RPOPLPUSH")

+ var CMD_RPUSH = newProtocolCommand("RPUSH")

+ var CMD_RPUSHX = newProtocolCommand("RPUSHX")

+ var CMD_SADD = newProtocolCommand("SADD")

+ var CMD_SAVE = newProtocolCommand("SAVE")

+ var CMD_SCAN = newProtocolCommand("SCAN")

+ var CMD_SCARD = newProtocolCommand("SCARD")

+ var CMD_SCRIPT = newProtocolCommand("SCRIPT")

+ var CMD_SDIFF = newProtocolCommand("SDIFF")

+ var CMD_SDIFFSTORE = newProtocolCommand("SDIFFSTORE")

+ var CMD_SELECT = newProtocolCommand("SELECT")

+ var CMD_SENTINEL = newProtocolCommand("SENTINEL")

+ var CMD_SET = newProtocolCommand("SET")

+ var CMD_SETBIT = newProtocolCommand("SETBIT")

+ var CMD_SETEX = newProtocolCommand("SETEX")

+ var CMD_SETNX = newProtocolCommand("SETNX")

+ var CMD_SETRANGE = newProtocolCommand("SETRANGE")

+ var CMD_SHUTDOWN = newProtocolCommand("SHUTDOWN")

+ var CMD_SINTER = newProtocolCommand("SINTER")

+ var CMD_SINTERSTORE = newProtocolCommand("SINTERSTORE")

+ var CMD_SISMEMBER = newProtocolCommand("SISMEMBER")

+ var CMD_SLAVEOF = newProtocolCommand("SLAVEOF")

+ var CMD_SLOWLOG = newProtocolCommand("SLOWLOG")

+ var CMD_SMEMBERS = newProtocolCommand("SMEMBERS")

+ var CMD_SMOVE = newProtocolCommand("SMOVE")

+ var CMD_SORT = newProtocolCommand("SORT")

+ var CMD_SPOP = newProtocolCommand("SPOP")

+ var CMD_SRANDMEMBER = newProtocolCommand("SRANDMEMBER")

+ var CMD_SREM = newProtocolCommand("SREM")

+ var CMD_SSCAN = newProtocolCommand("SSCAN")

+ var CMD_STRLEN = newProtocolCommand("STRLEN")

+ var CMD_SUBSCRIBE = newProtocolCommand("SUBSCRIBE")

+ var CMD_SUBSTR = newProtocolCommand("SUBSTR")

+ var CMD_SUNION = newProtocolCommand("SUNION")

+ var CMD_SUNIONSTORE = newProtocolCommand("SUNIONSTORE")

+ var CMD_SWAPDB = newProtocolCommand("SWAPDB")

+ var CMD_SYNC = newProtocolCommand("SYNC")

+ var CMD_TIME = newProtocolCommand("TIME")

+ var CMD_TOUCH = newProtocolCommand("TOUCH")

+ var CMD_TTL = newProtocolCommand("TTL")

+ var CMD_TYPE = newProtocolCommand("TYPE")

+ var CMD_UNLINK = newProtocolCommand("UNLINK")

+ var CMD_UNSUBSCRIBE = newProtocolCommand("UNSUBSCRIBE")

+ var CMD_UNWATCH = newProtocolCommand("UNWATCH")

+ var CMD_WAIT = newProtocolCommand("WAIT")

+ var CMD_WATCH = newProtocolCommand("WATCH")

+ var CMD_XACK = newProtocolCommand("XACK")

+ var CMD_XADD = newProtocolCommand("XADD")

+ var CMD_XCLAIM = newProtocolCommand("XCLAIM")

+ var CMD_XDEL = newProtocolCommand("XDEL")

+ var CMD_XGROUP = newProtocolCommand("XGROUP")

+ var CMD_XLEN = newProtocolCommand("XLEN")

+ var CMD_XPENDING = newProtocolCommand("XPENDING")

+ var CMD_XRANGE = newProtocolCommand("XRANGE")

+ var CMD_XREAD = newProtocolCommand("XREAD")

+ var CMD_XREADGROUP = newProtocolCommand("XREADGROUP")

+ var CMD_XREVRANGE = newProtocolCommand("XREVRANGE")

+ var CMD_XTRIM = newProtocolCommand("XTRIM")

+ var CMD_ZADD = newProtocolCommand("ZADD")

+ var CMD_ZCARD = newProtocolCommand("ZCARD")

+ var CMD_ZCOUNT = newProtocolCommand("ZCOUNT")

+ var CMD_ZINCRBY = newProtocolCommand("ZINCRBY")

+ var CMD_ZINTERSTORE = newProtocolCommand("ZINTERSTORE")

+ var CMD_ZLEXCOUNT = newProtocolCommand("ZLEXCOUNT")

+ var CMD_ZRANGE = newProtocolCommand("ZRANGE")

+ var CMD_ZRANGEBYLEX = newProtocolCommand("ZRANGEBYLEX")

+ var CMD_ZRANGEBYSCORE = newProtocolCommand("ZRANGEBYSCORE")

+ var CMD_ZRANK = newProtocolCommand("ZRANK")

+ var CMD_ZREM = newProtocolCommand("ZREM")

+ var CMD_ZREMRANGEBYLEX = newProtocolCommand("ZREMRANGEBYLEX")

+ var CMD_ZREMRANGEBYRANK = newProtocolCommand("ZREMRANGEBYRANK")

+ var CMD_ZREMRANGEBYSCORE = newProtocolCommand("ZREMRANGEBYSCORE")

+ var CMD_ZREVRANGE = newProtocolCommand("ZREVRANGE")

+ var CMD_ZREVRANGEBYLEX = newProtocolCommand("ZREVRANGEBYLEX")

+ var CMD_ZREVRANGEBYSCORE = newProtocolCommand("ZREVRANGEBYSCORE")

+ var CMD_ZREVRANK = newProtocolCommand("ZREVRANK")

+ var CMD_ZSCAN = newProtocolCommand("ZSCAN")

+ var CMD_ZSCORE = newProtocolCommand("ZSCORE")

+ var CMD_ZUNIONSTORE = newProtocolCommand("ZUNIONSTORE")

+ var GEOUNIT_FT = newGeoUnit("FT")

+ var GEOUNIT_KM = newGeoUnit("KM")

+ var GEOUNIT_M = newGeoUnit("M")

+ var GEOUNIT_MI = newGeoUnit("MI")

+ var KEYWORD_AGGREGATE = newKeyword("AGGREGATE")

+ var KEYWORD_ALPHA = newKeyword("ALPHA")

+ var KEYWORD_ASC = newKeyword("ASC")

+ var KEYWORD_BLOCK = newKeyword("BLOCK")

+ var KEYWORD_BY = newKeyword("BY")

+ var KEYWORD_COUNT = newKeyword("COUNT")

+ var KEYWORD_CREATE = newKeyword("CREATE")

+ var KEYWORD_DELCONSUMER = newKeyword("DELCONSUMER")

+ var KEYWORD_DESC = newKeyword("DESC")

+ var KEYWORD_DESTROY = newKeyword("DESTROY")

+ var KEYWORD_DOCTOR = newKeyword("DOCTOR")

+ var KEYWORD_ENCODING = newKeyword("ENCODING")

+ var KEYWORD_EXISTS = newKeyword("EXISTS")

+ var KEYWORD_FLUSH = newKeyword("FLUSH")

+ var KEYWORD_FORCE = newKeyword("FORCE")

+ var KEYWORD_GET = newKeyword("GET")

+ var KEYWORD_GETNAME = newKeyword("GETNAME")

+ var KEYWORD_GROUP = newKeyword("GROUP")

+ var KEYWORD_IDLE = newKeyword("IDLE")

+ var KEYWORD_IDLETIME = newKeyword("IDLETIME")

+ var KEYWORD_KEY = newKeyword("KEY")

+ var KEYWORD_KEYS = newKeyword("KEYS")

+ var KEYWORD_KILL = newKeyword("KILL")

+ var KEYWORD_LEN = newKeyword("LEN")

+ var KEYWORD_LIMIT = newKeyword("LIMIT")

+ var KEYWORD_LIST = newKeyword("LIST")

+ var KEYWORD_LOAD = newKeyword("LOAD")

+ var KEYWORD_MATCH = newKeyword("MATCH")

+ var KEYWORD_MAXLEN = newKeyword("MAXLEN")

+ var KEYWORD_MESSAGE = newKeyword("MESSAGE")

+ var KEYWORD_MKSTREAM = newKeyword("MKSTREAM")

+ var KEYWORD_NO = newKeyword("NO")

+ var KEYWORD_NOACK = newKeyword("NOACK")

+ var KEYWORD_NOSORT = newKeyword("NOSORT")

+ var KEYWORD_OK = newKeyword("OK")

+ var KEYWORD_ONE = newKeyword("ONE")

+ var KEYWORD_PAUSE = newKeyword("PAUSE")

+ var KEYWORD_PING = newKeyword("PING")

+ var KEYWORD_PMESSAGE = newKeyword("PMESSAGE")

+ var KEYWORD_PONG = newKeyword("PONG")

+ var KEYWORD_PSUBSCRIBE = newKeyword("PSUBSCRIBE")

+ var KEYWORD_PUNSUBSCRIBE = newKeyword("PUNSUBSCRIBE")

+ var KEYWORD_QUEUED = newKeyword("QUEUED")

+ var KEYWORD_REFCOUNT = newKeyword("REFCOUNT")

+ var KEYWORD_REPLACE = newKeyword("REPLACE")

+ var KEYWORD_RESET = newKeyword("RESET")

+ var KEYWORD_RESETSTAT = newKeyword("RESETSTAT")

+ var KEYWORD_RETRYCOUNT = newKeyword("RETRYCOUNT")

+ var KEYWORD_REWRITE = newKeyword("REWRITE")

+ var KEYWORD_SET = newKeyword("SET")

+ var KEYWORD_SETID = newKeyword("SETID")

+ var KEYWORD_SETNAME = newKeyword("SETNAME")

+ var KEYWORD_STORE = newKeyword("STORE")

+ var KEYWORD_STREAMS = newKeyword("STREAMS")

+ var KEYWORD_SUBSCRIBE = newKeyword("SUBSCRIBE")

+ var KEYWORD_TIME = newKeyword("TIME")

+ var KEYWORD_UNLOAD = newKeyword("UNLOAD")

+ var KEYWORD_UNSUBSCRIBE = newKeyword("UNSUBSCRIBE")

+ var KEYWORD_WEIGHTS = newKeyword("WEIGHTS")

+ var KEYWORD_WITHSCORES = newKeyword("WITHSCORES")

+ var LOOKUP_TABLE = []uint16

+ var ListOption_AFTER = newListOption("AFTER")

+ var ListOption_BEFORE = newListOption("BEFORE")

+ var NEGATIVE_INFINITY_BYTES = []byte("-inf")

+ var POSITIVE_INFINITY_BYTES = []byte("+inf")

+ var Reset_HARD = newReset("HARD")

+ var Reset_SOFT = newReset("SOFT")

+ var STRING_ARRAY_BUILDER = newStringArrayBuilder()

+ var STRING_BUILDER = newStringBuilder()

+ var ZParams_MAX = newZParams("MAX")

+ var ZParams_MIN = newZParams("MIN")

+ var ZParams_SUM = newZParams("SUM")

+ func BoolToByteArray(a bool) []byte

+ func ByteArrayToFloat64(bytes []byte) float64

+ func ByteArrayToInt(bytes []byte) uint64

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

+ func Float64ToByteArray(a float64) []byte

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

+ func Int64ToByteArray(a int64) []byte

+ func IntToByteArray(a int) []byte

+ 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 AdvancedRedisCommands interface

+ ConfigGet func(pattern string) ([]string, error)

+ ConfigSet func(parameter string, value string) (string, error)

+ ObjectEncoding func(str string) (string, error)

+ ObjectIdletime func(str string) (int64, error)

+ ObjectRefcount func(str string) (int64, error)

+ SlowlogGet func(entries ...int64) ([]Slowlog, error)

+ SlowlogLen func() (int64, error)

+ SlowlogReset func() (string, error)

+ type BasicCommands interface

+ Auth func(password string) (string, error)

+ Bgrewriteaof func() (string, error)

+ Bgsave func() (string, error)

+ ConfigResetStat func() (string, error)

+ DbSize func() (int64, error)

+ Debug func(params DebugParams) (string, error)

+ FlushAll func() (string, error)

+ FlushDB func() (string, error)

+ GetDB func() int

+ Info func(section ...string) (string, error)

+ Lastsave func() (int64, error)

+ Ping func() (string, error)

+ Quit func() (string, error)

+ Save func() (string, error)

+ Select func(index int) (string, error)

+ Shutdown func() (string, error)

+ Slaveof func(host string, port int) (string, error)

+ SlaveofNoOne func() (string, error)

+ WaitReplicas func(replicas int, timeout int64) (int64, error)

+ type BasicRedisPipeline interface

+ Bgrewriteaof func() (*Response, error)

+ Bgsave func() (*Response, error)

+ ConfigGet func(pattern string) (*Response, error)

+ ConfigResetStat func() (*Response, error)

+ ConfigSet func(parameter, value string) (*Response, error)

+ DbSize func() (*Response, error)

+ FlushAll func() (*Response, error)

+ FlushDB func() (*Response, error)

+ Info func() (*Response, error)

+ Lastsave func() (*Response, error)

+ Ping func() (*Response, error)

+ Save func() (*Response, error)

+ Select func(index int) (*Response, error)

+ Shutdown func() (*Response, error)

+ Time func() (*Response, error)

+ type BitOP struct

+ Name string

+ func (g BitOP) GetRaw() []byte

+ type BitPosParams struct

+ type Builder interface

+ type CRC16 struct

+ func NewCRC16() *CRC16

+ type Client struct

+ Db int

+ IsInMulti bool

+ IsInWatch bool

+ Password string

+ func NewClient(shardInfo ShardInfo) *Client

+ func (c *Client) Append(key, value string) error

+ func (c *Client) Asking() error

+ func (c *Client) Auth(password string) error

+ func (c *Client) Bgrewriteaof() error

+ func (c *Client) Bgsave() error

+ func (c *Client) Bitcount(key string) error

+ func (c *Client) BitcountRange(key string, start, end int64) error

+ func (c *Client) Bitfield(key string, arguments ...string) error

+ func (c *Client) Bitop(op BitOP, destKey string, srcKeys ...string) error

+ func (c *Client) Bitpos(key string, value bool, params ...BitPosParams) error

+ func (c *Client) Blpop(args []string) error

+ func (c *Client) BlpopTimout(timeout int, keys ...string) error

+ func (c *Client) Brpop(args []string) error

+ func (c *Client) BrpopTimout(timeout int, keys ...string) error

+ func (c *Client) Brpoplpush(source, destination string, timeout int) error

+ func (c *Client) ClientGetname() error

+ func (c *Client) ClientKill(client string) error

+ func (c *Client) ClientList() error

+ func (c *Client) ClientSetname(name string) error

+ func (c *Client) Close() error

+ func (c *Client) Cluster(args ...[]byte) error

+ func (c *Client) ClusterAddSlots(slots ...int) error

+ func (c *Client) ClusterCountKeysInSlot(slot int) error

+ func (c *Client) ClusterDelSlots(slots ...int) error

+ func (c *Client) ClusterFailover() error

+ func (c *Client) ClusterFlushSlots() error

+ func (c *Client) ClusterForget(nodeId string) error

+ func (c *Client) ClusterGetKeysInSlot(slot int, count int) error

+ func (c *Client) ClusterInfo() error

+ func (c *Client) ClusterKeySlot(key string) error

+ func (c *Client) ClusterMeet(ip string, port int) error

+ func (c *Client) ClusterNodes() error

+ func (c *Client) ClusterReplicate(nodeId string) error

+ func (c *Client) ClusterReset(resetType Reset) error

+ func (c *Client) ClusterSaveConfig() error

+ func (c *Client) ClusterSetSlotImporting(slot int, nodeId string) error

+ func (c *Client) ClusterSetSlotMigrating(slot int, nodeId string) error

+ func (c *Client) ClusterSetSlotNode(slot int, nodeId string) error

+ func (c *Client) ClusterSetSlotStable(slot int) error

+ func (c *Client) ClusterSlaves(nodeId string) error

+ func (c *Client) ClusterSlots() error

+ func (c *Client) ConfigGet(pattern string) error

+ func (c *Client) ConfigResetStat() error

+ func (c *Client) ConfigSet(parameter, value string) error

+ func (c *Client) Connect() error

+ func (c *Client) DbSize() error

+ func (c *Client) Debug(params DebugParams) error

+ func (c *Client) Decr(key string) error

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

+ func (c *Client) Del(keys ...string) error

+ func (c *Client) Discard() error

+ func (c *Client) Dump(key string) error

+ func (c *Client) Echo(string string) error

+ func (c *Client) Eval(script string, keyCount int, params ...string) error

+ func (c *Client) Evalsha(sha1 string, keyCount int, params ...string) error

+ func (c *Client) Exec() error

+ func (c *Client) Exists(keys ...string) error

+ func (c *Client) Expire(key string, seconds int) error

+ func (c *Client) ExpireAt(key string, unixTime int64) error

+ func (c *Client) FlushAll() error

+ func (c *Client) FlushDB() error

+ func (c *Client) Geoadd(key string, longitude, latitude float64, member string) error

+ func (c *Client) GeoaddByMap(key string, memberCoordinateMap map[string]GeoCoordinate) error

+ func (c *Client) Geodist(key, member1, member2 string, unit ...GeoUnit) error

+ func (c *Client) Geohash(key string, members ...string) error

+ func (c *Client) Geopos(key string, members ...string) error

+ func (c *Client) Georadius(key string, longitude, latitude, radius float64, unit GeoUnit, ...) error

+ func (c *Client) GeoradiusByMember(key, member string, radius float64, unit GeoUnit, param ...GeoRadiusParam) error

+ func (c *Client) Get(key string) error

+ func (c *Client) GetDB() int

+ func (c *Client) GetSet(key, value string) error

+ func (c *Client) Getbit(key string, offset int64) error

+ func (c *Client) Getrange(key string, startOffset, endOffset int64) error

+ func (c *Client) Hdel(key string, fields ...string) error

+ func (c *Client) Hexists(key, field string) error

+ func (c *Client) Hget(key, field string) error

+ func (c *Client) HgetAll(key string) error

+ func (c *Client) HincrBy(key, field string, increment int64) error

+ func (c *Client) HincrByFloat(key, field string, increment float64) error

+ func (c *Client) Hkeys(key string) error

+ func (c *Client) Hlen(key string) error

+ func (c *Client) Hmget(key string, fields ...string) error

+ func (c *Client) Hmset(key string, hash map[string]string) error

+ func (c *Client) Host() string

+ func (c *Client) Hscan(key, cursor string, params ...ScanParams) error

+ func (c *Client) Hset(key, field, value string) error

+ func (c *Client) Hsetnx(key, field, value string) error

+ func (c *Client) Hvals(key string) error

+ func (c *Client) Incr(key string) error

+ func (c *Client) IncrBy(key string, increment int64) error

+ func (c *Client) IncrByFloat(key string, increment float64) error

+ func (c *Client) Info(section ...string) error

+ func (c *Client) Keys(pattern string) error

+ func (c *Client) Lastsave() error

+ func (c *Client) Lindex(key string, index int64) error

+ func (c *Client) Linsert(key string, where ListOption, pivot, value string) error

+ func (c *Client) Llen(key string) error

+ func (c *Client) Lpop(key string) error

+ func (c *Client) Lpush(key string, fields ...string) error

+ func (c *Client) Lpushx(key string, string ...string) error

+ func (c *Client) Lrange(key string, start, end int64) error

+ func (c *Client) Lrem(key string, count int64, value string) error

+ func (c *Client) Lset(key string, index int64, value string) error

+ func (c *Client) Ltrim(key string, start, end int64) error

+ func (c *Client) Mget(keys ...string) error

+ func (c *Client) Migrate(host string, port int, key string, destinationDb int, timeout int) error

+ func (c *Client) Move(key string, dbIndex int) error

+ func (c *Client) Mset(keysvalues ...string) error

+ func (c *Client) Msetnx(keysvalues ...string) error

+ func (c *Client) Multi() error

+ func (c *Client) ObjectEncoding(str string) error

+ func (c *Client) ObjectIdletime(str string) error

+ func (c *Client) ObjectRefcount(str string) error

+ func (c *Client) Persist(key string) error

+ func (c *Client) Pexpire(key string, milliseconds int64) error

+ func (c *Client) PexpireAt(key string, unixTime int64) error

+ func (c *Client) Pfadd(key string, elements ...string) error

+ func (c *Client) Pfcount(keys ...string) error

+ func (c *Client) Pfmerge(destkey string, sourcekeys ...string) error

+ func (c *Client) Ping() error

+ func (c *Client) Port() int

+ func (c *Client) Psetex(key string, milliseconds int64, value string) error

+ func (c *Client) Psubscribe(patterns ...string) error

+ func (c *Client) Pttl(key string) error

+ func (c *Client) Publish(channel, message string) error

+ func (c *Client) Pubsub(subcommand string, args ...string) error

+ func (c *Client) PubsubChannels(pattern string) error

+ func (c *Client) Punsubscribe(patterns ...string) error

+ func (c *Client) Quit() error

+ func (c *Client) RandomKey() error

+ func (c *Client) Readonly() error

+ func (c *Client) Rename(oldKey, newKey string) error

+ func (c *Client) Renamenx(oldKey, newKey string) error

+ func (c *Client) Restore(key string, ttl int, serializedValue []byte) error

+ func (c *Client) Rpop(key string) error

+ func (c *Client) RpopLpush(srckey, dstkey string) error

+ func (c *Client) Rpush(key string, fields ...string) error

+ func (c *Client) Rpushx(key string, string ...string) error

+ func (c *Client) Sadd(key string, members ...string) error

+ func (c *Client) Save() error

+ func (c *Client) Scan(cursor string, params ...ScanParams) error

+ func (c *Client) Scard(key string) error

+ func (c *Client) ScriptExists(sha1 ...string) error

+ func (c *Client) ScriptLoad(script string) error

+ func (c *Client) Sdiff(keys ...string) error

+ func (c *Client) Sdiffstore(dstkey string, keys ...string) error

+ func (c *Client) Select(index int) error

+ func (c *Client) Sentinel(args ...string) error

+ func (c *Client) SentinelFailover(masterName string) error

+ func (c *Client) SentinelGetMasterAddrByName(masterName string) error

+ func (c *Client) SentinelMasters() error

+ func (c *Client) SentinelMonitor(masterName, ip string, port, quorum int) error

+ func (c *Client) SentinelRemove(masterName string) error

+ func (c *Client) SentinelReset(pattern string) error

+ func (c *Client) SentinelSet(masterName string, parameterMap map[string]string) error

+ func (c *Client) SentinelSlaves(masterName string) error

+ func (c *Client) Set(key, value string) error

+ func (c *Client) SetWithParams(key, value, nxxx string) error

+ func (c *Client) SetWithParamsAndTime(key, value, nxxx, expx string, time int64) error

+ func (c *Client) Setbit(key string, offset int64, value string) error

+ func (c *Client) Setex(key string, seconds int, value string) error

+ func (c *Client) Setnx(key, value string) error

+ func (c *Client) Setrange(key string, offset int64, value string) error

+ func (c *Client) Shutdown() error

+ func (c *Client) Sinter(keys ...string) error

+ func (c *Client) Sinterstore(dstkey string, keys ...string) error

+ func (c *Client) Sismember(key, member string) error

+ func (c *Client) Slaveof(host string, port int) error

+ func (c *Client) SlaveofNoOne() error

+ func (c *Client) SlowlogGet(entries ...int64) error

+ func (c *Client) SlowlogLen() error

+ func (c *Client) SlowlogReset() error

+ func (c *Client) Smembers(key string) error

+ func (c *Client) Smove(srckey, dstkey, member string) error

+ func (c *Client) Sort(key string, sortingParameters ...SortingParams) error

+ func (c *Client) SortMulti(key, dstkey string, sortingParameters ...SortingParams) error

+ func (c *Client) Spop(key string) error

+ func (c *Client) SpopBatch(key string, count int64) error

+ func (c *Client) Srandmember(key string) error

+ func (c *Client) SrandmemberBatch(key string, count int) error

+ func (c *Client) Srem(key string, members ...string) error

+ func (c *Client) Sscan(key, cursor string, params ...ScanParams) error

+ func (c *Client) Strlen(key string) error

+ func (c *Client) Subscribe(channels ...string) error

+ func (c *Client) Substr(key string, start, end int) error

+ func (c *Client) Sunion(keys ...string) error

+ func (c *Client) Sunionstore(dstkey string, keys ...string) error

+ func (c *Client) Time() error

+ func (c *Client) Ttl(key string) error

+ func (c *Client) Type(key string) error

+ func (c *Client) Unsubscribe(channels ...string) error

+ func (c *Client) Unwatch() error

+ func (c *Client) WaitReplicas(replicas int, timeout int64) error

+ func (c *Client) Watch(keys ...string) error

+ func (c *Client) Zadd(key string, score float64, member string) error

+ func (c *Client) ZaddByMap(key string, scoreMembers map[string]float64, params ...ZAddParams) error

+ func (c *Client) Zcard(key string) error

+ func (c *Client) Zcount(key, min, max string) error

+ func (c *Client) Zincrby(key string, score float64, member string) error

+ func (c *Client) Zinterstore(dstkey string, sets ...string) error

+ func (c *Client) ZinterstoreWithParams(dstkey string, params ZParams, sets ...string) error

+ func (c *Client) Zlexcount(key, min, max string) error

+ func (c *Client) Zrange(key string, start, end int64) error

+ func (c *Client) ZrangeByLex(key, min, max string) error

+ func (c *Client) ZrangeByLexBatch(key, min, max string, offset, count int) error

+ func (c *Client) ZrangeByScore(key, min, max string) error

+ func (c *Client) ZrangeByScoreBatch(key, max, min string, offset, count int) error

+ func (c *Client) ZrangeWithScores(key string, start, end int64) error

+ func (c *Client) Zrank(key, member string) error

+ func (c *Client) Zrem(key string, members ...string) error

+ func (c *Client) ZremrangeByLex(key, min, max string) error

+ func (c *Client) ZremrangeByRank(key string, start, end int64) error

+ func (c *Client) ZremrangeByScore(key, start, end string) error

+ func (c *Client) Zrevrange(key string, start, end int64) error

+ func (c *Client) ZrevrangeByLex(key, max, min string) error

+ func (c *Client) ZrevrangeByLexBatch(key, max, min string, offset, count int) error

+ func (c *Client) ZrevrangeByScore(key, max, min string) error

+ func (c *Client) ZrevrangeByScoreBatch(key, max, min string, offset, count int) error

+ func (c *Client) ZrevrangeByScoreWithScores(key, max, min string) error

+ func (c *Client) ZrevrangeWithScores(key string, start, end int64) error

+ func (c *Client) Zrevrank(key, member string) error

+ func (c *Client) Zscan(key, cursor string, params ...ScanParams) error

+ func (c *Client) Zscore(key, member string) error

+ func (c *Client) Zunionstore(dstkey string, sets ...string) error

+ func (c *Client) ZunionstoreWithParams(dstkey string, params ZParams, sets ...string) error

+ type ClusterCommands interface

+ ClusterAddSlots func(slots ...int) (string, error)

+ ClusterCountKeysInSlot func(slot int) (int64, error)

+ ClusterDelSlots func(slots ...int) (string, error)

+ ClusterFailover func() (string, error)

+ ClusterFlushSlots func() (string, error)

+ ClusterForget func(nodeId string) (string, error)

+ ClusterGetKeysInSlot func(slot int, count int) ([]string, error)

+ ClusterInfo func() (string, error)

+ ClusterKeySlot func(key string) (int64, error)

+ ClusterMeet func(ip string, port int) (string, error)

+ ClusterNodes func() (string, error)

+ ClusterReplicate func(nodeId string) (string, error)

+ ClusterReset func(resetType Reset) (string, error)

+ ClusterSaveConfig func() (string, error)

+ ClusterSetSlotImporting func(slot int, nodeId string) (string, error)

+ ClusterSetSlotMigrating func(slot int, nodeId string) (string, error)

+ ClusterSetSlotNode func(slot int, nodeId string) (string, error)

+ ClusterSetSlotStable func(slot int) (string, error)

+ ClusterSlaves func(nodeId string) ([]string, error)

+ ClusterSlots func() ([]interface{}, error)

+ Readonly func() (string, error)

+ type ClusterPipeline interface

+ ClusterAddSlots func(slots ...int) (*Response, error)

+ ClusterDelSlots func(slots ...int) (*Response, error)

+ ClusterGetKeysInSlot func(slot int, count int) (*Response, error)

+ ClusterInfo func() (*Response, error)

+ ClusterMeet func(ip string, port int) (*Response, error)

+ ClusterNodes func() (*Response, error)

+ ClusterSetSlotImporting func(slot int, nodeId string) (*Response, error)

+ ClusterSetSlotMigrating func(slot int, nodeId string) (*Response, error)

+ ClusterSetSlotNode func(slot int, nodeId string) (*Response, error)

+ type ClusterScriptingCommands interface

+ Eval func(script string, keyCount int, params ...string) (interface{}, error)

+ Evalsha func(sha1 string, keyCount int, params ...string) (interface{}, error)

+ ScriptExists func(key string, sha1 ...string) ([]bool, error)

+ ScriptLoad func(key, script string) (string, error)

+ type Connection struct

+ Broken bool

+ ConnectionTimeout int

+ Host string

+ Port int

+ Protocol *Protocol

+ SoTimeout int

+ Socket net.Conn

+ Ssl bool

+ func NewConnection(host string, port, connectionTimeout, soTimeout int, ssl bool) *Connection

+ func (c *Connection) Close() error

+ func (c *Connection) Connect() error

+ func (c *Connection) IsConnected() bool

+ func (c *Connection) SendCommand(cmd protocolCommand, args ...[]byte) error

+ type DebugParams struct

+ type Factory struct

+ func NewFactory(shardInfo ShardInfo) *Factory

+ func (f Factory) ActivateObject(ctx context.Context, object *pool.PooledObject) error

+ func (f Factory) DestroyObject(ctx context.Context, object *pool.PooledObject) error

+ func (f Factory) MakeObject(ctx context.Context) (*pool.PooledObject, error)

+ func (f Factory) PassivateObject(ctx context.Context, object *pool.PooledObject) error

+ func (f Factory) ValidateObject(ctx context.Context, object *pool.PooledObject) bool

+ type GeoCoordinate struct

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

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

+ type GeoRadiusParam struct

+ type GeoRadiusResponse struct

+ type GeoUnit struct

+ Name string

+ func (g GeoUnit) GetRaw() []byte

+ type ListOption struct

+ Name string

+ func (l ListOption) GetRaw() []byte

+ type MultiKeyCommands interface

+ Bitop func(op BitOP, destKey string, srcKeys ...string) (int64, error)

+ Blpop func(args ...string) ([]string, error)

+ BlpopTimout func(timeout int, keys ...string) ([]string, error)

+ Brpop func(args ...string) ([]string, error)

+ BrpopTimout func(timeout int, keys ...string) ([]string, error)

+ Brpoplpush func(source, destination string, timeout int) (string, error)

+ Del func(keys ...string) (int64, error)

+ Exists func(keys ...string) (int64, error)

+ Keys func(pattern string) ([]string, error)

+ Mget func(keys ...string) ([]string, error)

+ Mset func(keysvalues ...string) (string, error)

+ Msetnx func(keysvalues ...string) (int64, error)

+ Pfcount func(keys ...string) (int64, error)

+ Pfmerge func(destkey string, sourcekeys ...string) (string, error)

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

+ Publish func(channel, message string) (int64, error)

+ RandomKey func() (string, error)

+ Rename func(oldkey, newkey string) (string, error)

+ Renamenx func(oldkey, newkey string) (int64, error)

+ Rpoplpush func(srckey, dstkey string) (string, error)

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

+ Sdiff func(keys ...string) ([]string, error)

+ Sdiffstore func(dstkey string, keys ...string) (int64, error)

+ Sinter func(keys ...string) ([]string, error)

+ Sinterstore func(dstkey string, keys ...string) (int64, error)

+ Smove func(srckey, dstkey, member string) (int64, error)

+ SortMulti func(key string, dstkey string, sortingParameters ...SortingParams) (int64, error)

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

+ Sunion func(keys ...string) ([]string, error)

+ Sunionstore func(dstkey string, keys ...string) (int64, error)

+ Unwatch func() (string, error)

+ Watch func(keys ...string) (string, error)

+ Zinterstore func(dstkey string, sets ...string) (int64, error)

+ ZinterstoreWithParams func(dstkey string, params ZParams, sets ...string) (int64, error)

+ Zunionstore func(dstkey string, sets ...string) (int64, error)

+ ZunionstoreWithParams func(dstkey string, params ZParams, sets ...string) (int64, error)

+ type MultiKeyCommandsPipeline interface

+ Bitop func(op BitOP, destKey string, srcKeys ...string) (*Response, error)

+ Blpop func(args ...string) (*Response, error)

+ BlpopTimout func(timeout int, keys ...string) (*Response, error)

+ Brpop func(args ...string) (*Response, error)

+ BrpopTimout func(timeout int, keys ...string) (*Response, error)

+ Brpoplpush func(source, destination string, timeout int) (*Response, error)

+ Del func(keys ...string) (*Response, error)

+ Exists func(keys ...string) (*Response, error)

+ Keys func(pattern string) (*Response, error)

+ Mget func(keys ...string) (*Response, error)

+ Mset func(keysvalues ...string) (*Response, error)

+ Msetnx func(keysvalues ...string) (*Response, error)

+ Pfcount func(keys ...string) (*Response, error)

+ Pfmerge func(destkey string, sourcekeys ...string) (*Response, error)

+ Publish func(channel, message string) (*Response, error)

+ RandomKey func() (*Response, error)

+ Rename func(oldkey, newkey string) (*Response, error)

+ Renamenx func(oldkey, newkey string) (*Response, error)

+ Rpoplpush func(srckey, dstkey string) (*Response, error)

+ Scan func(cursor string, params ...ScanParams) (*Response, error)

+ Sdiff func(keys ...string) (*Response, error)

+ Sdiffstore func(dstkey string, keys ...string) (*Response, error)

+ Sinter func(keys ...string) (*Response, error)

+ Sinterstore func(dstkey string, keys ...string) (*Response, error)

+ Smove func(srckey, dstkey, member string) (*Response, error)

+ SortMulti func(key string, dstkey string, sortingParameters ...SortingParams) (*Response, error)

+ Sunion func(keys ...string) (*Response, error)

+ Sunionstore func(dstkey string, keys ...string) (*Response, error)

+ Unwatch func() (*Response, error)

+ Watch func(keys ...string) (*Response, error)

+ Zinterstore func(dstkey string, sets ...string) (*Response, error)

+ ZinterstoreWithParams func(dstkey string, params ZParams, sets ...string) (*Response, error)

+ Zunionstore func(dstkey string, sets ...string) (*Response, error)

+ ZunionstoreWithParams func(dstkey string, params ZParams, sets ...string) (*Response, error)

+ type MultiKeyPipelineBase struct

+ func NewMultiKeyPipelineBase(client *Client) *MultiKeyPipelineBase

+ func (p *MultiKeyPipelineBase) Bgrewriteaof() (*Response, error)

+ func (p *MultiKeyPipelineBase) Bgsave() (*Response, error)

+ func (p *MultiKeyPipelineBase) ConfigGet(pattern string) (*Response, error)

+ func (p *MultiKeyPipelineBase) ConfigResetStat() (*Response, error)

+ func (p *MultiKeyPipelineBase) ConfigSet(parameter, value string) (*Response, error)

+ func (p *MultiKeyPipelineBase) DbSize() (*Response, error)

+ func (p *MultiKeyPipelineBase) FlushAll() (*Response, error)

+ func (p *MultiKeyPipelineBase) FlushDB() (*Response, error)

+ func (p *MultiKeyPipelineBase) Info() (*Response, error)

+ func (p *MultiKeyPipelineBase) Lastsave() (*Response, error)

+ func (p *MultiKeyPipelineBase) Ping() (*Response, error)

+ func (p *MultiKeyPipelineBase) Save() (*Response, error)

+ func (p *MultiKeyPipelineBase) Select(index int) (*Response, error)

+ func (p *MultiKeyPipelineBase) Shutdown() (*Response, error)

+ func (p *MultiKeyPipelineBase) Time() (*Response, error)

+ type Pipeline struct

+ func NewPipeline(client *Client) *Pipeline

+ func (p *Pipeline) Sync() error

+ type Pool struct

+ func NewPool(config PoolConfig, factory *Factory) *Pool

+ func (p *Pool) Destroy()

+ func (p *Pool) GetResource() (*Redis, error)

+ type PoolConfig struct

+ MaxIdle *int

+ MaxTotal *int

+ MinEvictableIdleTime *time.Duration

+ MinIdle *int

+ TestOnBorrow *bool

+ type Protocol struct

+ func NewProtocol(os *RedisOutputStream, is *RedisInputStream) *Protocol

+ type ProtocolCommand interface

+ GetRaw func() []byte

+ type Queable struct

+ func NewQueable() *Queable

+ type Redis struct

+ Client *Client

+ func NewRedis(shardInfo ShardInfo) *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) 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) 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) 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 struct

+ ConnectionHandler *RedisClusterConnectionHandler

+ MaxAttempts int

+ func NewRedisCluster(nodes []string, connectionTimeout, soTimeout, maxAttempts int, password string, ...) *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 RedisClusterCommand struct

+ ConnectionHandler *RedisClusterConnectionHandler

+ MaxAttempts int

+ func NewRedisClusterCommand(maxAttempts int, connectionHandler *RedisClusterConnectionHandler) *RedisClusterCommand

+ type RedisClusterConnectionHandler struct

+ func NewRedisClusterConnectionHandler(nodes []string, connectionTimeout, soTimeout int, password string, ...) *RedisClusterConnectionHandler

+ type RedisClusterHashTagUtil struct

+ func NewRedisClusterHashTagUtil() *RedisClusterHashTagUtil

+ type RedisClusterInfoCache struct

+ func NewRedisClusterInfoCache(connectionTimeout, soTimeout int, password string, poolConfig PoolConfig) *RedisClusterInfoCache

+ type RedisCommands interface

+ Append func(key, value string) (int64, error)

+ Bitcount func(key string) (int64, error)

+ BitcountRange func(key string, start int64, end int64) (int64, error)

+ Bitfield func(key string, arguments ...string) ([]int64, error)

+ Bitpos func(key string, value bool, params ...BitPosParams) (int64, error)

+ Decr func(key string) (int64, error)

+ DecrBy func(key string, decrement int64) (int64, error)

+ Echo func(str string) (string, error)

+ Expire func(key string, seconds int) (int64, error)

+ ExpireAt func(key string, unixtime int64) (int64, error)

+ Geoadd func(key string, longitude, latitude float64, member string) (int64, error)

+ GeoaddByMap func(key string, memberCoordinateMap map[string]GeoCoordinate) (int64, error)

+ Geodist func(key string, member1, member2 string, unit ...GeoUnit) (float64, error)

+ Geohash func(key string, members ...string) ([]string, error)

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

+ Georadius func(key string, longitude, latitude, radius float64, unit GeoUnit, ...) ([]*GeoCoordinate, error)

+ GeoradiusByMember func(key string, member string, radius float64, unit GeoUnit, ...) ([]*GeoCoordinate, error)

+ Get func(key string) (string, error)

+ GetSet func(key, value string) (string, error)

+ Getbit func(key string, offset int64) (bool, error)

+ Getrange func(key string, startOffset, endOffset int64) (string, error)

+ Hdel func(key string, fields ...string) (int64, error)

+ Hexists func(key, field string) (bool, error)

+ Hget func(key, field string) (string, error)

+ HgetAll func(key string) (map[string]string, error)

+ HincrBy func(key, field string, value int64) (int64, error)

+ HincrByFloat func(key, field string, value float64) (float64, error)

+ Hkeys func(key string) ([]string, error)

+ Hlen func(key string) (int64, error)

+ Hmget func(key string, fields ...string) ([]string, error)

+ Hmset func(key string, hash map[string]string) (string, error)

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

+ Hset func(key, field string, value string) (int64, error)

+ Hsetnx func(key, field, value string) (int64, error)

+ Hvals func(key string) ([]string, error)

+ Incr func(key string) (int64, error)

+ IncrBy func(key string, increment int64) (int64, error)

+ IncrByFloat func(key string, increment float64) (float64, error)

+ Lindex func(key string, index int64) (string, error)

+ Linsert func(key string, where ListOption, pivot, value string) (int64, error)

+ Llen func(key string) (int64, error)

+ Lpop func(key string) (string, error)

+ Lpush func(key string, strings ...string) (int64, error)

+ Lpushx func(key string, String ...string) (int64, error)

+ Lrange func(key string, start, stop int64) ([]string, error)

+ Lrem func(key string, count int64, value string) (int64, error)

+ Lset func(key string, index int64, value string) (string, error)

+ Ltrim func(key string, start, stop int64) (string, error)

+ Move func(key string, dbIndex int) (int64, error)

+ Persist func(key string) (int64, error)

+ Pexpire func(key string, milliseconds int64) (int64, error)

+ PexpireAt func(key string, millisecondsTimestamp int64) (int64, error)

+ Pfadd func(key string, elements ...string) (int64, error)

+ Psetex func(key string, milliseconds int64, value string) (string, error)

+ Pttl func(key string) (int64, error)

+ Rpop func(key string) (string, error)

+ Rpush func(key string, strings ...string) (int64, error)

+ Rpushx func(key string, String ...string) (int64, error)

+ Sadd func(key string, members ...string) (int64, error)

+ Scard func(key string) (int64, error)

+ Set func(key, value string) (string, error)

+ SetWithParams func(key, value, nxxx string) (string, error)

+ SetWithParamsAndTime func(key, value, nxxx, expx string, time int64) (string, error)

+ Setbit func(key string, offset int64, value string) (bool, error)

+ SetbitWithBool func(key string, offset int64, value bool) (bool, error)

+ Setex func(key string, seconds int, value string) (string, error)

+ Setnx func(key, value string) (int64, error)

+ Setrange func(key string, offset int64, value string) (int64, error)

+ Sismember func(key string, member string) (bool, error)

+ Smembers func(key string) ([]string, error)

+ Sort func(key string, sortingParameters ...SortingParams) ([]string, error)

+ Spop func(key string) (string, error)

+ SpopBatch func(key string, count int64) ([]string, error)

+ Srandmember func(key string) (string, error)

+ SrandmemberBatch func(key string, count int) ([]string, error)

+ Srem func(key string, members ...string) (int64, error)

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

+ Strlen func(key string) (int64, error)

+ Substr func(key string, start, end int) (string, error)

+ Ttl func(key string) (int64, error)

+ Type func(key string) (string, error)

+ Zadd func(key string, score float64, member string, params ...ZAddParams) (int64, error)

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

+ Zcard func(key string) (int64, error)

+ Zcount func(key string, min string, max string) (int64, error)

+ Zincrby func(key string, score float64, member string, params ...ZAddParams) (float64, error)

+ Zlexcount func(key, min, max string) (int64, error)

+ Zrange func(key string, start, end int64) ([]string, error)

+ ZrangeByLex func(key, min, max string) ([]string, error)

+ ZrangeByLexBatch func(key, min, max string, offset, count int) ([]string, error)

+ ZrangeByScore func(key string, min string, max string) ([]string, error)

+ ZrangeByScoreBatch func(key string, min string, max string, offset int, count int) ([]string, error)

+ ZrangeByScoreWithScores func(key, min, max string) ([]Tuple, error)

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

+ ZrangeWithScores func(key string, start, end int64) ([]Tuple, error)

+ Zrank func(key, member string) (int64, error)

+ Zrem func(key string, member ...string) (int64, error)

+ ZremrangeByLex func(key, min, max string) (int64, error)

+ ZremrangeByRank func(key string, start, end int64) (int64, error)

+ ZremrangeByScore func(key, start, end string) (int64, error)

+ Zrevrange func(key string, start, end int64) ([]string, error)

+ ZrevrangeByLex func(key, max, min string) ([]string, error)

+ ZrevrangeByLexBatch func(key, max, min string, offset, count int) ([]string, error)

+ ZrevrangeByScore func(key string, max string, min string) ([]string, error)

+ ZrevrangeByScoreWithScores func(key, max, min string) ([]Tuple, error)

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

+ ZrevrangeWithScores func(key string, start, end int64) ([]Tuple, error)

+ Zrevrank func(key, member string) (int64, error)

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

+ Zscore func(key, member string) (float64, error)

+ type RedisInputStream struct

+ func NewRedisInputStream(br *bufio.Reader) *RedisInputStream

+ type RedisOutputStream struct

+ func NewRedisOutputStream(bw *bufio.Writer) *RedisOutputStream

+ type RedisPipeline interface

+ Append func(key, value string) (*Response, error)

+ Bitcount func(key string) (*Response, error)

+ BitcountRange func(key string, start int64, end int64) (*Response, error)

+ Bitfield func(key string, arguments ...string) (*Response, error)

+ Bitpos func(key string, value bool, params ...BitPosParams) (*Response, error)

+ Decr func(key string) (*Response, error)

+ DecrBy func(key string, decrement int64) (*Response, error)

+ Echo func(str string) (*Response, error)

+ Expire func(key string, seconds int) (*Response, error)

+ ExpireAt func(key string, unixtime int64) (*Response, error)

+ Geoadd func(key string, longitude, latitude float64, member string) (*Response, error)

+ GeoaddByMap func(key string, memberCoordinateMap map[string]GeoCoordinate) (*Response, error)

+ Geodist func(key string, member1, member2 string, unit ...GeoUnit) (*Response, error)

+ Geohash func(key string, members ...string) (*Response, error)

+ Geopos func(key string, members ...string) (*Response, error)

+ Georadius func(key string, longitude, latitude, radius float64, unit GeoUnit, ...) (*Response, error)

+ GeoradiusByMember func(key string, member string, radius float64, unit GeoUnit, ...) (*Response, error)

+ Get func(key string) (*Response, error)

+ GetSet func(key, value string) (*Response, error)

+ Getbit func(key string, offset int64) (*Response, error)

+ Getrange func(key string, startOffset, endOffset int64) (*Response, error)

+ Hdel func(key string, fields ...string) (*Response, error)

+ Hexists func(key, field string) (*Response, error)

+ Hget func(key, field string) (*Response, error)

+ HgetAll func(key string) (*Response, error)

+ HincrBy func(key, field string, value int64) (*Response, error)

+ HincrByFloat func(key, field string, value float64) (*Response, error)

+ Hkeys func(key string) (*Response, error)

+ Hlen func(key string) (*Response, error)

+ Hmget func(key string, fields ...string) (*Response, error)

+ Hmset func(key string, hash map[string]string) (*Response, error)

+ Hscan func(key, cursor string, params ...ScanParams) (*Response, error)

+ Hset func(key, field string, value string) (*Response, error)

+ Hsetnx func(key, field, value string) (*Response, error)

+ Hvals func(key string) (*Response, error)

+ Incr func(key string) (*Response, error)

+ IncrBy func(key string, increment int64) (*Response, error)

+ IncrByFloat func(key string, increment float64) (*Response, error)

+ Lindex func(key string, index int64) (*Response, error)

+ Linsert func(key string, where ListOption, pivot, value string) (*Response, error)

+ Llen func(key string) (*Response, error)

+ Lpop func(key string) (*Response, error)

+ Lpush func(key string, strings ...string) (*Response, error)

+ Lpushx func(key string, String ...string) (*Response, error)

+ Lrange func(key string, start, stop int64) (*Response, error)

+ Lrem func(key string, count int64, value string) (*Response, error)

+ Lset func(key string, index int64, value string) (*Response, error)

+ Ltrim func(key string, start, stop int64) (*Response, error)

+ Move func(key string, dbIndex int) (*Response, error)

+ Persist func(key string) (*Response, error)

+ Pexpire func(key string, milliseconds int64) (*Response, error)

+ PexpireAt func(key string, millisecondsTimestamp int64) (*Response, error)

+ Pfadd func(key string, elements ...string) (*Response, error)

+ Psetex func(key string, milliseconds int64, value string) (*Response, error)

+ Pttl func(key string) (*Response, error)

+ Rpop func(key string) (*Response, error)

+ Rpush func(key string, strings ...string) (*Response, error)

+ Rpushx func(key string, String ...string) (*Response, error)

+ Sadd func(key string, members ...string) (*Response, error)

+ Scard func(key string) (*Response, error)

+ Set func(key, value string) (*Response, error)

+ SetWithParams func(key, value, nxxx string) (*Response, error)

+ SetWithParamsAndTime func(key, value, nxxx, expx string, time int64) (*Response, error)

+ Setbit func(key string, offset int64, value string) (*Response, error)

+ SetbitWithBool func(key string, offset int64, value bool) (*Response, error)

+ Setex func(key string, seconds int, value string) (*Response, error)

+ Setnx func(key, value string) (*Response, error)

+ Setrange func(key string, offset int64, value string) (*Response, error)

+ Sismember func(key string, member string) (*Response, error)

+ Smembers func(key string) (*Response, error)

+ Sort func(key string, sortingParameters ...SortingParams) (*Response, error)

+ Spop func(key string) (*Response, error)

+ SpopBatch func(key string, count int64) (*Response, error)

+ Srandmember func(key string) (*Response, error)

+ SrandmemberBatch func(key string, count int) (*Response, error)

+ Srem func(key string, members ...string) (*Response, error)

+ Sscan func(key, cursor string, params ...ScanParams) (*Response, error)

+ Strlen func(key string) (*Response, error)

+ Substr func(key string, start, end int) (*Response, error)

+ Ttl func(key string) (*Response, error)

+ Type func(key string) (*Response, error)

+ Zadd func(key string, score float64, member string, params ...ZAddParams) (*Response, error)

+ ZaddByMap func(key string, scoreMembers map[string]float64, params ...ZAddParams) (*Response, error)

+ Zcard func(key string) (*Response, error)

+ Zcount func(key string, min string, max string) (*Response, error)

+ Zincrby func(key string, score float64, member string, params ...ZAddParams) (*Response, error)

+ Zlexcount func(key, min, max string) (*Response, error)

+ Zrange func(key string, start, end int64) (*Response, error)

+ ZrangeByLex func(key, min, max string) (*Response, error)

+ ZrangeByLexBatch func(key, min, max string, offset, count int) (*Response, error)

+ ZrangeByScore func(key string, min string, max string) (*Response, error)

+ ZrangeByScoreBatch func(key string, min string, max string, offset int, count int) (*Response, error)

+ ZrangeByScoreWithScores func(key, min, max string) (*Response, error)

+ ZrangeByScoreWithScoresBatch func(key, min, max string, offset, count int) (*Response, error)

+ ZrangeWithScores func(key string, start, end int64) (*Response, error)

+ Zrank func(key, member string) (*Response, error)

+ Zrem func(key string, member ...string) (*Response, error)

+ ZremrangeByLex func(key, min, max string) (*Response, error)

+ ZremrangeByRank func(key string, start, end int64) (*Response, error)

+ ZremrangeByScore func(key, start, end string) (*Response, error)

+ Zrevrange func(key string, start, end int64) (*Response, error)

+ ZrevrangeByLex func(key, max, min string) (*Response, error)

+ ZrevrangeByLexBatch func(key, max, min string, offset, count int) (*Response, error)

+ ZrevrangeByScore func(key string, max string, min string) (*Response, error)

+ ZrevrangeByScoreWithScores func(key, max, min string) (*Response, error)

+ ZrevrangeByScoreWithScoresBatch func(key, max, min string, offset, count int) (*Response, error)

+ ZrevrangeWithScores func(key string, start, end int64) (*Response, error)

+ Zrevrank func(key, member string) (*Response, error)

+ Zscan func(key, cursor string, params ...ScanParams) (*Response, error)

+ Zscore func(key, member string) (*Response, error)

+ type RedisPubSub struct

+ OnMessage func(channel, message string)

+ OnPMessage func(pattern string, channel, message string)

+ OnPSubscribe func(pattern string, subscribedChannels int)

+ OnPUnsubscribe func(pattern string, subscribedChannels int)

+ OnPong func(channel string)

+ OnSubscribe func(channel string, subscribedChannels int)

+ OnUnsubscribe func(channel string, subscribedChannels int)

+ Redis *Redis

+ 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 struct

+ Name string

+ func (g Reset) GetRaw() []byte

+ type Response struct

+ func NewResponse() *Response

+ func (r *Response) Get() (interface{}, error)

+ func (r *Response) Set(data interface{})

+ type ScanParams struct

+ func NewScanParams() *ScanParams

+ type ScanResult struct

+ Cursor string

+ Results []string

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

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

+ type ScriptingCommands interface

+ Eval func(script string, keyCount int, params ...string) (interface{}, error)

+ Evalsha func(sha1 string, keyCount int, params ...string) (interface{}, error)

+ ScriptExists func(sha1 ...string) ([]bool, error)

+ ScriptLoad func(script string) (string, error)

+ type ScriptingCommandsPipeline interface

+ Eval func(script string, keyCount int, params ...string) (*Response, error)

+ Evalsha func(sha1 string, keyCount int, params ...string) (*Response, error)

+ type SentinelCommands interface

+ SentinelFailover func(masterName string) (string, error)

+ SentinelGetMasterAddrByName func(masterName string) ([]string, error)

+ SentinelMasters func() ([]map[string]string, error)

+ SentinelMonitor func(masterName, ip string, port, quorum int) (string, error)

+ SentinelRemove func(masterName string) (string, error)

+ SentinelReset func(pattern string) (int64, error)

+ SentinelSet func(masterName string, parameterMap map[string]string) (string, error)

+ SentinelSlaves func(masterName string) ([]map[string]string, error)

+ type ShardInfo struct

+ ConnectionTimeout int

+ Db int

+ Host string

+ IsInMulti bool

+ IsInWatch bool

+ Password string

+ Port int

+ SoTimeout int

+ Ssl bool

+ type Slowlog struct

+ type SortingParams struct

+ type Transaction struct

+ func NewTransaction(client *Client) *Transaction

+ func (t *Transaction) Clear() (string, error)

+ func (t *Transaction) Discard() (string, error)

+ func (t *Transaction) Exec() ([]interface{}, error)

+ func (t *Transaction) ExecGetResponse() ([]*Response, error)

+ type Tuple struct

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

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

+ type ZAddParams struct

+ CH bool

+ NX bool

+ XX bool

+ type ZParams struct

+ Name string

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

+ func (g ZParams) GetRaw() []byte

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL