mirror
/
redis
mirror of https://github.com/go-redis/redis.git
1
0
Fork 1
Code Issues Packages Projects Releases Wiki Activity
redis/commands.go

2650 lines
76 KiB
Go
Raw Normal View History

Initial commit.
2012-07-25 17:00:50 +04:00
package redis
import (
Add ctx as first arg
2020-03-11 17:26:42 +03:00
"context"
Fix proto.RedisError in slices
2018-02-22 15:14:30 +03:00
"errors"
Fix rate limiter and add test.
2014-11-13 15:26:14 +03:00
"io"
all: switch to gopkg.in.
2014-05-11 11:42:40 +04:00
"time"
Move logger to internal package.
2016-04-09 14:52:01 +03:00
Bump major version
2020-03-11 17:29:16 +03:00
"github.com/go-redis/redis/v8/internal"
Initial commit.
2012-07-25 17:00:50 +04:00
)
Refactor Set, SetNX and SetXX with expiration.
2015-01-31 12:08:56 +03:00
func usePrecise(dur time.Duration) bool {
return dur < time.Second || dur%time.Second != 0
}
Remove manual strconv
2017-03-24 13:48:32 +03:00
func formatMs(dur time.Duration) int64 {
Use time.Duration to specify timeout.
2015-04-07 12:42:16 +03:00
if dur > 0 && dur < time.Millisecond {
Cleanup
2019-06-17 12:32:40 +03:00
internal.Logger.Printf(
Add prefix to package logger.
2016-02-06 13:16:09 +03:00
"specified duration is %s, but minimal supported value is %s",
Use time.Duration to specify timeout.
2015-04-07 12:42:16 +03:00
dur, time.Millisecond,
)
}
Remove manual strconv
2017-03-24 13:48:32 +03:00
return int64(dur / time.Millisecond)
Refactor Set, SetNX and SetXX with expiration.
2015-01-31 12:08:56 +03:00
}
Remove manual strconv
2017-03-24 13:48:32 +03:00
func formatSec(dur time.Duration) int64 {
Use time.Duration to specify timeout.
2015-04-07 12:42:16 +03:00
if dur > 0 && dur < time.Second {
Cleanup
2019-06-17 12:32:40 +03:00
internal.Logger.Printf(
Add prefix to package logger.
2016-02-06 13:16:09 +03:00
"specified duration is %s, but minimal supported value is %s",
Use time.Duration to specify timeout.
2015-04-07 12:42:16 +03:00
dur, time.Second,
)
}
Remove manual strconv
2017-03-24 13:48:32 +03:00
return int64(dur / time.Second)
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
}
Support []string slices in commands that accept multiple values
2018-03-08 15:30:27 +03:00
func appendArgs(dst, src []interface{}) []interface{} {
if len(src) == 1 {
Use HSET for HMSet
2019-12-18 11:52:49 +03:00
switch v := src[0].(type) {
case []string:
for _, s := range v {
Support []string slices in commands that accept multiple values
2018-03-08 15:30:27 +03:00
dst = append(dst, s)
}
return dst
Use HSET for HMSet
2019-12-18 11:52:49 +03:00
case map[string]interface{}:
for k, v := range v {
dst = append(dst, k, v)
}
return dst
Support []string slices in commands that accept multiple values
2018-03-08 15:30:27 +03:00
}
}
Propagate context in Pipeline
2019-07-25 13:28:15 +03:00
dst = append(dst, src...)
Support []string slices in commands that accept multiple values
2018-03-08 15:30:27 +03:00
return dst
}
Rename Commander to Cmdable to match internal name.
2016-07-21 16:24:58 +03:00
type Cmdable interface {
rename Pipelineable to Pipeliner
2017-05-02 18:00:53 +03:00
Pipeline() Pipeliner
Add ctx as first arg
2020-03-11 17:26:42 +03:00
Pipelined(ctx context.Context, fn func(Pipeliner) error) ([]Cmder, error)
Add Pipeline to Cmdable.
2016-09-27 12:24:14 +03:00
Add ctx as first arg
2020-03-11 17:26:42 +03:00
TxPipelined(ctx context.Context, fn func(Pipeliner) error) ([]Cmder, error)
Add TxPipeline to Cmdable
2017-09-25 11:48:44 +03:00
TxPipeline() Pipeliner
Add ctx as first arg
2020-03-11 17:26:42 +03:00
Command(ctx context.Context) *CommandsInfoCmd
ClientGetName(ctx context.Context) *StringCmd
Echo(ctx context.Context, message interface{}) *StringCmd
Ping(ctx context.Context) *StatusCmd
Quit(ctx context.Context) *StatusCmd
Del(ctx context.Context, keys ...string) *IntCmd
Unlink(ctx context.Context, keys ...string) *IntCmd
Dump(ctx context.Context, key string) *StringCmd
Exists(ctx context.Context, keys ...string) *IntCmd
Expire(ctx context.Context, key string, expiration time.Duration) *BoolCmd
ExpireAt(ctx context.Context, key string, tm time.Time) *BoolCmd
Keys(ctx context.Context, pattern string) *StringSliceCmd
Migrate(ctx context.Context, host, port, key string, db int, timeout time.Duration) *StatusCmd
Move(ctx context.Context, key string, db int) *BoolCmd
ObjectRefCount(ctx context.Context, key string) *IntCmd
ObjectEncoding(ctx context.Context, key string) *StringCmd
ObjectIdleTime(ctx context.Context, key string) *DurationCmd
Persist(ctx context.Context, key string) *BoolCmd
PExpire(ctx context.Context, key string, expiration time.Duration) *BoolCmd
PExpireAt(ctx context.Context, key string, tm time.Time) *BoolCmd
PTTL(ctx context.Context, key string) *DurationCmd
RandomKey(ctx context.Context) *StringCmd
Rename(ctx context.Context, key, newkey string) *StatusCmd
RenameNX(ctx context.Context, key, newkey string) *BoolCmd
Restore(ctx context.Context, key string, ttl time.Duration, value string) *StatusCmd
RestoreReplace(ctx context.Context, key string, ttl time.Duration, value string) *StatusCmd
Sort(ctx context.Context, key string, sort *Sort) *StringSliceCmd
SortStore(ctx context.Context, key, store string, sort *Sort) *IntCmd
SortInterfaces(ctx context.Context, key string, sort *Sort) *SliceCmd
Touch(ctx context.Context, keys ...string) *IntCmd
TTL(ctx context.Context, key string) *DurationCmd
Type(ctx context.Context, key string) *StatusCmd
Append(ctx context.Context, key, value string) *IntCmd
Decr(ctx context.Context, key string) *IntCmd
DecrBy(ctx context.Context, key string, decrement int64) *IntCmd
Get(ctx context.Context, key string) *StringCmd
GetRange(ctx context.Context, key string, start, end int64) *StringCmd
GetSet(ctx context.Context, key string, value interface{}) *StringCmd
Incr(ctx context.Context, key string) *IntCmd
IncrBy(ctx context.Context, key string, value int64) *IntCmd
IncrByFloat(ctx context.Context, key string, value float64) *FloatCmd
MGet(ctx context.Context, keys ...string) *SliceCmd
MSet(ctx context.Context, values ...interface{}) *StatusCmd
MSetNX(ctx context.Context, values ...interface{}) *BoolCmd
Set(ctx context.Context, key string, value interface{}, expiration time.Duration) *StatusCmd
SetNX(ctx context.Context, key string, value interface{}, expiration time.Duration) *BoolCmd
SetXX(ctx context.Context, key string, value interface{}, expiration time.Duration) *BoolCmd
SetRange(ctx context.Context, key string, offset int64, value string) *IntCmd
StrLen(ctx context.Context, key string) *IntCmd
GetBit(ctx context.Context, key string, offset int64) *IntCmd
SetBit(ctx context.Context, key string, offset int64, value int) *IntCmd
BitCount(ctx context.Context, key string, bitCount *BitCount) *IntCmd
BitOpAnd(ctx context.Context, destKey string, keys ...string) *IntCmd
BitOpOr(ctx context.Context, destKey string, keys ...string) *IntCmd
BitOpXor(ctx context.Context, destKey string, keys ...string) *IntCmd
BitOpNot(ctx context.Context, destKey string, key string) *IntCmd
BitPos(ctx context.Context, key string, bit int64, pos ...int64) *IntCmd
BitField(ctx context.Context, key string, args ...interface{}) *IntSliceCmd
Scan(ctx context.Context, cursor uint64, match string, count int64) *ScanCmd
SScan(ctx context.Context, key string, cursor uint64, match string, count int64) *ScanCmd
HScan(ctx context.Context, key string, cursor uint64, match string, count int64) *ScanCmd
ZScan(ctx context.Context, key string, cursor uint64, match string, count int64) *ScanCmd
HDel(ctx context.Context, key string, fields ...string) *IntCmd
HExists(ctx context.Context, key, field string) *BoolCmd
HGet(ctx context.Context, key, field string) *StringCmd
HGetAll(ctx context.Context, key string) *StringStringMapCmd
HIncrBy(ctx context.Context, key, field string, incr int64) *IntCmd
HIncrByFloat(ctx context.Context, key, field string, incr float64) *FloatCmd
HKeys(ctx context.Context, key string) *StringSliceCmd
HLen(ctx context.Context, key string) *IntCmd
HMGet(ctx context.Context, key string, fields ...string) *SliceCmd
HSet(ctx context.Context, key string, values ...interface{}) *IntCmd
HMSet(ctx context.Context, key string, values ...interface{}) *BoolCmd
HSetNX(ctx context.Context, key, field string, value interface{}) *BoolCmd
HVals(ctx context.Context, key string) *StringSliceCmd
BLPop(ctx context.Context, timeout time.Duration, keys ...string) *StringSliceCmd
BRPop(ctx context.Context, timeout time.Duration, keys ...string) *StringSliceCmd
BRPopLPush(ctx context.Context, source, destination string, timeout time.Duration) *StringCmd
LIndex(ctx context.Context, key string, index int64) *StringCmd
LInsert(ctx context.Context, key, op string, pivot, value interface{}) *IntCmd
LInsertBefore(ctx context.Context, key string, pivot, value interface{}) *IntCmd
LInsertAfter(ctx context.Context, key string, pivot, value interface{}) *IntCmd
LLen(ctx context.Context, key string) *IntCmd
LPop(ctx context.Context, key string) *StringCmd
LPush(ctx context.Context, key string, values ...interface{}) *IntCmd
LPushX(ctx context.Context, key string, values ...interface{}) *IntCmd
LRange(ctx context.Context, key string, start, stop int64) *StringSliceCmd
LRem(ctx context.Context, key string, count int64, value interface{}) *IntCmd
LSet(ctx context.Context, key string, index int64, value interface{}) *StatusCmd
LTrim(ctx context.Context, key string, start, stop int64) *StatusCmd
RPop(ctx context.Context, key string) *StringCmd
RPopLPush(ctx context.Context, source, destination string) *StringCmd
RPush(ctx context.Context, key string, values ...interface{}) *IntCmd
RPushX(ctx context.Context, key string, values ...interface{}) *IntCmd
SAdd(ctx context.Context, key string, members ...interface{}) *IntCmd
SCard(ctx context.Context, key string) *IntCmd
SDiff(ctx context.Context, keys ...string) *StringSliceCmd
SDiffStore(ctx context.Context, destination string, keys ...string) *IntCmd
SInter(ctx context.Context, keys ...string) *StringSliceCmd
SInterStore(ctx context.Context, destination string, keys ...string) *IntCmd
SIsMember(ctx context.Context, key string, member interface{}) *BoolCmd
SMembers(ctx context.Context, key string) *StringSliceCmd
SMembersMap(ctx context.Context, key string) *StringStructMapCmd
SMove(ctx context.Context, source, destination string, member interface{}) *BoolCmd
SPop(ctx context.Context, key string) *StringCmd
SPopN(ctx context.Context, key string, count int64) *StringSliceCmd
SRandMember(ctx context.Context, key string) *StringCmd
SRandMemberN(ctx context.Context, key string, count int64) *StringSliceCmd
SRem(ctx context.Context, key string, members ...interface{}) *IntCmd
SUnion(ctx context.Context, keys ...string) *StringSliceCmd
SUnionStore(ctx context.Context, destination string, keys ...string) *IntCmd
XAdd(ctx context.Context, a *XAddArgs) *StringCmd
XDel(ctx context.Context, stream string, ids ...string) *IntCmd
XLen(ctx context.Context, stream string) *IntCmd
XRange(ctx context.Context, stream, start, stop string) *XMessageSliceCmd
XRangeN(ctx context.Context, stream, start, stop string, count int64) *XMessageSliceCmd
XRevRange(ctx context.Context, stream string, start, stop string) *XMessageSliceCmd
XRevRangeN(ctx context.Context, stream string, start, stop string, count int64) *XMessageSliceCmd
XRead(ctx context.Context, a *XReadArgs) *XStreamSliceCmd
XReadStreams(ctx context.Context, streams ...string) *XStreamSliceCmd
XGroupCreate(ctx context.Context, stream, group, start string) *StatusCmd
XGroupCreateMkStream(ctx context.Context, stream, group, start string) *StatusCmd
XGroupSetID(ctx context.Context, stream, group, start string) *StatusCmd
XGroupDestroy(ctx context.Context, stream, group string) *IntCmd
XGroupDelConsumer(ctx context.Context, stream, group, consumer string) *IntCmd
XReadGroup(ctx context.Context, a *XReadGroupArgs) *XStreamSliceCmd
XAck(ctx context.Context, stream, group string, ids ...string) *IntCmd
XPending(ctx context.Context, stream, group string) *XPendingCmd
XPendingExt(ctx context.Context, a *XPendingExtArgs) *XPendingExtCmd
XClaim(ctx context.Context, a *XClaimArgs) *XMessageSliceCmd
XClaimJustID(ctx context.Context, a *XClaimArgs) *StringSliceCmd
XTrim(ctx context.Context, key string, maxLen int64) *IntCmd
XTrimApprox(ctx context.Context, key string, maxLen int64) *IntCmd
XInfoGroups(ctx context.Context, key string) *XInfoGroupsCmd
BZPopMax(ctx context.Context, timeout time.Duration, keys ...string) *ZWithKeyCmd
BZPopMin(ctx context.Context, timeout time.Duration, keys ...string) *ZWithKeyCmd
ZAdd(ctx context.Context, key string, members ...*Z) *IntCmd
ZAddNX(ctx context.Context, key string, members ...*Z) *IntCmd
ZAddXX(ctx context.Context, key string, members ...*Z) *IntCmd
ZAddCh(ctx context.Context, key string, members ...*Z) *IntCmd
ZAddNXCh(ctx context.Context, key string, members ...*Z) *IntCmd
ZAddXXCh(ctx context.Context, key string, members ...*Z) *IntCmd
ZIncr(ctx context.Context, key string, member *Z) *FloatCmd
ZIncrNX(ctx context.Context, key string, member *Z) *FloatCmd
ZIncrXX(ctx context.Context, key string, member *Z) *FloatCmd
ZCard(ctx context.Context, key string) *IntCmd
ZCount(ctx context.Context, key, min, max string) *IntCmd
ZLexCount(ctx context.Context, key, min, max string) *IntCmd
ZIncrBy(ctx context.Context, key string, increment float64, member string) *FloatCmd
ZInterStore(ctx context.Context, destination string, store *ZStore) *IntCmd
ZPopMax(ctx context.Context, key string, count ...int64) *ZSliceCmd
ZPopMin(ctx context.Context, key string, count ...int64) *ZSliceCmd
ZRange(ctx context.Context, key string, start, stop int64) *StringSliceCmd
ZRangeWithScores(ctx context.Context, key string, start, stop int64) *ZSliceCmd
ZRangeByScore(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd
ZRangeByLex(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd
ZRangeByScoreWithScores(ctx context.Context, key string, opt *ZRangeBy) *ZSliceCmd
ZRank(ctx context.Context, key, member string) *IntCmd
ZRem(ctx context.Context, key string, members ...interface{}) *IntCmd
ZRemRangeByRank(ctx context.Context, key string, start, stop int64) *IntCmd
ZRemRangeByScore(ctx context.Context, key, min, max string) *IntCmd
ZRemRangeByLex(ctx context.Context, key, min, max string) *IntCmd
ZRevRange(ctx context.Context, key string, start, stop int64) *StringSliceCmd
ZRevRangeWithScores(ctx context.Context, key string, start, stop int64) *ZSliceCmd
ZRevRangeByScore(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd
ZRevRangeByLex(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd
ZRevRangeByScoreWithScores(ctx context.Context, key string, opt *ZRangeBy) *ZSliceCmd
ZRevRank(ctx context.Context, key, member string) *IntCmd
ZScore(ctx context.Context, key, member string) *FloatCmd
ZUnionStore(ctx context.Context, dest string, store *ZStore) *IntCmd
PFAdd(ctx context.Context, key string, els ...interface{}) *IntCmd
PFCount(ctx context.Context, keys ...string) *IntCmd
PFMerge(ctx context.Context, dest string, keys ...string) *StatusCmd
BgRewriteAOF(ctx context.Context) *StatusCmd
BgSave(ctx context.Context) *StatusCmd
ClientKill(ctx context.Context, ipPort string) *StatusCmd
ClientKillByFilter(ctx context.Context, keys ...string) *IntCmd
ClientList(ctx context.Context) *StringCmd
ClientPause(ctx context.Context, dur time.Duration) *BoolCmd
ClientID(ctx context.Context) *IntCmd
ConfigGet(ctx context.Context, parameter string) *SliceCmd
ConfigResetStat(ctx context.Context) *StatusCmd
ConfigSet(ctx context.Context, parameter, value string) *StatusCmd
ConfigRewrite(ctx context.Context) *StatusCmd
DBSize(ctx context.Context) *IntCmd
FlushAll(ctx context.Context) *StatusCmd
FlushAllAsync(ctx context.Context) *StatusCmd
FlushDB(ctx context.Context) *StatusCmd
FlushDBAsync(ctx context.Context) *StatusCmd
Info(ctx context.Context, section ...string) *StringCmd
LastSave(ctx context.Context) *IntCmd
Save(ctx context.Context) *StatusCmd
Shutdown(ctx context.Context) *StatusCmd
ShutdownSave(ctx context.Context) *StatusCmd
ShutdownNoSave(ctx context.Context) *StatusCmd
SlaveOf(ctx context.Context, host, port string) *StatusCmd
Time(ctx context.Context) *TimeCmd
DebugObject(ctx context.Context, key string) *StringCmd
ReadOnly(ctx context.Context) *StatusCmd
ReadWrite(ctx context.Context) *StatusCmd
MemoryUsage(ctx context.Context, key string, samples ...int) *IntCmd
Eval(ctx context.Context, script string, keys []string, args ...interface{}) *Cmd
EvalSha(ctx context.Context, sha1 string, keys []string, args ...interface{}) *Cmd
ScriptExists(ctx context.Context, hashes ...string) *BoolSliceCmd
ScriptFlush(ctx context.Context) *StatusCmd
ScriptKill(ctx context.Context) *StatusCmd
ScriptLoad(ctx context.Context, script string) *StringCmd
Publish(ctx context.Context, channel string, message interface{}) *IntCmd
PubSubChannels(ctx context.Context, pattern string) *StringSliceCmd
PubSubNumSub(ctx context.Context, channels ...string) *StringIntMapCmd
PubSubNumPat(ctx context.Context) *IntCmd
ClusterSlots(ctx context.Context) *ClusterSlotsCmd
ClusterNodes(ctx context.Context) *StringCmd
ClusterMeet(ctx context.Context, host, port string) *StatusCmd
ClusterForget(ctx context.Context, nodeID string) *StatusCmd
ClusterReplicate(ctx context.Context, nodeID string) *StatusCmd
ClusterResetSoft(ctx context.Context) *StatusCmd
ClusterResetHard(ctx context.Context) *StatusCmd
ClusterInfo(ctx context.Context) *StringCmd
ClusterKeySlot(ctx context.Context, key string) *IntCmd
ClusterGetKeysInSlot(ctx context.Context, slot int, count int) *StringSliceCmd
ClusterCountFailureReports(ctx context.Context, nodeID string) *IntCmd
ClusterCountKeysInSlot(ctx context.Context, slot int) *IntCmd
ClusterDelSlots(ctx context.Context, slots ...int) *StatusCmd
ClusterDelSlotsRange(ctx context.Context, min, max int) *StatusCmd
ClusterSaveConfig(ctx context.Context) *StatusCmd
ClusterSlaves(ctx context.Context, nodeID string) *StringSliceCmd
ClusterFailover(ctx context.Context) *StatusCmd
ClusterAddSlots(ctx context.Context, slots ...int) *StatusCmd
ClusterAddSlotsRange(ctx context.Context, min, max int) *StatusCmd
GeoAdd(ctx context.Context, key string, geoLocation ...*GeoLocation) *IntCmd
GeoPos(ctx context.Context, key string, members ...string) *GeoPosCmd
GeoRadius(ctx context.Context, key string, longitude, latitude float64, query *GeoRadiusQuery) *GeoLocationCmd
GeoRadiusStore(ctx context.Context, key string, longitude, latitude float64, query *GeoRadiusQuery) *IntCmd
GeoRadiusByMember(ctx context.Context, key, member string, query *GeoRadiusQuery) *GeoLocationCmd
GeoRadiusByMemberStore(ctx context.Context, key, member string, query *GeoRadiusQuery) *IntCmd
GeoDist(ctx context.Context, key string, member1, member2, unit string) *FloatCmd
GeoHash(ctx context.Context, key string, members ...string) *StringSliceCmd
Feature: Export cmdable as an interface
2016-07-21 08:50:28 +03:00
}
pipeline now has its own interface "Pipelineable"
2017-05-01 18:42:58 +03:00
type StatefulCmdable interface {
Embed Cmdable into StatefulCmdable
2017-05-25 13:38:04 +03:00
Cmdable
Add ctx as first arg
2020-03-11 17:26:42 +03:00
Auth(ctx context.Context, password string) *StatusCmd
Select(ctx context.Context, index int) *StatusCmd
SwapDB(ctx context.Context, index1, index2 int) *StatusCmd
ClientSetName(ctx context.Context, name string) *BoolCmd
pipeline now has its own interface "Pipelineable"
2017-05-01 18:42:58 +03:00
}
Check that clients implement scripter interface.
2016-12-14 13:12:50 +03:00
var _ Cmdable = (*Client)(nil)
var _ Cmdable = (*Tx)(nil)
var _ Cmdable = (*Ring)(nil)
var _ Cmdable = (*ClusterClient)(nil)
Add ctx as first arg
2020-03-11 17:26:42 +03:00
type cmdable func(ctx context.Context, cmd Cmder) error
Embed Cmdable into StatefulCmdable
2017-05-25 13:38:04 +03:00
Add ctx as first arg
2020-03-11 17:26:42 +03:00
type statefulCmdable func(ctx context.Context, cmd Cmder) error
Embed Cmdable into StatefulCmdable
2017-05-25 13:38:04 +03:00
Add sorted sets support.
2012-07-27 18:21:50 +04:00
//------------------------------------------------------------------------------
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c statefulCmdable) Auth(ctx context.Context, password string) *StatusCmd {
cmd := NewStatusCmd(ctx, "auth", password)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) Wait(ctx context.Context, numSlaves int, timeout time.Duration) *IntCmd {
cmd := NewIntCmd(ctx, "wait", numSlaves, int(timeout/time.Millisecond))
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c statefulCmdable) Select(ctx context.Context, index int) *StatusCmd {
cmd := NewStatusCmd(ctx, "select", index)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c statefulCmdable) SwapDB(ctx context.Context, index1, index2 int) *StatusCmd {
cmd := NewStatusCmd(ctx, "swapdb", index1, index2)
_ = c(ctx, cmd)
Added implementation for WAIT command Reference: https://redis.io/commands/wait
2017-02-16 19:15:34 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
// ClientSetName assigns a name to the connection.
func (c statefulCmdable) ClientSetName(ctx context.Context, name string) *BoolCmd {
cmd := NewBoolCmd(ctx, "client", "setname", name)
_ = c(ctx, cmd)
return cmd
Update readme.
2012-08-25 16:40:49 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
//------------------------------------------------------------------------------
func (c cmdable) Command(ctx context.Context) *CommandsInfoCmd {
cmd := NewCommandsInfoCmd(ctx, "command")
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
// ClientGetName returns the name of the connection.
func (c cmdable) ClientGetName(ctx context.Context) *StringCmd {
cmd := NewStringCmd(ctx, "client", "getname")
_ = c(ctx, cmd)
add new command Touch and SwapDB
2018-02-14 07:42:19 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) Echo(ctx context.Context, message interface{}) *StringCmd {
cmd := NewStringCmd(ctx, "echo", message)
_ = c(ctx, cmd)
return cmd
}
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) Ping(ctx context.Context) *StatusCmd {
cmd := NewStatusCmd(ctx, "ping")
_ = c(ctx, cmd)
Add MemoryUsage
2018-07-22 09:46:29 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) Quit(ctx context.Context) *StatusCmd {
panic("not implemented")
}
func (c cmdable) Del(ctx context.Context, keys ...string) *IntCmd {
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
args := make([]interface{}, 1+len(keys))
Fix Del command case.
2016-07-08 12:24:02 +03:00
args[0] = "del"
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
for i, key := range keys {
args[1+i] = key
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewIntCmd(ctx, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) Unlink(ctx context.Context, keys ...string) *IntCmd {
Add unlink command.
2016-12-22 14:42:05 +03:00
args := make([]interface{}, 1+len(keys))
args[0] = "unlink"
for i, key := range keys {
args[1+i] = key
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewIntCmd(ctx, args...)
_ = c(ctx, cmd)
Add unlink command.
2016-12-22 14:42:05 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) Dump(ctx context.Context, key string) *StringCmd {
cmd := NewStringCmd(ctx, "dump", key)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) Exists(ctx context.Context, keys ...string) *IntCmd {
Support for multi keys in Exists
2017-02-10 13:15:25 +03:00
args := make([]interface{}, 1+len(keys))
args[0] = "exists"
for i, key := range keys {
args[1+i] = key
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewIntCmd(ctx, args...)
_ = c(ctx, cmd)
Support for multi keys in Exists
2017-02-10 13:15:25 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) Expire(ctx context.Context, key string, expiration time.Duration) *BoolCmd {
cmd := NewBoolCmd(ctx, "expire", key, formatSec(expiration))
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ExpireAt(ctx context.Context, key string, tm time.Time) *BoolCmd {
cmd := NewBoolCmd(ctx, "expireat", key, tm.Unix())
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) Keys(ctx context.Context, pattern string) *StringSliceCmd {
cmd := NewStringSliceCmd(ctx, "keys", pattern)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) Migrate(ctx context.Context, host, port, key string, db int, timeout time.Duration) *StatusCmd {
Rename req to cmd.
2014-06-25 11:40:56 +04:00
cmd := NewStatusCmd(
Add ctx as first arg
2020-03-11 17:26:42 +03:00
ctx,
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
"migrate",
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
host,
Review API.
2012-08-17 22:36:48 +04:00
port,
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
key,
Remove unneeded formatting.
2015-10-07 18:21:18 +03:00
db,
Use time.Duration to specify timeout.
2015-04-07 12:42:16 +03:00
formatMs(timeout),
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
)
Conn timeout should be higher than read timeout
2018-07-22 08:49:48 +03:00
cmd.setReadTimeout(timeout)
Add ctx as first arg
2020-03-11 17:26:42 +03:00
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) Move(ctx context.Context, key string, db int) *BoolCmd {
cmd := NewBoolCmd(ctx, "move", key, db)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ObjectRefCount(ctx context.Context, key string) *IntCmd {
cmd := NewIntCmd(ctx, "object", "refcount", key)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ObjectEncoding(ctx context.Context, key string) *StringCmd {
cmd := NewStringCmd(ctx, "object", "encoding", key)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ObjectIdleTime(ctx context.Context, key string) *DurationCmd {
cmd := NewDurationCmd(ctx, time.Second, "object", "idletime", key)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) Persist(ctx context.Context, key string) *BoolCmd {
cmd := NewBoolCmd(ctx, "persist", key)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) PExpire(ctx context.Context, key string, expiration time.Duration) *BoolCmd {
cmd := NewBoolCmd(ctx, "pexpire", key, formatMs(expiration))
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) PExpireAt(ctx context.Context, key string, tm time.Time) *BoolCmd {
Rename req to cmd.
2014-06-25 11:40:56 +04:00
cmd := NewBoolCmd(
Add ctx as first arg
2020-03-11 17:26:42 +03:00
ctx,
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
"pexpireat",
all: switch to gopkg.in.
2014-05-11 11:42:40 +04:00
key,
Remove unneeded formatting.
2015-10-07 18:21:18 +03:00
tm.UnixNano()/int64(time.Millisecond),
all: switch to gopkg.in.
2014-05-11 11:42:40 +04:00
)
Add ctx as first arg
2020-03-11 17:26:42 +03:00
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) PTTL(ctx context.Context, key string) *DurationCmd {
cmd := NewDurationCmd(ctx, time.Millisecond, "pttl", key)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) RandomKey(ctx context.Context) *StringCmd {
cmd := NewStringCmd(ctx, "randomkey")
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) Rename(ctx context.Context, key, newkey string) *StatusCmd {
cmd := NewStatusCmd(ctx, "rename", key, newkey)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) RenameNX(ctx context.Context, key, newkey string) *BoolCmd {
cmd := NewBoolCmd(ctx, "renamenx", key, newkey)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) Restore(ctx context.Context, key string, ttl time.Duration, value string) *StatusCmd {
Rename req to cmd.
2014-06-25 11:40:56 +04:00
cmd := NewStatusCmd(
Add ctx as first arg
2020-03-11 17:26:42 +03:00
ctx,
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
"restore",
Review API.
2012-08-17 22:36:48 +04:00
key,
Use time.Duration in Restore.
2015-07-11 12:10:41 +03:00
formatMs(ttl),
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
value,
)
Add ctx as first arg
2020-03-11 17:26:42 +03:00
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) RestoreReplace(ctx context.Context, key string, ttl time.Duration, value string) *StatusCmd {
Add RestoreReplace.
2015-07-11 12:23:04 +03:00
cmd := NewStatusCmd(
Add ctx as first arg
2020-03-11 17:26:42 +03:00
ctx,
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
"restore",
Add RestoreReplace.
2015-07-11 12:23:04 +03:00
key,
formatMs(ttl),
value,
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
"replace",
Add RestoreReplace.
2015-07-11 12:23:04 +03:00
)
Add ctx as first arg
2020-03-11 17:26:42 +03:00
_ = c(ctx, cmd)
Add RestoreReplace.
2015-07-11 12:23:04 +03:00
return cmd
}
Review API.
2012-08-17 22:36:48 +04:00
type Sort struct {
By string
Add SortStore and fix Sort signature
2018-02-13 17:08:11 +03:00
Offset, Count int64
Review API.
2012-08-17 22:36:48 +04:00
Get []string
Order string
Add SortStore and fix Sort signature
2018-02-13 17:08:11 +03:00
Alpha bool
Review API.
2012-08-17 22:36:48 +04:00
}
Sort can return nil reply. Fixes #246.
2016-01-22 13:29:23 +03:00
func (sort *Sort) args(key string) []interface{} {
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args := []interface{}{"sort", key}
Review API.
2012-08-17 22:36:48 +04:00
if sort.By != "" {
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args = append(args, "by", sort.By)
Review API.
2012-08-17 22:36:48 +04:00
}
if sort.Offset != 0 || sort.Count != 0 {
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args = append(args, "limit", sort.Offset, sort.Count)
Review API.
2012-08-17 22:36:48 +04:00
}
for _, get := range sort.Get {
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args = append(args, "get", get)
Review API.
2012-08-17 22:36:48 +04:00
}
if sort.Order != "" {
args = append(args, sort.Order)
}
Add SortStore and fix Sort signature
2018-02-13 17:08:11 +03:00
if sort.Alpha {
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args = append(args, "alpha")
Review API.
2012-08-17 22:36:48 +04:00
}
Sort can return nil reply. Fixes #246.
2016-01-22 13:29:23 +03:00
return args
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) Sort(ctx context.Context, key string, sort *Sort) *StringSliceCmd {
cmd := NewStringSliceCmd(ctx, sort.args(key)...)
_ = c(ctx, cmd)
Sort can return nil reply. Fixes #246.
2016-01-22 13:29:23 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) SortStore(ctx context.Context, key, store string, sort *Sort) *IntCmd {
Add SortStore and fix Sort signature
2018-02-13 17:08:11 +03:00
args := sort.args(key)
if store != "" {
args = append(args, "store", store)
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewIntCmd(ctx, args...)
_ = c(ctx, cmd)
Add SortStore and fix Sort signature
2018-02-13 17:08:11 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) SortInterfaces(ctx context.Context, key string, sort *Sort) *SliceCmd {
cmd := NewSliceCmd(ctx, sort.args(key)...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) Touch(ctx context.Context, keys ...string) *IntCmd {
add new command Touch and SwapDB
2018-02-14 07:42:19 +03:00
args := make([]interface{}, len(keys)+1)
args[0] = "touch"
for i, key := range keys {
args[i+1] = key
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewIntCmd(ctx, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Add BITCOUNT and BITOP commands.
2012-08-19 16:57:58 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) TTL(ctx context.Context, key string) *DurationCmd {
cmd := NewDurationCmd(ctx, time.Second, "ttl", key)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Add BITCOUNT and BITOP commands.
2012-08-19 16:57:58 +04:00
}
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) Type(ctx context.Context, key string) *StatusCmd {
cmd := NewStatusCmd(ctx, "type", key)
_ = c(ctx, cmd)
Add bitpos command.
2014-10-07 14:54:43 +04:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) Append(ctx context.Context, key, value string) *IntCmd {
cmd := NewIntCmd(ctx, "append", key, value)
_ = c(ctx, cmd)
Add basic BITFIELD support
2019-06-26 14:45:38 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) Decr(ctx context.Context, key string) *IntCmd {
cmd := NewIntCmd(ctx, "decr", key)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) DecrBy(ctx context.Context, key string, decrement int64) *IntCmd {
cmd := NewIntCmd(ctx, "decrby", key, decrement)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Mention redis.Nil
2017-12-27 14:29:46 +03:00
// Redis `GET key` command. It returns redis.Nil error when key does not exist.
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) Get(ctx context.Context, key string) *StringCmd {
cmd := NewStringCmd(ctx, "get", key)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Initial commit.
2012-07-25 17:00:50 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) GetRange(ctx context.Context, key string, start, end int64) *StringCmd {
cmd := NewStringCmd(ctx, "getrange", key, start, end)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) GetSet(ctx context.Context, key string, value interface{}) *StringCmd {
cmd := NewStringCmd(ctx, "getset", key, value)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) Incr(ctx context.Context, key string) *IntCmd {
cmd := NewIntCmd(ctx, "incr", key)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) IncrBy(ctx context.Context, key string, value int64) *IntCmd {
cmd := NewIntCmd(ctx, "incrby", key, value)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) IncrByFloat(ctx context.Context, key string, value float64) *FloatCmd {
cmd := NewFloatCmd(ctx, "incrbyfloat", key, value)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) MGet(ctx context.Context, keys ...string) *SliceCmd {
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
args := make([]interface{}, 1+len(keys))
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args[0] = "mget"
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
for i, key := range keys {
args[1+i] = key
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewSliceCmd(ctx, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Use HSET for HMSet
2019-12-18 11:52:49 +03:00
// MSet is like Set but accepts multiple values:
// - MSet("key1", "value1", "key2", "value2")
// - MSet([]string{"key1", "value1", "key2", "value2"})
// - MSet(map[string]interface{}{"key1": "value1", "key2": "value2"})
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) MSet(ctx context.Context, values ...interface{}) *StatusCmd {
Use HSET for HMSet
2019-12-18 11:52:49 +03:00
args := make([]interface{}, 1, 1+len(values))
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args[0] = "mset"
Use HSET for HMSet
2019-12-18 11:52:49 +03:00
args = appendArgs(args, values)
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewStatusCmd(ctx, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Use HSET for HMSet
2019-12-18 11:52:49 +03:00
// MSetNX is like SetNX but accepts multiple values:
// - MSetNX("key1", "value1", "key2", "value2")
// - MSetNX([]string{"key1", "value1", "key2", "value2"})
// - MSetNX(map[string]interface{}{"key1": "value1", "key2": "value2"})
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) MSetNX(ctx context.Context, values ...interface{}) *BoolCmd {
Use HSET for HMSet
2019-12-18 11:52:49 +03:00
args := make([]interface{}, 1, 1+len(values))
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args[0] = "msetnx"
Use HSET for HMSet
2019-12-18 11:52:49 +03:00
args = appendArgs(args, values)
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewBoolCmd(ctx, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Document zero expiration. Fixes #143.
2015-08-07 17:02:17 +03:00
// Redis `SET key value [expiration]` command.
//
Mention SETEX in the documentation. To help people looking for it specifically.
2017-02-25 04:01:11 +03:00
// Use expiration for `SETEX`-like behavior.
Document zero expiration. Fixes #143.
2015-08-07 17:02:17 +03:00
// Zero expiration means the key has no expiration time.
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) Set(ctx context.Context, key string, value interface{}, expiration time.Duration) *StatusCmd {
fix:Set operation claims insufficient memory (#1203)
2019-12-04 12:18:13 +03:00
args := make([]interface{}, 3, 5)
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args[0] = "set"
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
args[1] = key
args[2] = value
Refactor Set, SetNX and SetXX with expiration.
2015-01-31 12:08:56 +03:00
if expiration > 0 {
if usePrecise(expiration) {
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args = append(args, "px", formatMs(expiration))
Refactor Set, SetNX and SetXX with expiration.
2015-01-31 12:08:56 +03:00
} else {
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args = append(args, "ex", formatSec(expiration))
Refactor Set, SetNX and SetXX with expiration.
2015-01-31 12:08:56 +03:00
}
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewStatusCmd(ctx, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Document zero expiration. Fixes #143.
2015-08-07 17:02:17 +03:00
// Redis `SET key value [expiration] NX` command.
//
// Zero expiration means the key has no expiration time.
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) SetNX(ctx context.Context, key string, value interface{}, expiration time.Duration) *BoolCmd {
Refactor Set, SetNX and SetXX with expiration.
2015-01-31 12:08:56 +03:00
var cmd *BoolCmd
if expiration == 0 {
// Use old `SETNX` to support old Redis versions.
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd = NewBoolCmd(ctx, "setnx", key, value)
Refactor Set, SetNX and SetXX with expiration.
2015-01-31 12:08:56 +03:00
} else {
if usePrecise(expiration) {
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd = NewBoolCmd(ctx, "set", key, value, "px", formatMs(expiration), "nx")
Refactor Set, SetNX and SetXX with expiration.
2015-01-31 12:08:56 +03:00
} else {
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd = NewBoolCmd(ctx, "set", key, value, "ex", formatSec(expiration), "nx")
Refactor Set, SetNX and SetXX with expiration.
2015-01-31 12:08:56 +03:00
}
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
_ = c(ctx, cmd)
Refactor Set, SetNX and SetXX with expiration.
2015-01-31 12:08:56 +03:00
return cmd
}
Document zero expiration. Fixes #143.
2015-08-07 17:02:17 +03:00
// Redis `SET key value [expiration] XX` command.
//
// Zero expiration means the key has no expiration time.
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) SetXX(ctx context.Context, key string, value interface{}, expiration time.Duration) *BoolCmd {
Refactor Set, SetNX and SetXX with expiration.
2015-01-31 12:08:56 +03:00
var cmd *BoolCmd
Fix "invalid expire time in set" for SetXX with expiration = 0
2016-10-21 15:40:53 +03:00
if expiration == 0 {
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd = NewBoolCmd(ctx, "set", key, value, "xx")
Refactor Set, SetNX and SetXX with expiration.
2015-01-31 12:08:56 +03:00
} else {
Fix "invalid expire time in set" for SetXX with expiration = 0
2016-10-21 15:40:53 +03:00
if usePrecise(expiration) {
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd = NewBoolCmd(ctx, "set", key, value, "px", formatMs(expiration), "xx")
Fix "invalid expire time in set" for SetXX with expiration = 0
2016-10-21 15:40:53 +03:00
} else {
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd = NewBoolCmd(ctx, "set", key, value, "ex", formatSec(expiration), "xx")
Fix "invalid expire time in set" for SetXX with expiration = 0
2016-10-21 15:40:53 +03:00
}
Refactor Set, SetNX and SetXX with expiration.
2015-01-31 12:08:56 +03:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
_ = c(ctx, cmd)
return cmd
}
func (c cmdable) SetRange(ctx context.Context, key string, offset int64, value string) *IntCmd {
cmd := NewIntCmd(ctx, "setrange", key, offset, value)
_ = c(ctx, cmd)
return cmd
}
func (c cmdable) StrLen(ctx context.Context, key string) *IntCmd {
cmd := NewIntCmd(ctx, "strlen", key)
_ = c(ctx, cmd)
return cmd
}
//------------------------------------------------------------------------------
func (c cmdable) GetBit(ctx context.Context, key string, offset int64) *IntCmd {
cmd := NewIntCmd(ctx, "getbit", key, offset)
_ = c(ctx, cmd)
return cmd
}
func (c cmdable) SetBit(ctx context.Context, key string, offset int64, value int) *IntCmd {
cmd := NewIntCmd(
ctx,
"setbit",
key,
offset,
value,
)
_ = c(ctx, cmd)
return cmd
}
type BitCount struct {
Start, End int64
}
func (c cmdable) BitCount(ctx context.Context, key string, bitCount *BitCount) *IntCmd {
args := []interface{}{"bitcount", key}
if bitCount != nil {
args = append(
args,
bitCount.Start,
bitCount.End,
)
}
cmd := NewIntCmd(ctx, args...)
_ = c(ctx, cmd)
return cmd
}
func (c cmdable) bitOp(ctx context.Context, op, destKey string, keys ...string) *IntCmd {
args := make([]interface{}, 3+len(keys))
args[0] = "bitop"
args[1] = op
args[2] = destKey
for i, key := range keys {
args[3+i] = key
}
cmd := NewIntCmd(ctx, args...)
_ = c(ctx, cmd)
return cmd
}
func (c cmdable) BitOpAnd(ctx context.Context, destKey string, keys ...string) *IntCmd {
return c.bitOp(ctx, "and", destKey, keys...)
}
func (c cmdable) BitOpOr(ctx context.Context, destKey string, keys ...string) *IntCmd {
return c.bitOp(ctx, "or", destKey, keys...)
}
func (c cmdable) BitOpXor(ctx context.Context, destKey string, keys ...string) *IntCmd {
return c.bitOp(ctx, "xor", destKey, keys...)
}
func (c cmdable) BitOpNot(ctx context.Context, destKey string, key string) *IntCmd {
return c.bitOp(ctx, "not", destKey, key)
}
func (c cmdable) BitPos(ctx context.Context, key string, bit int64, pos ...int64) *IntCmd {
args := make([]interface{}, 3+len(pos))
args[0] = "bitpos"
args[1] = key
args[2] = bit
switch len(pos) {
case 0:
case 1:
args[3] = pos[0]
case 2:
args[3] = pos[0]
args[4] = pos[1]
default:
panic("too many arguments")
}
cmd := NewIntCmd(ctx, args...)
_ = c(ctx, cmd)
return cmd
}
func (c cmdable) BitField(ctx context.Context, key string, args ...interface{}) *IntSliceCmd {
a := make([]interface{}, 0, 2+len(args))
a = append(a, "bitfield")
a = append(a, key)
a = append(a, args...)
cmd := NewIntSliceCmd(ctx, a...)
_ = c(ctx, cmd)
return cmd
}
//------------------------------------------------------------------------------
func (c cmdable) Scan(ctx context.Context, cursor uint64, match string, count int64) *ScanCmd {
args := []interface{}{"scan", cursor}
if match != "" {
args = append(args, "match", match)
}
if count > 0 {
args = append(args, "count", count)
}
cmd := NewScanCmd(ctx, c, args...)
_ = c(ctx, cmd)
return cmd
}
func (c cmdable) SScan(ctx context.Context, key string, cursor uint64, match string, count int64) *ScanCmd {
args := []interface{}{"sscan", key, cursor}
if match != "" {
args = append(args, "match", match)
}
if count > 0 {
args = append(args, "count", count)
}
cmd := NewScanCmd(ctx, c, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) HScan(ctx context.Context, key string, cursor uint64, match string, count int64) *ScanCmd {
args := []interface{}{"hscan", key, cursor}
if match != "" {
args = append(args, "match", match)
}
if count > 0 {
args = append(args, "count", count)
}
cmd := NewScanCmd(ctx, c, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ZScan(ctx context.Context, key string, cursor uint64, match string, count int64) *ScanCmd {
args := []interface{}{"zscan", key, cursor}
if match != "" {
args = append(args, "match", match)
}
if count > 0 {
args = append(args, "count", count)
}
cmd := NewScanCmd(ctx, c, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Initial commit.
2012-07-25 17:00:50 +04:00
}
//------------------------------------------------------------------------------
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) HDel(ctx context.Context, key string, fields ...string) *IntCmd {
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
args := make([]interface{}, 2+len(fields))
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args[0] = "hdel"
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
args[1] = key
for i, field := range fields {
args[2+i] = field
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewIntCmd(ctx, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Initial commit.
2012-07-25 17:00:50 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) HExists(ctx context.Context, key, field string) *BoolCmd {
cmd := NewBoolCmd(ctx, "hexists", key, field)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Initial commit.
2012-07-25 17:00:50 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) HGet(ctx context.Context, key, field string) *StringCmd {
cmd := NewStringCmd(ctx, "hget", key, field)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Initial commit.
2012-07-25 17:00:50 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) HGetAll(ctx context.Context, key string) *StringStringMapCmd {
cmd := NewStringStringMapCmd(ctx, "hgetall", key)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Add *Map commands where possible.
2013-02-02 16:17:01 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) HIncrBy(ctx context.Context, key, field string, incr int64) *IntCmd {
cmd := NewIntCmd(ctx, "hincrby", key, field, incr)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Initial commit.
2012-07-25 17:00:50 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) HIncrByFloat(ctx context.Context, key, field string, incr float64) *FloatCmd {
cmd := NewFloatCmd(ctx, "hincrbyfloat", key, field, incr)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Review API.
2012-08-17 22:36:48 +04:00
}
Initial commit.
2012-07-25 17:00:50 +04:00
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) HKeys(ctx context.Context, key string) *StringSliceCmd {
cmd := NewStringSliceCmd(ctx, "hkeys", key)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Initial commit.
2012-07-25 17:00:50 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) HLen(ctx context.Context, key string) *IntCmd {
cmd := NewIntCmd(ctx, "hlen", key)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Initial commit.
2012-07-25 17:00:50 +04:00
}
Add note on HMGet
2020-01-12 13:03:21 +03:00
// HMGet returns the values for the specified fields in the hash stored at key.
// It returns an interface{} to distinguish between empty string and nil value.
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) HMGet(ctx context.Context, key string, fields ...string) *SliceCmd {
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
args := make([]interface{}, 2+len(fields))
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args[0] = "hmget"
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
args[1] = key
for i, field := range fields {
args[2+i] = field
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewSliceCmd(ctx, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Initial commit.
2012-07-25 17:00:50 +04:00
Rename HMSet to HSet and restore old HMSet
2020-02-19 16:14:18 +03:00
// HSet accepts values in following formats:
Fix doc
2020-01-20 12:57:46 +03:00
// - HMSet("myhash", "key1", "value1", "key2", "value2")
// - HMSet("myhash", []string{"key1", "value1", "key2", "value2"})
// - HMSet("myhash", map[string]interface{}{"key1": "value1", "key2": "value2"})
Use HSET for HMSet
2019-12-18 11:52:49 +03:00
//
Rename HMSet to HSet and restore old HMSet
2020-02-19 16:14:18 +03:00
// Note that it requires Redis v4 for multiple field/value pairs support.
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) HSet(ctx context.Context, key string, values ...interface{}) *IntCmd {
Fix HMSet args size
2019-12-24 13:23:32 +03:00
args := make([]interface{}, 2, 2+len(values))
Use HSET for HMSet
2019-12-18 11:52:49 +03:00
args[0] = "hset"
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
args[1] = key
Use HSET for HMSet
2019-12-18 11:52:49 +03:00
args = appendArgs(args, values)
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewIntCmd(ctx, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Rename HMSet to HSet and restore old HMSet
2020-02-19 16:14:18 +03:00
// HMSet is a deprecated version of HSet left for compatibility with Redis 3.
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) HMSet(ctx context.Context, key string, values ...interface{}) *BoolCmd {
Rename HMSet to HSet and restore old HMSet
2020-02-19 16:14:18 +03:00
args := make([]interface{}, 2, 2+len(values))
args[0] = "hmset"
args[1] = key
args = appendArgs(args, values)
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewBoolCmd(ctx, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Initial commit.
2012-07-25 17:00:50 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) HSetNX(ctx context.Context, key, field string, value interface{}) *BoolCmd {
cmd := NewBoolCmd(ctx, "hsetnx", key, field, value)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Initial commit.
2012-07-25 17:00:50 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) HVals(ctx context.Context, key string) *StringSliceCmd {
cmd := NewStringSliceCmd(ctx, "hvals", key)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Initial commit.
2012-07-25 17:00:50 +04:00
}
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
//------------------------------------------------------------------------------
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) BLPop(ctx context.Context, timeout time.Duration, keys ...string) *StringSliceCmd {
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args := make([]interface{}, 1+len(keys)+1)
args[0] = "blpop"
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
for i, key := range keys {
args[1+i] = key
}
args[len(args)-1] = formatSec(timeout)
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewStringSliceCmd(ctx, args...)
Conn timeout should be higher than read timeout
2018-07-22 08:49:48 +03:00
cmd.setReadTimeout(timeout)
Add ctx as first arg
2020-03-11 17:26:42 +03:00
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Initial commit.
2012-07-25 17:00:50 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) BRPop(ctx context.Context, timeout time.Duration, keys ...string) *StringSliceCmd {
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args := make([]interface{}, 1+len(keys)+1)
args[0] = "brpop"
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
for i, key := range keys {
args[1+i] = key
}
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args[len(keys)+1] = formatSec(timeout)
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewStringSliceCmd(ctx, args...)
Conn timeout should be higher than read timeout
2018-07-22 08:49:48 +03:00
cmd.setReadTimeout(timeout)
Add ctx as first arg
2020-03-11 17:26:42 +03:00
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Initial commit.
2012-07-25 17:00:50 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) BRPopLPush(ctx context.Context, source, destination string, timeout time.Duration) *StringCmd {
Rename req to cmd.
2014-06-25 11:40:56 +04:00
cmd := NewStringCmd(
Add ctx as first arg
2020-03-11 17:26:42 +03:00
ctx,
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
"brpoplpush",
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
source,
destination,
Use time.Duration to specify timeout.
2015-04-07 12:42:16 +03:00
formatSec(timeout),
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
)
Conn timeout should be higher than read timeout
2018-07-22 08:49:48 +03:00
cmd.setReadTimeout(timeout)
Add ctx as first arg
2020-03-11 17:26:42 +03:00
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Initial commit.
2012-07-25 17:00:50 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) LIndex(ctx context.Context, key string, index int64) *StringCmd {
cmd := NewStringCmd(ctx, "lindex", key, index)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) LInsert(ctx context.Context, key, op string, pivot, value interface{}) *IntCmd {
cmd := NewIntCmd(ctx, "linsert", key, op, pivot, value)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) LInsertBefore(ctx context.Context, key string, pivot, value interface{}) *IntCmd {
cmd := NewIntCmd(ctx, "linsert", key, "before", pivot, value)
_ = c(ctx, cmd)
Support more interface values.
2016-06-14 13:22:16 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) LInsertAfter(ctx context.Context, key string, pivot, value interface{}) *IntCmd {
cmd := NewIntCmd(ctx, "linsert", key, "after", pivot, value)
_ = c(ctx, cmd)
Support more interface values.
2016-06-14 13:22:16 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) LLen(ctx context.Context, key string) *IntCmd {
cmd := NewIntCmd(ctx, "llen", key)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) LPop(ctx context.Context, key string) *StringCmd {
cmd := NewStringCmd(ctx, "lpop", key)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) LPush(ctx context.Context, key string, values ...interface{}) *IntCmd {
Support []string slices in commands that accept multiple values
2018-03-08 15:30:27 +03:00
args := make([]interface{}, 2, 2+len(values))
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args[0] = "lpush"
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
args[1] = key
Support []string slices in commands that accept multiple values
2018-03-08 15:30:27 +03:00
args = appendArgs(args, values)
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewIntCmd(ctx, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Initial commit.
2012-07-25 17:00:50 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) LPushX(ctx context.Context, key string, values ...interface{}) *IntCmd {
remove mandatory arg value in lpushx and rpushx
2019-07-18 14:53:05 +03:00
args := make([]interface{}, 2, 2+len(values))
Making LpushX and RpushX variadic
2019-07-18 14:18:09 +03:00
args[0] = "lpushx"
args[1] = key
args = appendArgs(args, values)
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewIntCmd(ctx, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Initial commit.
2012-07-25 17:00:50 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) LRange(ctx context.Context, key string, start, stop int64) *StringSliceCmd {
Rename req to cmd.
2014-06-25 11:40:56 +04:00
cmd := NewStringSliceCmd(
Add ctx as first arg
2020-03-11 17:26:42 +03:00
ctx,
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
"lrange",
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
key,
Remove unneeded formatting.
2015-10-07 18:21:18 +03:00
start,
stop,
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
)
Add ctx as first arg
2020-03-11 17:26:42 +03:00
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Initial commit.
2012-07-25 17:00:50 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) LRem(ctx context.Context, key string, count int64, value interface{}) *IntCmd {
cmd := NewIntCmd(ctx, "lrem", key, count, value)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Initial commit.
2012-07-25 17:00:50 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) LSet(ctx context.Context, key string, index int64, value interface{}) *StatusCmd {
cmd := NewStatusCmd(ctx, "lset", key, index, value)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Initial commit.
2012-07-25 17:00:50 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) LTrim(ctx context.Context, key string, start, stop int64) *StatusCmd {
Rename req to cmd.
2014-06-25 11:40:56 +04:00
cmd := NewStatusCmd(
Add ctx as first arg
2020-03-11 17:26:42 +03:00
ctx,
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
"ltrim",
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
key,
Remove unneeded formatting.
2015-10-07 18:21:18 +03:00
start,
stop,
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
)
Add ctx as first arg
2020-03-11 17:26:42 +03:00
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) RPop(ctx context.Context, key string) *StringCmd {
cmd := NewStringCmd(ctx, "rpop", key)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) RPopLPush(ctx context.Context, source, destination string) *StringCmd {
cmd := NewStringCmd(ctx, "rpoplpush", source, destination)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) RPush(ctx context.Context, key string, values ...interface{}) *IntCmd {
Support []string slices in commands that accept multiple values
2018-03-08 15:30:27 +03:00
args := make([]interface{}, 2, 2+len(values))
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args[0] = "rpush"
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
args[1] = key
Support []string slices in commands that accept multiple values
2018-03-08 15:30:27 +03:00
args = appendArgs(args, values)
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewIntCmd(ctx, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) RPushX(ctx context.Context, key string, values ...interface{}) *IntCmd {
remove mandatory arg value in lpushx and rpushx
2019-07-18 14:53:05 +03:00
args := make([]interface{}, 2, 2+len(values))
Making LpushX and RpushX variadic
2019-07-18 14:18:09 +03:00
args[0] = "rpushx"
args[1] = key
args = appendArgs(args, values)
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewIntCmd(ctx, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
//------------------------------------------------------------------------------
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) SAdd(ctx context.Context, key string, members ...interface{}) *IntCmd {
Support []string slices in commands that accept multiple values
2018-03-08 15:30:27 +03:00
args := make([]interface{}, 2, 2+len(members))
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args[0] = "sadd"
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
args[1] = key
Support []string slices in commands that accept multiple values
2018-03-08 15:30:27 +03:00
args = appendArgs(args, members)
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewIntCmd(ctx, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Initial commit.
2012-07-25 17:00:50 +04:00
}
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) SCard(ctx context.Context, key string) *IntCmd {
cmd := NewIntCmd(ctx, "scard", key)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) SDiff(ctx context.Context, keys ...string) *StringSliceCmd {
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
args := make([]interface{}, 1+len(keys))
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args[0] = "sdiff"
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
for i, key := range keys {
args[1+i] = key
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewStringSliceCmd(ctx, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) SDiffStore(ctx context.Context, destination string, keys ...string) *IntCmd {
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
args := make([]interface{}, 2+len(keys))
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args[0] = "sdiffstore"
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
args[1] = destination
for i, key := range keys {
args[2+i] = key
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewIntCmd(ctx, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) SInter(ctx context.Context, keys ...string) *StringSliceCmd {
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
args := make([]interface{}, 1+len(keys))
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args[0] = "sinter"
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
for i, key := range keys {
args[1+i] = key
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewStringSliceCmd(ctx, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) SInterStore(ctx context.Context, destination string, keys ...string) *IntCmd {
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
args := make([]interface{}, 2+len(keys))
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args[0] = "sinterstore"
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
args[1] = destination
for i, key := range keys {
args[2+i] = key
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewIntCmd(ctx, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) SIsMember(ctx context.Context, key string, member interface{}) *BoolCmd {
cmd := NewBoolCmd(ctx, "sismember", key, member)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add godoc commentary to SMembers and SMembersMap
2017-11-19 19:56:54 +03:00
// Redis `SMEMBERS key` command output as a slice
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) SMembers(ctx context.Context, key string) *StringSliceCmd {
cmd := NewStringSliceCmd(ctx, "smembers", key)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add godoc commentary to SMembers and SMembersMap
2017-11-19 19:56:54 +03:00
// Redis `SMEMBERS key` command output as a map
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) SMembersMap(ctx context.Context, key string) *StringStructMapCmd {
cmd := NewStringStructMapCmd(ctx, "smembers", key)
_ = c(ctx, cmd)
Add SMembersMap function
2017-11-19 19:36:23 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) SMove(ctx context.Context, source, destination string, member interface{}) *BoolCmd {
cmd := NewBoolCmd(ctx, "smove", source, destination, member)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
add support for SPOP with a count argument (available in REDIS 3.2)
2016-06-09 18:39:51 +03:00
// Redis `SPOP key` command.
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) SPop(ctx context.Context, key string) *StringCmd {
cmd := NewStringCmd(ctx, "spop", key)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
add support for SPOP with a count argument (available in REDIS 3.2)
2016-06-09 18:39:51 +03:00
// Redis `SPOP key count` command.
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) SPopN(ctx context.Context, key string, count int64) *StringSliceCmd {
cmd := NewStringSliceCmd(ctx, "spop", key, count)
_ = c(ctx, cmd)
add support for SPOP with a count argument (available in REDIS 3.2)
2016-06-09 18:39:51 +03:00
return cmd
}
Add SRandMemberN. Fixes #155.
2015-08-25 14:02:16 +03:00
// Redis `SRANDMEMBER key` command.
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) SRandMember(ctx context.Context, key string) *StringCmd {
cmd := NewStringCmd(ctx, "srandmember", key)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add SRandMemberN. Fixes #155.
2015-08-25 14:02:16 +03:00
// Redis `SRANDMEMBER key count` command.
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) SRandMemberN(ctx context.Context, key string, count int64) *StringSliceCmd {
cmd := NewStringSliceCmd(ctx, "srandmember", key, count)
_ = c(ctx, cmd)
Add SRandMemberN. Fixes #155.
2015-08-25 14:02:16 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) SRem(ctx context.Context, key string, members ...interface{}) *IntCmd {
Support []string slices in commands that accept multiple values
2018-03-08 15:30:27 +03:00
args := make([]interface{}, 2, 2+len(members))
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args[0] = "srem"
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
args[1] = key
Support []string slices in commands that accept multiple values
2018-03-08 15:30:27 +03:00
args = appendArgs(args, members)
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewIntCmd(ctx, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) SUnion(ctx context.Context, keys ...string) *StringSliceCmd {
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
args := make([]interface{}, 1+len(keys))
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args[0] = "sunion"
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
for i, key := range keys {
args[1+i] = key
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewStringSliceCmd(ctx, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) SUnionStore(ctx context.Context, destination string, keys ...string) *IntCmd {
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
args := make([]interface{}, 2+len(keys))
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args[0] = "sunionstore"
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
args[1] = destination
for i, key := range keys {
args[2+i] = key
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewIntCmd(ctx, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Fix multi/exec and add more commands.
2012-07-26 19:16:17 +04:00
}
//------------------------------------------------------------------------------
Add streams group related commands
2018-08-02 14:48:46 +03:00
type XAddArgs struct {
Add basic redis streams support
2017-11-25 05:06:13 +03:00
Stream string
MaxLen int64 // MAXLEN N
MaxLenApprox int64 // MAXLEN ~ N
ID string
Values map[string]interface{}
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) XAdd(ctx context.Context, a *XAddArgs) *StringCmd {
Add streams group related commands
2018-08-02 14:48:46 +03:00
args := make([]interface{}, 0, 6+len(a.Values)*2)
args = append(args, "xadd")
args = append(args, a.Stream)
if a.MaxLen > 0 {
args = append(args, "maxlen", a.MaxLen)
} else if a.MaxLenApprox > 0 {
args = append(args, "maxlen", "~", a.MaxLenApprox)
Add basic redis streams support
2017-11-25 05:06:13 +03:00
}
Add streams group related commands
2018-08-02 14:48:46 +03:00
if a.ID != "" {
args = append(args, a.ID)
Add basic redis streams support
2017-11-25 05:06:13 +03:00
} else {
Add streams group related commands
2018-08-02 14:48:46 +03:00
args = append(args, "*")
Add basic redis streams support
2017-11-25 05:06:13 +03:00
}
Add streams group related commands
2018-08-02 14:48:46 +03:00
for k, v := range a.Values {
args = append(args, k)
args = append(args, v)
Add basic redis streams support
2017-11-25 05:06:13 +03:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewStringCmd(ctx, args...)
_ = c(ctx, cmd)
Add basic redis streams support
2017-11-25 05:06:13 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) XDel(ctx context.Context, stream string, ids ...string) *IntCmd {
Add support for XDel
2018-11-13 15:22:50 +03:00
args := []interface{}{"xdel", stream}
for _, id := range ids {
args = append(args, id)
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewIntCmd(ctx, args...)
_ = c(ctx, cmd)
Add support for XDel
2018-11-13 15:22:50 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) XLen(ctx context.Context, stream string) *IntCmd {
cmd := NewIntCmd(ctx, "xlen", stream)
_ = c(ctx, cmd)
Add basic redis streams support
2017-11-25 05:06:13 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) XRange(ctx context.Context, stream, start, stop string) *XMessageSliceCmd {
cmd := NewXMessageSliceCmd(ctx, "xrange", stream, start, stop)
_ = c(ctx, cmd)
Add basic redis streams support
2017-11-25 05:06:13 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) XRangeN(ctx context.Context, stream, start, stop string, count int64) *XMessageSliceCmd {
cmd := NewXMessageSliceCmd(ctx, "xrange", stream, start, stop, "count", count)
_ = c(ctx, cmd)
Add basic redis streams support
2017-11-25 05:06:13 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) XRevRange(ctx context.Context, stream, start, stop string) *XMessageSliceCmd {
cmd := NewXMessageSliceCmd(ctx, "xrevrange", stream, start, stop)
_ = c(ctx, cmd)
Add basic redis streams support
2017-11-25 05:06:13 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) XRevRangeN(ctx context.Context, stream, start, stop string, count int64) *XMessageSliceCmd {
cmd := NewXMessageSliceCmd(ctx, "xrevrange", stream, start, stop, "count", count)
_ = c(ctx, cmd)
Add basic redis streams support
2017-11-25 05:06:13 +03:00
return cmd
}
Add streams group related commands
2018-08-02 14:48:46 +03:00
type XReadArgs struct {
Add hint on Streams usage
2020-01-12 13:14:22 +03:00
Streams []string // list of streams and ids, e.g. stream1 stream2 id1 id2
Add basic redis streams support
2017-11-25 05:06:13 +03:00
Count int64
Block time.Duration
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) XRead(ctx context.Context, a *XReadArgs) *XStreamSliceCmd {
Add streams group related commands
2018-08-02 14:48:46 +03:00
args := make([]interface{}, 0, 5+len(a.Streams))
args = append(args, "xread")
if a.Count > 0 {
args = append(args, "count")
args = append(args, a.Count)
Add basic redis streams support
2017-11-25 05:06:13 +03:00
}
Add streams group related commands
2018-08-02 14:48:46 +03:00
if a.Block >= 0 {
args = append(args, "block")
args = append(args, int64(a.Block/time.Millisecond))
}
Add hint on Streams usage
2020-01-12 13:14:22 +03:00
Add streams group related commands
2018-08-02 14:48:46 +03:00
args = append(args, "streams")
for _, s := range a.Streams {
args = append(args, s)
Add basic redis streams support
2017-11-25 05:06:13 +03:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewXStreamSliceCmd(ctx, args...)
Set cmd timeout when Block >= 0
2018-09-13 09:14:52 +03:00
if a.Block >= 0 {
cmd.setReadTimeout(a.Block)
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
_ = c(ctx, cmd)
Add basic redis streams support
2017-11-25 05:06:13 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) XReadStreams(ctx context.Context, streams ...string) *XStreamSliceCmd {
return c.XRead(ctx, &XReadArgs{
Add basic redis streams support
2017-11-25 05:06:13 +03:00
Streams: streams,
Support XREAD BLOCK 0
2018-07-18 12:08:43 +03:00
Block: -1,
Add basic redis streams support
2017-11-25 05:06:13 +03:00
})
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) XGroupCreate(ctx context.Context, stream, group, start string) *StatusCmd {
cmd := NewStatusCmd(ctx, "xgroup", "create", stream, group, start)
_ = c(ctx, cmd)
Add streams group related commands
2018-08-02 14:48:46 +03:00
return cmd
Add basic redis streams support
2017-11-25 05:06:13 +03:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) XGroupCreateMkStream(ctx context.Context, stream, group, start string) *StatusCmd {
cmd := NewStatusCmd(ctx, "xgroup", "create", stream, group, start, "mkstream")
_ = c(ctx, cmd)
xgroup: Add XGroupCreateMkStream
2018-12-11 17:52:46 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) XGroupSetID(ctx context.Context, stream, group, start string) *StatusCmd {
cmd := NewStatusCmd(ctx, "xgroup", "setid", stream, group, start)
_ = c(ctx, cmd)
Add streams group related commands
2018-08-02 14:48:46 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) XGroupDestroy(ctx context.Context, stream, group string) *IntCmd {
cmd := NewIntCmd(ctx, "xgroup", "destroy", stream, group)
_ = c(ctx, cmd)
Add streams group related commands
2018-08-02 14:48:46 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) XGroupDelConsumer(ctx context.Context, stream, group, consumer string) *IntCmd {
cmd := NewIntCmd(ctx, "xgroup", "delconsumer", stream, group, consumer)
_ = c(ctx, cmd)
Add streams group related commands
2018-08-02 14:48:46 +03:00
return cmd
}
type XReadGroupArgs struct {
Group string
Consumer string
Pass pointers where it makes sense
2019-05-16 16:27:19 +03:00
Streams []string // list of streams and ids, e.g. stream1 stream2 id1 id2
Count int64
Block time.Duration
NoAck bool
Add streams group related commands
2018-08-02 14:48:46 +03:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) XReadGroup(ctx context.Context, a *XReadGroupArgs) *XStreamSliceCmd {
Add streams group related commands
2018-08-02 14:48:46 +03:00
args := make([]interface{}, 0, 8+len(a.Streams))
args = append(args, "xreadgroup", "group", a.Group, a.Consumer)
if a.Count > 0 {
args = append(args, "count", a.Count)
}
if a.Block >= 0 {
args = append(args, "block", int64(a.Block/time.Millisecond))
}
Fix tests
2018-11-21 12:09:21 +03:00
if a.NoAck {
args = append(args, "noack")
}
Add streams group related commands
2018-08-02 14:48:46 +03:00
args = append(args, "streams")
for _, s := range a.Streams {
args = append(args, s)
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewXStreamSliceCmd(ctx, args...)
Set cmd timeout when Block >= 0
2018-09-13 09:14:52 +03:00
if a.Block >= 0 {
cmd.setReadTimeout(a.Block)
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
_ = c(ctx, cmd)
Add streams group related commands
2018-08-02 14:48:46 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) XAck(ctx context.Context, stream, group string, ids ...string) *IntCmd {
Add streams group related commands
2018-08-02 14:48:46 +03:00
args := []interface{}{"xack", stream, group}
for _, id := range ids {
args = append(args, id)
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewIntCmd(ctx, args...)
_ = c(ctx, cmd)
Add streams group related commands
2018-08-02 14:48:46 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) XPending(ctx context.Context, stream, group string) *XPendingCmd {
cmd := NewXPendingCmd(ctx, "xpending", stream, group)
_ = c(ctx, cmd)
Add streams group related commands
2018-08-02 14:48:46 +03:00
return cmd
}
type XPendingExtArgs struct {
Stream string
Group string
Start string
End string
Count int64
Consumer string
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) XPendingExt(ctx context.Context, a *XPendingExtArgs) *XPendingExtCmd {
Add streams group related commands
2018-08-02 14:48:46 +03:00
args := make([]interface{}, 0, 7)
args = append(args, "xpending", a.Stream, a.Group, a.Start, a.End, a.Count)
if a.Consumer != "" {
args = append(args, a.Consumer)
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewXPendingExtCmd(ctx, args...)
_ = c(ctx, cmd)
Add streams group related commands
2018-08-02 14:48:46 +03:00
return cmd
}
type XClaimArgs struct {
Stream string
Group string
Consumer string
MinIdle time.Duration
Messages []string
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) XClaim(ctx context.Context, a *XClaimArgs) *XMessageSliceCmd {
Add streams group related commands
2018-08-02 14:48:46 +03:00
args := xClaimArgs(a)
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewXMessageSliceCmd(ctx, args...)
_ = c(ctx, cmd)
Add streams group related commands
2018-08-02 14:48:46 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) XClaimJustID(ctx context.Context, a *XClaimArgs) *StringSliceCmd {
Add streams group related commands
2018-08-02 14:48:46 +03:00
args := xClaimArgs(a)
args = append(args, "justid")
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewStringSliceCmd(ctx, args...)
_ = c(ctx, cmd)
Add streams group related commands
2018-08-02 14:48:46 +03:00
return cmd
}
func xClaimArgs(a *XClaimArgs) []interface{} {
args := make([]interface{}, 0, 4+len(a.Messages))
args = append(args,
"xclaim",
a.Stream,
a.Group, a.Consumer,
int64(a.MinIdle/time.Millisecond))
for _, id := range a.Messages {
args = append(args, id)
}
return args
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) XTrim(ctx context.Context, key string, maxLen int64) *IntCmd {
cmd := NewIntCmd(ctx, "xtrim", key, "maxlen", maxLen)
_ = c(ctx, cmd)
Add streams group related commands
2018-08-02 14:48:46 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) XTrimApprox(ctx context.Context, key string, maxLen int64) *IntCmd {
cmd := NewIntCmd(ctx, "xtrim", key, "maxlen", "~", maxLen)
_ = c(ctx, cmd)
Add streams group related commands
2018-08-02 14:48:46 +03:00
return cmd
Add basic redis streams support
2017-11-25 05:06:13 +03:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) XInfoGroups(ctx context.Context, key string) *XInfoGroupsCmd {
cmd := NewXInfoGroupsCmd(ctx, key)
_ = c(ctx, cmd)
add xinfo groups command (#1166) Add xinfo groups command
2019-10-08 12:48:24 +03:00
return cmd
}
Add basic redis streams support
2017-11-25 05:06:13 +03:00
//------------------------------------------------------------------------------
Fix ZStore Weight type. Fixes #206.
2015-12-01 17:28:41 +03:00
// Z represents sorted set member.
Review API.
2012-08-17 22:36:48 +04:00
type Z struct {
Add sorted sets support.
2012-07-27 18:21:50 +04:00
Score float64
Add bytes support for sorted set.
2015-07-16 17:30:16 +03:00
Member interface{}
Add sorted sets support.
2012-07-27 18:21:50 +04:00
}
Implement BZPop{Min,Max}
2018-10-31 16:35:23 +03:00
// ZWithKey represents sorted set member including the name of the key where it was popped.
type ZWithKey struct {
Change ZWithKey
2018-11-03 13:07:25 +03:00
Z
Key string
Implement BZPop{Min,Max}
2018-10-31 16:35:23 +03:00
}
Fix ZStore Weight type. Fixes #206.
2015-12-01 17:28:41 +03:00
// ZStore is used as an arg to ZInterStore and ZUnionStore.
Review API.
2012-08-17 22:36:48 +04:00
type ZStore struct {
Move key to ZStore
2019-08-09 16:23:56 +03:00
Keys []string
Fix ZStore Weight type. Fixes #206.
2015-12-01 17:28:41 +03:00
Weights []float64
Add bytes support for sorted set.
2015-07-16 17:30:16 +03:00
// Can be SUM, MIN or MAX.
Review API.
2012-08-17 22:36:48 +04:00
Aggregate string
Add sorted sets support.
2012-07-27 18:21:50 +04:00
}
Implement BZPop{Min,Max}
2018-10-31 16:35:23 +03:00
// Redis `BZPOPMAX key [key ...] timeout` command.
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) BZPopMax(ctx context.Context, timeout time.Duration, keys ...string) *ZWithKeyCmd {
Implement BZPop{Min,Max}
2018-10-31 16:35:23 +03:00
args := make([]interface{}, 1+len(keys)+1)
args[0] = "bzpopmax"
for i, key := range keys {
args[1+i] = key
}
args[len(args)-1] = formatSec(timeout)
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewZWithKeyCmd(ctx, args...)
Implement BZPop{Min,Max}
2018-10-31 16:35:23 +03:00
cmd.setReadTimeout(timeout)
Add ctx as first arg
2020-03-11 17:26:42 +03:00
_ = c(ctx, cmd)
Implement BZPop{Min,Max}
2018-10-31 16:35:23 +03:00
return cmd
}
// Redis `BZPOPMIN key [key ...] timeout` command.
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) BZPopMin(ctx context.Context, timeout time.Duration, keys ...string) *ZWithKeyCmd {
Implement BZPop{Min,Max}
2018-10-31 16:35:23 +03:00
args := make([]interface{}, 1+len(keys)+1)
args[0] = "bzpopmin"
for i, key := range keys {
args[1+i] = key
}
args[len(args)-1] = formatSec(timeout)
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewZWithKeyCmd(ctx, args...)
Implement BZPop{Min,Max}
2018-10-31 16:35:23 +03:00
cmd.setReadTimeout(timeout)
Add ctx as first arg
2020-03-11 17:26:42 +03:00
_ = c(ctx, cmd)
Implement BZPop{Min,Max}
2018-10-31 16:35:23 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) zAdd(ctx context.Context, a []interface{}, n int, members ...*Z) *IntCmd {
Add ZADD modifiers.
2015-08-29 13:08:27 +03:00
for i, m := range members {
Remove unneeded formatting.
2015-10-07 18:21:18 +03:00
a[n+2*i] = m.Score
Add ZADD modifiers.
2015-08-29 13:08:27 +03:00
a[n+2*i+1] = m.Member
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewIntCmd(ctx, a...)
_ = c(ctx, cmd)
Add ZADD modifiers.
2015-08-29 13:08:27 +03:00
return cmd
}
// Redis `ZADD key score member [score member ...]` command.
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ZAdd(ctx context.Context, key string, members ...*Z) *IntCmd {
Add ZADD modifiers.
2015-08-29 13:08:27 +03:00
const n = 2
a := make([]interface{}, n+2*len(members))
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
a[0], a[1] = "zadd", key
Add ctx as first arg
2020-03-11 17:26:42 +03:00
return c.zAdd(ctx, a, n, members...)
Add ZADD modifiers.
2015-08-29 13:08:27 +03:00
}
// Redis `ZADD key NX score member [score member ...]` command.
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ZAddNX(ctx context.Context, key string, members ...*Z) *IntCmd {
Add ZADD modifiers.
2015-08-29 13:08:27 +03:00
const n = 3
a := make([]interface{}, n+2*len(members))
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
a[0], a[1], a[2] = "zadd", key, "nx"
Add ctx as first arg
2020-03-11 17:26:42 +03:00
return c.zAdd(ctx, a, n, members...)
Add ZADD modifiers.
2015-08-29 13:08:27 +03:00
}
// Redis `ZADD key XX score member [score member ...]` command.
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ZAddXX(ctx context.Context, key string, members ...*Z) *IntCmd {
Add ZADD modifiers.
2015-08-29 13:08:27 +03:00
const n = 3
a := make([]interface{}, n+2*len(members))
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
a[0], a[1], a[2] = "zadd", key, "xx"
Add ctx as first arg
2020-03-11 17:26:42 +03:00
return c.zAdd(ctx, a, n, members...)
Add ZADD modifiers.
2015-08-29 13:08:27 +03:00
}
// Redis `ZADD key CH score member [score member ...]` command.
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ZAddCh(ctx context.Context, key string, members ...*Z) *IntCmd {
Add ZADD modifiers.
2015-08-29 13:08:27 +03:00
const n = 3
a := make([]interface{}, n+2*len(members))
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
a[0], a[1], a[2] = "zadd", key, "ch"
Add ctx as first arg
2020-03-11 17:26:42 +03:00
return c.zAdd(ctx, a, n, members...)
Add ZADD modifiers.
2015-08-29 13:08:27 +03:00
}
// Redis `ZADD key NX CH score member [score member ...]` command.
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ZAddNXCh(ctx context.Context, key string, members ...*Z) *IntCmd {
Add ZADD modifiers.
2015-08-29 13:08:27 +03:00
const n = 4
a := make([]interface{}, n+2*len(members))
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
a[0], a[1], a[2], a[3] = "zadd", key, "nx", "ch"
Add ctx as first arg
2020-03-11 17:26:42 +03:00
return c.zAdd(ctx, a, n, members...)
Add ZADD modifiers.
2015-08-29 13:08:27 +03:00
}
// Redis `ZADD key XX CH score member [score member ...]` command.
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ZAddXXCh(ctx context.Context, key string, members ...*Z) *IntCmd {
Add ZADD modifiers.
2015-08-29 13:08:27 +03:00
const n = 4
a := make([]interface{}, n+2*len(members))
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
a[0], a[1], a[2], a[3] = "zadd", key, "xx", "ch"
Add ctx as first arg
2020-03-11 17:26:42 +03:00
return c.zAdd(ctx, a, n, members...)
Add ZADD modifiers.
2015-08-29 13:08:27 +03:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) zIncr(ctx context.Context, a []interface{}, n int, members ...*Z) *FloatCmd {
commands: reduce memory allocations in ZAdd.
2015-05-11 16:41:42 +03:00
for i, m := range members {
Remove unneeded formatting.
2015-10-07 18:21:18 +03:00
a[n+2*i] = m.Score
Add ZADD modifiers.
2015-08-29 13:08:27 +03:00
a[n+2*i+1] = m.Member
Add sorted sets support.
2012-07-27 18:21:50 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewFloatCmd(ctx, a...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Add sorted sets support.
2012-07-27 18:21:50 +04:00
}
Add ZADD modifiers.
2015-08-29 13:08:27 +03:00
// Redis `ZADD key INCR score member` command.
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ZIncr(ctx context.Context, key string, member *Z) *FloatCmd {
Add ZADD modifiers.
2015-08-29 13:08:27 +03:00
const n = 3
a := make([]interface{}, n+2)
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
a[0], a[1], a[2] = "zadd", key, "incr"
Add ctx as first arg
2020-03-11 17:26:42 +03:00
return c.zIncr(ctx, a, n, member)
Add ZADD modifiers.
2015-08-29 13:08:27 +03:00
}
// Redis `ZADD key NX INCR score member` command.
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ZIncrNX(ctx context.Context, key string, member *Z) *FloatCmd {
Add ZADD modifiers.
2015-08-29 13:08:27 +03:00
const n = 4
a := make([]interface{}, n+2)
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
a[0], a[1], a[2], a[3] = "zadd", key, "incr", "nx"
Add ctx as first arg
2020-03-11 17:26:42 +03:00
return c.zIncr(ctx, a, n, member)
Add ZADD modifiers.
2015-08-29 13:08:27 +03:00
}
// Redis `ZADD key XX INCR score member` command.
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ZIncrXX(ctx context.Context, key string, member *Z) *FloatCmd {
Add ZADD modifiers.
2015-08-29 13:08:27 +03:00
const n = 4
a := make([]interface{}, n+2)
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
a[0], a[1], a[2], a[3] = "zadd", key, "incr", "xx"
Add ctx as first arg
2020-03-11 17:26:42 +03:00
return c.zIncr(ctx, a, n, member)
Add ZADD modifiers.
2015-08-29 13:08:27 +03:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ZCard(ctx context.Context, key string) *IntCmd {
cmd := NewIntCmd(ctx, "zcard", key)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Add sorted sets support.
2012-07-27 18:21:50 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ZCount(ctx context.Context, key, min, max string) *IntCmd {
cmd := NewIntCmd(ctx, "zcount", key, min, max)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Add sorted sets support.
2012-07-27 18:21:50 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ZLexCount(ctx context.Context, key, min, max string) *IntCmd {
cmd := NewIntCmd(ctx, "zlexcount", key, min, max)
_ = c(ctx, cmd)
Add ZLexCount
2017-08-15 09:49:23 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ZIncrBy(ctx context.Context, key string, increment float64, member string) *FloatCmd {
cmd := NewFloatCmd(ctx, "zincrby", key, increment, member)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Add sorted sets support.
2012-07-27 18:21:50 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ZInterStore(ctx context.Context, destination string, store *ZStore) *IntCmd {
Move key to ZStore
2019-08-09 16:23:56 +03:00
args := make([]interface{}, 3+len(store.Keys))
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args[0] = "zinterstore"
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
args[1] = destination
Move key to ZStore
2019-08-09 16:23:56 +03:00
args[2] = len(store.Keys)
for i, key := range store.Keys {
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
args[3+i] = key
}
Review API.
2012-08-17 22:36:48 +04:00
if len(store.Weights) > 0 {
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args = append(args, "weights")
Review API.
2012-08-17 22:36:48 +04:00
for _, weight := range store.Weights {
Remove unneeded formatting.
2015-10-07 18:21:18 +03:00
args = append(args, weight)
Add sorted sets support.
2012-07-27 18:21:50 +04:00
}
}
Review API.
2012-08-17 22:36:48 +04:00
if store.Aggregate != "" {
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args = append(args, "aggregate", store.Aggregate)
Add sorted sets support.
2012-07-27 18:21:50 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewIntCmd(ctx, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Add sorted sets support.
2012-07-27 18:21:50 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ZPopMax(ctx context.Context, key string, count ...int64) *ZSliceCmd {
Add ZPopMin and ZPopMax (#853) * Add ZPopMin and ZPopMax
2018-09-03 11:45:32 +03:00
args := []interface{}{
"zpopmax",
key,
}
switch len(count) {
case 0:
break
case 1:
args = append(args, count[0])
default:
panic("too many arguments")
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewZSliceCmd(ctx, args...)
_ = c(ctx, cmd)
Add ZPopMin and ZPopMax (#853) * Add ZPopMin and ZPopMax
2018-09-03 11:45:32 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ZPopMin(ctx context.Context, key string, count ...int64) *ZSliceCmd {
Add ZPopMin and ZPopMax (#853) * Add ZPopMin and ZPopMax
2018-09-03 11:45:32 +03:00
args := []interface{}{
"zpopmin",
key,
}
switch len(count) {
case 0:
break
case 1:
args = append(args, count[0])
default:
panic("too many arguments")
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewZSliceCmd(ctx, args...)
_ = c(ctx, cmd)
Add ZPopMin and ZPopMax (#853) * Add ZPopMin and ZPopMax
2018-09-03 11:45:32 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) zRange(ctx context.Context, key string, start, stop int64, withScores bool) *StringSliceCmd {
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
args := []interface{}{
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
"zrange",
Add sorted sets support.
2012-07-27 18:21:50 +04:00
key,
Remove unneeded formatting.
2015-10-07 18:21:18 +03:00
start,
stop,
Add sorted sets support.
2012-07-27 18:21:50 +04:00
}
if withScores {
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args = append(args, "withscores")
Add sorted sets support.
2012-07-27 18:21:50 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewStringSliceCmd(ctx, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Add sorted sets support.
2012-07-27 18:21:50 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ZRange(ctx context.Context, key string, start, stop int64) *StringSliceCmd {
return c.zRange(ctx, key, start, stop, false)
Review API.
2012-08-17 22:36:48 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ZRangeWithScores(ctx context.Context, key string, start, stop int64) *ZSliceCmd {
cmd := NewZSliceCmd(ctx, "zrange", key, start, stop, "withscores")
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Add *Map commands where possible.
2013-02-02 16:17:01 +04:00
}
Rename ZRangeByScore to ZRange since it is used in ZRangeByLex.
2016-04-09 13:15:33 +03:00
type ZRangeBy struct {
Use consistent API in ZRevRangeWithScores and ZRevRange. Fixes #56. Fixes #78.
2015-03-30 16:14:21 +03:00
Min, Max string
all: switch to gopkg.in.
2014-05-11 11:42:40 +04:00
Offset, Count int64
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) zRangeBy(ctx context.Context, zcmd, key string, opt *ZRangeBy, withScores bool) *StringSliceCmd {
Reverted change to struct ZRangeByScore, implemented ZRevRangeByLex.
2015-08-25 22:15:01 +03:00
args := []interface{}{zcmd, key, opt.Min, opt.Max}
Add sorted sets support.
2012-07-27 18:21:50 +04:00
if withScores {
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args = append(args, "withscores")
Add sorted sets support.
2012-07-27 18:21:50 +04:00
}
all: switch to gopkg.in.
2014-05-11 11:42:40 +04:00
if opt.Offset != 0 || opt.Count != 0 {
Add sorted sets support.
2012-07-27 18:21:50 +04:00
args = append(
args,
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
"limit",
Remove unneeded formatting.
2015-10-07 18:21:18 +03:00
opt.Offset,
opt.Count,
Add sorted sets support.
2012-07-27 18:21:50 +04:00
)
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewStringSliceCmd(ctx, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Add sorted sets support.
2012-07-27 18:21:50 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ZRangeByScore(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd {
return c.zRangeBy(ctx, "zrangebyscore", key, opt, false)
Implemented ZRangeByLex with tests.
2015-08-23 06:38:37 +03:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ZRangeByLex(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd {
return c.zRangeBy(ctx, "zrangebylex", key, opt, false)
Review API.
2012-08-17 22:36:48 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ZRangeByScoreWithScores(ctx context.Context, key string, opt *ZRangeBy) *ZSliceCmd {
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args := []interface{}{"zrangebyscore", key, opt.Min, opt.Max, "withscores"}
all: switch to gopkg.in.
2014-05-11 11:42:40 +04:00
if opt.Offset != 0 || opt.Count != 0 {
Add *Map commands where possible.
2013-02-02 16:17:01 +04:00
args = append(
args,
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
"limit",
Remove unneeded formatting.
2015-10-07 18:21:18 +03:00
opt.Offset,
opt.Count,
Add *Map commands where possible.
2013-02-02 16:17:01 +04:00
)
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewZSliceCmd(ctx, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Add *Map commands where possible.
2013-02-02 16:17:01 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ZRank(ctx context.Context, key, member string) *IntCmd {
cmd := NewIntCmd(ctx, "zrank", key, member)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Add sorted sets support.
2012-07-27 18:21:50 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ZRem(ctx context.Context, key string, members ...interface{}) *IntCmd {
Support []string slices in commands that accept multiple values
2018-03-08 15:30:27 +03:00
args := make([]interface{}, 2, 2+len(members))
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args[0] = "zrem"
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
args[1] = key
Support []string slices in commands that accept multiple values
2018-03-08 15:30:27 +03:00
args = appendArgs(args, members)
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewIntCmd(ctx, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Add sorted sets support.
2012-07-27 18:21:50 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ZRemRangeByRank(ctx context.Context, key string, start, stop int64) *IntCmd {
Rename req to cmd.
2014-06-25 11:40:56 +04:00
cmd := NewIntCmd(
Add ctx as first arg
2020-03-11 17:26:42 +03:00
ctx,
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
"zremrangebyrank",
Add sorted sets support.
2012-07-27 18:21:50 +04:00
key,
Remove unneeded formatting.
2015-10-07 18:21:18 +03:00
start,
stop,
Add sorted sets support.
2012-07-27 18:21:50 +04:00
)
Add ctx as first arg
2020-03-11 17:26:42 +03:00
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Add sorted sets support.
2012-07-27 18:21:50 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ZRemRangeByScore(ctx context.Context, key, min, max string) *IntCmd {
cmd := NewIntCmd(ctx, "zremrangebyscore", key, min, max)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Add sorted sets support.
2012-07-27 18:21:50 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ZRemRangeByLex(ctx context.Context, key, min, max string) *IntCmd {
cmd := NewIntCmd(ctx, "zremrangebylex", key, min, max)
_ = c(ctx, cmd)
Add ZRemRangeByLex.
2017-01-26 16:51:34 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ZRevRange(ctx context.Context, key string, start, stop int64) *StringSliceCmd {
cmd := NewStringSliceCmd(ctx, "zrevrange", key, start, stop)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Add sorted sets support.
2012-07-27 18:21:50 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ZRevRangeWithScores(ctx context.Context, key string, start, stop int64) *ZSliceCmd {
cmd := NewZSliceCmd(ctx, "zrevrange", key, start, stop, "withscores")
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Add *Map commands where possible.
2013-02-02 16:17:01 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) zRevRangeBy(ctx context.Context, zcmd, key string, opt *ZRangeBy) *StringSliceCmd {
Reverted change to struct ZRangeByScore, implemented ZRevRangeByLex.
2015-08-25 22:15:01 +03:00
args := []interface{}{zcmd, key, opt.Max, opt.Min}
all: switch to gopkg.in.
2014-05-11 11:42:40 +04:00
if opt.Offset != 0 || opt.Count != 0 {
Add sorted sets support.
2012-07-27 18:21:50 +04:00
args = append(
args,
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
"limit",
Remove unneeded formatting.
2015-10-07 18:21:18 +03:00
opt.Offset,
opt.Count,
Add sorted sets support.
2012-07-27 18:21:50 +04:00
)
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewStringSliceCmd(ctx, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Add sorted sets support.
2012-07-27 18:21:50 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ZRevRangeByScore(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd {
return c.zRevRangeBy(ctx, "zrevrangebyscore", key, opt)
Reverted change to struct ZRangeByScore, implemented ZRevRangeByLex.
2015-08-25 22:15:01 +03:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ZRevRangeByLex(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd {
return c.zRevRangeBy(ctx, "zrevrangebylex", key, opt)
Reverted change to struct ZRangeByScore, implemented ZRevRangeByLex.
2015-08-25 22:15:01 +03:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ZRevRangeByScoreWithScores(ctx context.Context, key string, opt *ZRangeBy) *ZSliceCmd {
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args := []interface{}{"zrevrangebyscore", key, opt.Max, opt.Min, "withscores"}
all: switch to gopkg.in.
2014-05-11 11:42:40 +04:00
if opt.Offset != 0 || opt.Count != 0 {
Add *Map commands where possible.
2013-02-02 16:17:01 +04:00
args = append(
args,
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
"limit",
Remove unneeded formatting.
2015-10-07 18:21:18 +03:00
opt.Offset,
opt.Count,
Add *Map commands where possible.
2013-02-02 16:17:01 +04:00
)
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewZSliceCmd(ctx, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Add *Map commands where possible.
2013-02-02 16:17:01 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ZRevRank(ctx context.Context, key, member string) *IntCmd {
cmd := NewIntCmd(ctx, "zrevrank", key, member)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Add sorted sets support.
2012-07-27 18:21:50 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ZScore(ctx context.Context, key, member string) *FloatCmd {
cmd := NewFloatCmd(ctx, "zscore", key, member)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Add sorted sets support.
2012-07-27 18:21:50 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ZUnionStore(ctx context.Context, dest string, store *ZStore) *IntCmd {
Move key to ZStore
2019-08-09 16:23:56 +03:00
args := make([]interface{}, 3+len(store.Keys))
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args[0] = "zunionstore"
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
args[1] = dest
Move key to ZStore
2019-08-09 16:23:56 +03:00
args[2] = len(store.Keys)
for i, key := range store.Keys {
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
args[3+i] = key
}
Review API.
2012-08-17 22:36:48 +04:00
if len(store.Weights) > 0 {
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args = append(args, "weights")
Review API.
2012-08-17 22:36:48 +04:00
for _, weight := range store.Weights {
Remove unneeded formatting.
2015-10-07 18:21:18 +03:00
args = append(args, weight)
Add sorted sets support.
2012-07-27 18:21:50 +04:00
}
}
Review API.
2012-08-17 22:36:48 +04:00
if store.Aggregate != "" {
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args = append(args, "aggregate", store.Aggregate)
Add sorted sets support.
2012-07-27 18:21:50 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewIntCmd(ctx, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Add sorted sets support.
2012-07-27 18:21:50 +04:00
}
parser: greatly simplify reply parsing.
2012-08-12 22:41:44 +04:00
//------------------------------------------------------------------------------
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) PFAdd(ctx context.Context, key string, els ...interface{}) *IntCmd {
Support []string slices in commands that accept multiple values
2018-03-08 15:30:27 +03:00
args := make([]interface{}, 2, 2+len(els))
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args[0] = "pfadd"
Implemented PFADD, PFCOUNT, PFMERGE
2015-11-04 10:34:58 +03:00
args[1] = key
Support []string slices in commands that accept multiple values
2018-03-08 15:30:27 +03:00
args = appendArgs(args, els)
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewIntCmd(ctx, args...)
_ = c(ctx, cmd)
Implemented PFADD, PFCOUNT, PFMERGE
2015-11-04 10:34:58 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) PFCount(ctx context.Context, keys ...string) *IntCmd {
Support multiple keys for the PFCOUNT command
2015-12-24 01:24:42 +03:00
args := make([]interface{}, 1+len(keys))
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args[0] = "pfcount"
Support multiple keys for the PFCOUNT command
2015-12-24 01:24:42 +03:00
for i, key := range keys {
args[1+i] = key
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewIntCmd(ctx, args...)
_ = c(ctx, cmd)
Implemented PFADD, PFCOUNT, PFMERGE
2015-11-04 10:34:58 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) PFMerge(ctx context.Context, dest string, keys ...string) *StatusCmd {
Implemented PFADD, PFCOUNT, PFMERGE
2015-11-04 10:34:58 +03:00
args := make([]interface{}, 2+len(keys))
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args[0] = "pfmerge"
Implemented PFADD, PFCOUNT, PFMERGE
2015-11-04 10:34:58 +03:00
args[1] = dest
for i, key := range keys {
args[2+i] = key
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewStatusCmd(ctx, args...)
_ = c(ctx, cmd)
Implemented PFADD, PFCOUNT, PFMERGE
2015-11-04 10:34:58 +03:00
return cmd
}
//------------------------------------------------------------------------------
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) BgRewriteAOF(ctx context.Context) *StatusCmd {
cmd := NewStatusCmd(ctx, "bgrewriteaof")
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
parser: greatly simplify reply parsing.
2012-08-12 22:41:44 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) BgSave(ctx context.Context) *StatusCmd {
cmd := NewStatusCmd(ctx, "bgsave")
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
parser: greatly simplify reply parsing.
2012-08-12 22:41:44 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ClientKill(ctx context.Context, ipPort string) *StatusCmd {
cmd := NewStatusCmd(ctx, "client", "kill", ipPort)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
parser: greatly simplify reply parsing.
2012-08-12 22:41:44 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
// ClientKillByFilter is new style syntax, while the ClientKill is old
Supports new style syntax of client kill command
2018-07-23 14:12:20 +03:00
// CLIENT KILL <option> [value] ... <option> [value]
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ClientKillByFilter(ctx context.Context, keys ...string) *IntCmd {
Supports new style syntax of client kill command
2018-07-23 14:12:20 +03:00
args := make([]interface{}, 2+len(keys))
args[0] = "client"
args[1] = "kill"
for i, key := range keys {
args[2+i] = key
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewIntCmd(ctx, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Add ClientPause command.
2015-05-15 15:11:22 +03:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ClientList(ctx context.Context) *StringCmd {
cmd := NewStringCmd(ctx, "client", "list")
_ = c(ctx, cmd)
Add ClientPause command.
2015-05-15 15:11:22 +03:00
return cmd
parser: greatly simplify reply parsing.
2012-08-12 22:41:44 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ClientPause(ctx context.Context, dur time.Duration) *BoolCmd {
cmd := NewBoolCmd(ctx, "client", "pause", formatMs(dur))
_ = c(ctx, cmd)
Add Client Id
2018-12-11 13:43:54 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ClientID(ctx context.Context) *IntCmd {
cmd := NewIntCmd(ctx, "client", "id")
_ = c(ctx, cmd)
ClientUnblock + ClientUnblockWithError
2018-12-14 17:46:15 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ClientUnblock(ctx context.Context, id int64) *IntCmd {
cmd := NewIntCmd(ctx, "client", "unblock", id)
_ = c(ctx, cmd)
Implement SetName and GetName Allows setting and getting the client connection name. http://redis.io/commands/client-setname http://redis.io/commands/client-getname
2015-10-20 22:21:58 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ClientUnblockWithError(ctx context.Context, id int64) *IntCmd {
cmd := NewIntCmd(ctx, "client", "unblock", id, "error")
_ = c(ctx, cmd)
Implement SetName and GetName Allows setting and getting the client connection name. http://redis.io/commands/client-setname http://redis.io/commands/client-getname
2015-10-20 22:21:58 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ConfigGet(ctx context.Context, parameter string) *SliceCmd {
cmd := NewSliceCmd(ctx, "config", "get", parameter)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
parser: greatly simplify reply parsing.
2012-08-12 22:41:44 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ConfigResetStat(ctx context.Context) *StatusCmd {
cmd := NewStatusCmd(ctx, "config", "resetstat")
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
parser: greatly simplify reply parsing.
2012-08-12 22:41:44 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ConfigSet(ctx context.Context, parameter, value string) *StatusCmd {
cmd := NewStatusCmd(ctx, "config", "set", parameter, value)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
parser: greatly simplify reply parsing.
2012-08-12 22:41:44 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ConfigRewrite(ctx context.Context) *StatusCmd {
cmd := NewStatusCmd(ctx, "config", "rewrite")
_ = c(ctx, cmd)
Impement Config Rewrite command (#722) This commit adds support for config rewrite as documented in https://redis.io/commands/config-rewrite .
2018-03-01 11:37:51 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) DBSize(ctx context.Context) *IntCmd {
cmd := NewIntCmd(ctx, "dbsize")
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
parser: greatly simplify reply parsing.
2012-08-12 22:41:44 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) FlushAll(ctx context.Context) *StatusCmd {
cmd := NewStatusCmd(ctx, "flushall")
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
parser: greatly simplify reply parsing.
2012-08-12 22:41:44 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) FlushAllAsync(ctx context.Context) *StatusCmd {
cmd := NewStatusCmd(ctx, "flushall", "async")
_ = c(ctx, cmd)
Add FlushDBAsync and FlushAllAsync
2017-06-17 12:53:16 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) FlushDB(ctx context.Context) *StatusCmd {
cmd := NewStatusCmd(ctx, "flushdb")
_ = c(ctx, cmd)
Add FlushDBAsync and FlushAllAsync
2017-06-17 12:53:16 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) FlushDBAsync(ctx context.Context) *StatusCmd {
cmd := NewStatusCmd(ctx, "flushdb", "async")
_ = c(ctx, cmd)
Add FlushDBAsync and FlushAllAsync
2017-06-17 12:53:16 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) Info(ctx context.Context, section ...string) *StringCmd {
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args := []interface{}{"info"}
commands.go: add section parameter to Info function.
2016-01-08 16:03:34 +03:00
if len(section) > 0 {
args = append(args, section[0])
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewStringCmd(ctx, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
parser: greatly simplify reply parsing.
2012-08-12 22:41:44 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) LastSave(ctx context.Context) *IntCmd {
cmd := NewIntCmd(ctx, "lastsave")
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
parser: greatly simplify reply parsing.
2012-08-12 22:41:44 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) Save(ctx context.Context) *StatusCmd {
cmd := NewStatusCmd(ctx, "save")
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
parser: greatly simplify reply parsing.
2012-08-12 22:41:44 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) shutdown(ctx context.Context, modifier string) *StatusCmd {
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
var args []interface{}
Add SHUTDOWN command.
2012-08-25 16:35:39 +04:00
if modifier == "" {
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args = []interface{}{"shutdown"}
Add SHUTDOWN command.
2012-08-25 16:35:39 +04:00
} else {
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args = []interface{}{"shutdown", modifier}
Add SHUTDOWN command.
2012-08-25 16:35:39 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewStatusCmd(ctx, args...)
_ = c(ctx, cmd)
Fix rate limiter and add test.
2014-11-13 15:26:14 +03:00
if err := cmd.Err(); err != nil {
if err == io.EOF {
// Server quit as expected.
cmd.err = nil
}
} else {
// Server did not quit. String reply contains the reason.
Fix proto.RedisError in slices
2018-02-22 15:14:30 +03:00
cmd.err = errors.New(cmd.val)
Fix rate limiter and add test.
2014-11-13 15:26:14 +03:00
cmd.val = ""
}
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Add SHUTDOWN command.
2012-08-25 16:35:39 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) Shutdown(ctx context.Context) *StatusCmd {
return c.shutdown(ctx, "")
Add SHUTDOWN command.
2012-08-25 16:35:39 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ShutdownSave(ctx context.Context) *StatusCmd {
return c.shutdown(ctx, "save")
Add SHUTDOWN command.
2012-08-25 16:35:39 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ShutdownNoSave(ctx context.Context) *StatusCmd {
return c.shutdown(ctx, "nosave")
parser: greatly simplify reply parsing.
2012-08-12 22:41:44 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) SlaveOf(ctx context.Context, host, port string) *StatusCmd {
cmd := NewStatusCmd(ctx, "slaveof", host, port)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
parser: greatly simplify reply parsing.
2012-08-12 22:41:44 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) SlowLog(ctx context.Context) {
parser: greatly simplify reply parsing.
2012-08-12 22:41:44 +04:00
panic("not implemented")
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) Sync(ctx context.Context) {
parser: greatly simplify reply parsing.
2012-08-12 22:41:44 +04:00
panic("not implemented")
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) Time(ctx context.Context) *TimeCmd {
cmd := NewTimeCmd(ctx, "time")
_ = c(ctx, cmd)
return cmd
}
func (c cmdable) DebugObject(ctx context.Context, key string) *StringCmd {
cmd := NewStringCmd(ctx, "debug", "object", key)
_ = c(ctx, cmd)
return cmd
}
func (c cmdable) ReadOnly(ctx context.Context) *StatusCmd {
cmd := NewStatusCmd(ctx, "readonly")
_ = c(ctx, cmd)
return cmd
}
func (c cmdable) ReadWrite(ctx context.Context) *StatusCmd {
cmd := NewStatusCmd(ctx, "readwrite")
_ = c(ctx, cmd)
return cmd
}
func (c cmdable) MemoryUsage(ctx context.Context, key string, samples ...int) *IntCmd {
args := []interface{}{"memory", "usage", key}
if len(samples) > 0 {
if len(samples) != 1 {
panic("MemoryUsage expects single sample count")
}
args = append(args, "SAMPLES", samples[0])
}
cmd := NewIntCmd(ctx, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
parser: greatly simplify reply parsing.
2012-08-12 22:41:44 +04:00
}
Add support for scripting commands.
2012-08-20 14:42:33 +04:00
//------------------------------------------------------------------------------
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) Eval(ctx context.Context, script string, keys []string, args ...interface{}) *Cmd {
Support []string slices in commands that accept multiple values
2018-03-08 15:30:27 +03:00
cmdArgs := make([]interface{}, 3+len(keys), 3+len(keys)+len(args))
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
cmdArgs[0] = "eval"
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
cmdArgs[1] = script
Remove manual strconv
2017-03-24 13:48:32 +03:00
cmdArgs[2] = len(keys)
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
for i, key := range keys {
cmdArgs[3+i] = key
}
Support []string slices in commands that accept multiple values
2018-03-08 15:30:27 +03:00
cmdArgs = appendArgs(cmdArgs, args)
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewCmd(ctx, cmdArgs...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Add support for scripting commands.
2012-08-20 14:42:33 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) EvalSha(ctx context.Context, sha1 string, keys []string, args ...interface{}) *Cmd {
Support []string slices in commands that accept multiple values
2018-03-08 15:30:27 +03:00
cmdArgs := make([]interface{}, 3+len(keys), 3+len(keys)+len(args))
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
cmdArgs[0] = "evalsha"
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
cmdArgs[1] = sha1
Remove manual strconv
2017-03-24 13:48:32 +03:00
cmdArgs[2] = len(keys)
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
for i, key := range keys {
cmdArgs[3+i] = key
}
Support []string slices in commands that accept multiple values
2018-03-08 15:30:27 +03:00
cmdArgs = appendArgs(cmdArgs, args)
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewCmd(ctx, cmdArgs...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Add support for scripting commands.
2012-08-20 14:42:33 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ScriptExists(ctx context.Context, hashes ...string) *BoolSliceCmd {
Script: Fix `Exists` to use hash instead of source (#726) `SCRIPT EXISTS` accepts a hash, not the raw source: https://redis.io/commands/script-exists
2018-03-05 11:54:11 +03:00
args := make([]interface{}, 2+len(hashes))
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args[0] = "script"
args[1] = "exists"
Script: Fix `Exists` to use hash instead of source (#726) `SCRIPT EXISTS` accepts a hash, not the raw source: https://redis.io/commands/script-exists
2018-03-05 11:54:11 +03:00
for i, hash := range hashes {
args[2+i] = hash
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewBoolSliceCmd(ctx, args...)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
all: switch to gopkg.in.
2014-05-11 11:42:40 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ScriptFlush(ctx context.Context) *StatusCmd {
cmd := NewStatusCmd(ctx, "script", "flush")
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Add support for scripting commands.
2012-08-20 14:42:33 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ScriptKill(ctx context.Context) *StatusCmd {
cmd := NewStatusCmd(ctx, "script", "kill")
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Add support for scripting commands.
2012-08-20 14:42:33 +04:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ScriptLoad(ctx context.Context, script string) *StringCmd {
cmd := NewStringCmd(ctx, "script", "load", script)
_ = c(ctx, cmd)
Rename req to cmd.
2014-06-25 11:40:56 +04:00
return cmd
Add support for scripting commands.
2012-08-20 14:42:33 +04:00
}
Add pubsub* commands.
2014-10-07 14:06:41 +04:00
//------------------------------------------------------------------------------
Move Publish channel to cmdable. Remove method that was deprecated in v3.
2016-07-21 16:04:40 +03:00
// Publish posts the message to the channel.
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) Publish(ctx context.Context, channel string, message interface{}) *IntCmd {
cmd := NewIntCmd(ctx, "publish", channel, message)
_ = c(ctx, cmd)
Move Publish channel to cmdable. Remove method that was deprecated in v3.
2016-07-21 16:04:40 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) PubSubChannels(ctx context.Context, pattern string) *StringSliceCmd {
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args := []interface{}{"pubsub", "channels"}
Add optimization for '*' pattern in PubSubChannels.
2014-10-07 16:40:00 +04:00
if pattern != "*" {
args = append(args, pattern)
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewStringSliceCmd(ctx, args...)
_ = c(ctx, cmd)
Add pubsub* commands.
2014-10-07 14:06:41 +04:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) PubSubNumSub(ctx context.Context, channels ...string) *StringIntMapCmd {
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
args := make([]interface{}, 2+len(channels))
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args[0] = "pubsub"
args[1] = "numsub"
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
for i, channel := range channels {
args[2+i] = channel
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewStringIntMapCmd(ctx, args...)
_ = c(ctx, cmd)
Add pubsub* commands.
2014-10-07 14:06:41 +04:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) PubSubNumPat(ctx context.Context) *IntCmd {
cmd := NewIntCmd(ctx, "pubsub", "numpat")
_ = c(ctx, cmd)
Add Redis Cluster support.
2015-01-24 15:12:48 +03:00
return cmd
}
//------------------------------------------------------------------------------
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ClusterSlots(ctx context.Context) *ClusterSlotsCmd {
cmd := NewClusterSlotsCmd(ctx, "cluster", "slots")
_ = c(ctx, cmd)
Add Redis Cluster support.
2015-01-24 15:12:48 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ClusterNodes(ctx context.Context) *StringCmd {
cmd := NewStringCmd(ctx, "cluster", "nodes")
_ = c(ctx, cmd)
Add Redis Cluster support.
2015-01-24 15:12:48 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ClusterMeet(ctx context.Context, host, port string) *StatusCmd {
cmd := NewStatusCmd(ctx, "cluster", "meet", host, port)
_ = c(ctx, cmd)
Add pubsub* commands.
2014-10-07 14:06:41 +04:00
return cmd
}
Add Redis Cluster support.
2015-01-24 15:12:48 +03:00
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ClusterForget(ctx context.Context, nodeID string) *StatusCmd {
cmd := NewStatusCmd(ctx, "cluster", "forget", nodeID)
_ = c(ctx, cmd)
Added CLUSTER FORGET command
2015-12-09 12:33:37 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ClusterReplicate(ctx context.Context, nodeID string) *StatusCmd {
cmd := NewStatusCmd(ctx, "cluster", "replicate", nodeID)
_ = c(ctx, cmd)
Add Redis Cluster support.
2015-01-24 15:12:48 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ClusterResetSoft(ctx context.Context) *StatusCmd {
cmd := NewStatusCmd(ctx, "cluster", "reset", "soft")
_ = c(ctx, cmd)
commands: add cluster reset function.
2015-12-21 19:53:02 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ClusterResetHard(ctx context.Context) *StatusCmd {
cmd := NewStatusCmd(ctx, "cluster", "reset", "hard")
_ = c(ctx, cmd)
commands: add cluster reset function.
2015-12-21 19:53:02 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ClusterInfo(ctx context.Context) *StringCmd {
cmd := NewStringCmd(ctx, "cluster", "info")
_ = c(ctx, cmd)
Add Redis Cluster support.
2015-01-24 15:12:48 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ClusterKeySlot(ctx context.Context, key string) *IntCmd {
cmd := NewIntCmd(ctx, "cluster", "keyslot", key)
_ = c(ctx, cmd)
commands.go: Add ClusterKeySlot function.
2015-12-28 19:58:04 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ClusterGetKeysInSlot(ctx context.Context, slot int, count int) *StringSliceCmd {
cmd := NewStringSliceCmd(ctx, "cluster", "getkeysinslot", slot, count)
_ = c(ctx, cmd)
:sparkles: Add GETKEYSINSLOT api call for clustered redis
2019-01-29 21:39:58 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ClusterCountFailureReports(ctx context.Context, nodeID string) *IntCmd {
cmd := NewIntCmd(ctx, "cluster", "count-failure-reports", nodeID)
_ = c(ctx, cmd)
commands.go: Add new functions to cluster.
2015-12-29 19:16:14 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ClusterCountKeysInSlot(ctx context.Context, slot int) *IntCmd {
cmd := NewIntCmd(ctx, "cluster", "countkeysinslot", slot)
_ = c(ctx, cmd)
commands.go: Add new functions to cluster.
2015-12-29 19:16:14 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ClusterDelSlots(ctx context.Context, slots ...int) *StatusCmd {
commands.go: Add new functions to cluster.
2015-12-29 19:16:14 +03:00
args := make([]interface{}, 2+len(slots))
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args[0] = "cluster"
args[1] = "delslots"
commands.go: Add new functions to cluster.
2015-12-29 19:16:14 +03:00
for i, slot := range slots {
args[2+i] = slot
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewStatusCmd(ctx, args...)
_ = c(ctx, cmd)
commands.go: Add new functions to cluster.
2015-12-29 19:16:14 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ClusterDelSlotsRange(ctx context.Context, min, max int) *StatusCmd {
commands.go: Add new functions to cluster.
2015-12-29 19:16:14 +03:00
size := max - min + 1
slots := make([]int, size)
for i := 0; i < size; i++ {
slots[i] = min + i
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
return c.ClusterDelSlots(ctx, slots...)
commands.go: Add new functions to cluster.
2015-12-29 19:16:14 +03:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ClusterSaveConfig(ctx context.Context) *StatusCmd {
cmd := NewStatusCmd(ctx, "cluster", "saveconfig")
_ = c(ctx, cmd)
commands.go: Add new functions to cluster.
2015-12-29 19:16:14 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ClusterSlaves(ctx context.Context, nodeID string) *StringSliceCmd {
cmd := NewStringSliceCmd(ctx, "cluster", "slaves", nodeID)
_ = c(ctx, cmd)
commands.go: Add new functions to cluster.
2015-12-29 19:16:14 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ClusterFailover(ctx context.Context) *StatusCmd {
cmd := NewStatusCmd(ctx, "cluster", "failover")
_ = c(ctx, cmd)
commands.go: Add new functions to cluster.
2015-12-29 19:16:14 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ClusterAddSlots(ctx context.Context, slots ...int) *StatusCmd {
Allow setting and scaning interface{} values.
2015-05-28 15:51:19 +03:00
args := make([]interface{}, 2+len(slots))
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args[0] = "cluster"
args[1] = "addslots"
Add Redis Cluster support.
2015-01-24 15:12:48 +03:00
for i, num := range slots {
Remove manual strconv
2017-03-24 13:48:32 +03:00
args[2+i] = num
Add Redis Cluster support.
2015-01-24 15:12:48 +03:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewStatusCmd(ctx, args...)
_ = c(ctx, cmd)
Add Redis Cluster support.
2015-01-24 15:12:48 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) ClusterAddSlotsRange(ctx context.Context, min, max int) *StatusCmd {
Add Redis Cluster support.
2015-01-24 15:12:48 +03:00
size := max - min + 1
slots := make([]int, size)
for i := 0; i < size; i++ {
slots[i] = min + i
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
return c.ClusterAddSlots(ctx, slots...)
Add Redis Cluster support.
2015-01-24 15:12:48 +03:00
}
Added binding for GEOADD and GEORADIUS.
2015-09-20 16:13:13 +03:00
//------------------------------------------------------------------------------
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) GeoAdd(ctx context.Context, key string, geoLocation ...*GeoLocation) *IntCmd {
Added binding for GEOADD and GEORADIUS.
2015-09-20 16:13:13 +03:00
args := make([]interface{}, 2+3*len(geoLocation))
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args[0] = "geoadd"
Added binding for GEOADD and GEORADIUS.
2015-09-20 16:13:13 +03:00
args[1] = key
for i, eachLoc := range geoLocation {
args[2+3*i] = eachLoc.Longitude
args[2+3*i+1] = eachLoc.Latitude
args[2+3*i+2] = eachLoc.Name
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewIntCmd(ctx, args...)
_ = c(ctx, cmd)
Added binding for GEOADD and GEORADIUS.
2015-09-20 16:13:13 +03:00
return cmd
}
Add writing version of GeoRadius commands
2019-08-09 15:04:56 +03:00
// GeoRadius is a read-only GEORADIUS_RO command.
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) GeoRadius(ctx context.Context, key string, longitude, latitude float64, query *GeoRadiusQuery) *GeoLocationCmd {
cmd := NewGeoLocationCmd(ctx, query, "georadius_ro", key, longitude, latitude)
Add writing version of GeoRadius commands
2019-08-09 15:04:56 +03:00
if query.Store != "" || query.StoreDist != "" {
Exported the setErr function as public
2020-02-03 12:53:47 +03:00
cmd.SetErr(errors.New("GeoRadius does not support Store or StoreDist"))
Add writing version of GeoRadius commands
2019-08-09 15:04:56 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
_ = c(ctx, cmd)
Added binding for GEOADD and GEORADIUS.
2015-09-20 16:13:13 +03:00
return cmd
}
Added binding for GEORADIUSBYMEMBER, GEODIST AND GEOHASH. Change-Id: Ia6144617f42629af4c022e595c444ddc6d66f1a3
2015-10-15 00:39:39 +03:00
Add writing version of GeoRadius commands
2019-08-09 15:04:56 +03:00
// GeoRadiusStore is a writing GEORADIUS command.
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) GeoRadiusStore(ctx context.Context, key string, longitude, latitude float64, query *GeoRadiusQuery) *IntCmd {
Add writing version of GeoRadius commands
2019-08-09 15:04:56 +03:00
args := geoLocationArgs(query, "georadius", key, longitude, latitude)
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewIntCmd(ctx, args...)
Add writing version of GeoRadius commands
2019-08-09 15:04:56 +03:00
if query.Store == "" && query.StoreDist == "" {
Exported the setErr function as public
2020-02-03 12:53:47 +03:00
cmd.SetErr(errors.New("GeoRadiusStore requires Store or StoreDist"))
Add writing version of GeoRadius commands
2019-08-09 15:04:56 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
_ = c(ctx, cmd)
Add Geo commands read-only variants
2017-07-19 15:32:50 +03:00
return cmd
}
Add writing version of GeoRadius commands
2019-08-09 15:04:56 +03:00
// GeoRadius is a read-only GEORADIUSBYMEMBER_RO command.
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) GeoRadiusByMember(ctx context.Context, key, member string, query *GeoRadiusQuery) *GeoLocationCmd {
cmd := NewGeoLocationCmd(ctx, query, "georadiusbymember_ro", key, member)
Add writing version of GeoRadius commands
2019-08-09 15:04:56 +03:00
if query.Store != "" || query.StoreDist != "" {
Exported the setErr function as public
2020-02-03 12:53:47 +03:00
cmd.SetErr(errors.New("GeoRadiusByMember does not support Store or StoreDist"))
Add writing version of GeoRadius commands
2019-08-09 15:04:56 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
_ = c(ctx, cmd)
Fix GeoRadius reply parsing.
2015-11-14 17:36:21 +03:00
return cmd
Added binding for GEORADIUSBYMEMBER, GEODIST AND GEOHASH. Change-Id: Ia6144617f42629af4c022e595c444ddc6d66f1a3
2015-10-15 00:39:39 +03:00
}
Add writing version of GeoRadius commands
2019-08-09 15:04:56 +03:00
// GeoRadiusByMemberStore is a writing GEORADIUSBYMEMBER command.
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) GeoRadiusByMemberStore(ctx context.Context, key, member string, query *GeoRadiusQuery) *IntCmd {
Add writing version of GeoRadius commands
2019-08-09 15:04:56 +03:00
args := geoLocationArgs(query, "georadiusbymember", key, member)
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewIntCmd(ctx, args...)
Add writing version of GeoRadius commands
2019-08-09 15:04:56 +03:00
if query.Store == "" && query.StoreDist == "" {
Exported the setErr function as public
2020-02-03 12:53:47 +03:00
cmd.SetErr(errors.New("GeoRadiusByMemberStore requires Store or StoreDist"))
Add writing version of GeoRadius commands
2019-08-09 15:04:56 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
_ = c(ctx, cmd)
Add Geo commands read-only variants
2017-07-19 15:32:50 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) GeoDist(ctx context.Context, key string, member1, member2, unit string) *FloatCmd {
Added binding for GEORADIUSBYMEMBER, GEODIST AND GEOHASH. Change-Id: Ia6144617f42629af4c022e595c444ddc6d66f1a3
2015-10-15 00:39:39 +03:00
if unit == "" {
unit = "km"
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewFloatCmd(ctx, "geodist", key, member1, member2, unit)
_ = c(ctx, cmd)
Added binding for GEORADIUSBYMEMBER, GEODIST AND GEOHASH. Change-Id: Ia6144617f42629af4c022e595c444ddc6d66f1a3
2015-10-15 00:39:39 +03:00
return cmd
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) GeoHash(ctx context.Context, key string, members ...string) *StringSliceCmd {
Added binding for GEORADIUSBYMEMBER, GEODIST AND GEOHASH. Change-Id: Ia6144617f42629af4c022e595c444ddc6d66f1a3
2015-10-15 00:39:39 +03:00
args := make([]interface{}, 2+len(members))
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
args[0] = "geohash"
Added binding for GEORADIUSBYMEMBER, GEODIST AND GEOHASH. Change-Id: Ia6144617f42629af4c022e595c444ddc6d66f1a3
2015-10-15 00:39:39 +03:00
args[1] = key
for i, member := range members {
args[2+i] = member
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewStringSliceCmd(ctx, args...)
_ = c(ctx, cmd)
Added binding for GEORADIUSBYMEMBER, GEODIST AND GEOHASH. Change-Id: Ia6144617f42629af4c022e595c444ddc6d66f1a3
2015-10-15 00:39:39 +03:00
return cmd
}
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
Add ctx as first arg
2020-03-11 17:26:42 +03:00
func (c cmdable) GeoPos(ctx context.Context, key string, members ...string) *GeoPosCmd {
Rename GeoPosition to GeoPos for consistency with Redis Server. Simplify code where possible.
2016-08-22 12:39:22 +03:00
args := make([]interface{}, 2+len(members))
support geopos command
2016-08-22 00:32:06 +03:00
args[0] = "geopos"
args[1] = key
Rename GeoPosition to GeoPos for consistency with Redis Server. Simplify code where possible.
2016-08-22 12:39:22 +03:00
for i, member := range members {
args[2+i] = member
support geopos command
2016-08-22 00:32:06 +03:00
}
Add ctx as first arg
2020-03-11 17:26:42 +03:00
cmd := NewGeoPosCmd(ctx, args...)
_ = c(ctx, cmd)
Add latency based routing to Redis Cluster client.
2016-05-06 21:12:31 +03:00
return cmd
}