ArchiveTeam
/
reshovel
11
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1 Commit
1 Branch
160 KiB
 
Tree: 2f1d008ddc
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '2f1d008ddc'
${ noResults }
reshovel/vendor/github.com/go-redis/redis/v8/commands.go

3430 lines
99 KiB
Raw Blame History 

  1. package redis

  2. 

  3. import (

  4. 	"context"

  5. 	"errors"

  6. 	"io"

  7. 	"time"

  8. 

  9. 	"github.com/go-redis/redis/v8/internal"

  10. )

  11. 

  12. // KeepTTL is a Redis KEEPTTL option to keep existing TTL, it requires your redis-server version >= 6.0,

  13. // otherwise you will receive an error: (error) ERR syntax error.

  14. // For example:

  15. //

  16. //    rdb.Set(ctx, key, value, redis.KeepTTL)

  17. const KeepTTL = -1

  18. 

  19. func usePrecise(dur time.Duration) bool {

  20. 	return dur < time.Second || dur%time.Second != 0

  21. }

  22. 

  23. func formatMs(ctx context.Context, dur time.Duration) int64 {

  24. 	if dur > 0 && dur < time.Millisecond {

  25. 		internal.Logger.Printf(

  26. 			ctx,

  27. 			"specified duration is %s, but minimal supported value is %s - truncating to 1ms",

  28. 			dur, time.Millisecond,

  29. 		)

  30. 		return 1

  31. 	}

  32. 	return int64(dur / time.Millisecond)

  33. }

  34. 

  35. func formatSec(ctx context.Context, dur time.Duration) int64 {

  36. 	if dur > 0 && dur < time.Second {

  37. 		internal.Logger.Printf(

  38. 			ctx,

  39. 			"specified duration is %s, but minimal supported value is %s - truncating to 1s",

  40. 			dur, time.Second,

  41. 		)

  42. 		return 1

  43. 	}

  44. 	return int64(dur / time.Second)

  45. }

  46. 

  47. func appendArgs(dst, src []interface{}) []interface{} {

  48. 	if len(src) == 1 {

  49. 		return appendArg(dst, src[0])

  50. 	}

  51. 

  52. 	dst = append(dst, src...)

  53. 	return dst

  54. }

  55. 

  56. func appendArg(dst []interface{}, arg interface{}) []interface{} {

  57. 	switch arg := arg.(type) {

  58. 	case []string:

  59. 		for _, s := range arg {

  60. 			dst = append(dst, s)

  61. 		}

  62. 		return dst

  63. 	case []interface{}:

  64. 		dst = append(dst, arg...)

  65. 		return dst

  66. 	case map[string]interface{}:

  67. 		for k, v := range arg {

  68. 			dst = append(dst, k, v)

  69. 		}

  70. 		return dst

  71. 	case map[string]string:

  72. 		for k, v := range arg {

  73. 			dst = append(dst, k, v)

  74. 		}

  75. 		return dst

  76. 	default:

  77. 		return append(dst, arg)

  78. 	}

  79. }

  80. 

  81. type Cmdable interface {

  82. 	Pipeline() Pipeliner

  83. 	Pipelined(ctx context.Context, fn func(Pipeliner) error) ([]Cmder, error)

  84. 

  85. 	TxPipelined(ctx context.Context, fn func(Pipeliner) error) ([]Cmder, error)

  86. 	TxPipeline() Pipeliner

  87. 

  88. 	Command(ctx context.Context) *CommandsInfoCmd

  89. 	ClientGetName(ctx context.Context) *StringCmd

  90. 	Echo(ctx context.Context, message interface{}) *StringCmd

  91. 	Ping(ctx context.Context) *StatusCmd

  92. 	Quit(ctx context.Context) *StatusCmd

  93. 	Del(ctx context.Context, keys ...string) *IntCmd

  94. 	Unlink(ctx context.Context, keys ...string) *IntCmd

  95. 	Dump(ctx context.Context, key string) *StringCmd

  96. 	Exists(ctx context.Context, keys ...string) *IntCmd

  97. 	Expire(ctx context.Context, key string, expiration time.Duration) *BoolCmd

  98. 	ExpireAt(ctx context.Context, key string, tm time.Time) *BoolCmd

  99. 	Keys(ctx context.Context, pattern string) *StringSliceCmd

  100. 	Migrate(ctx context.Context, host, port, key string, db int, timeout time.Duration) *StatusCmd

  101. 	Move(ctx context.Context, key string, db int) *BoolCmd

  102. 	ObjectRefCount(ctx context.Context, key string) *IntCmd

  103. 	ObjectEncoding(ctx context.Context, key string) *StringCmd

  104. 	ObjectIdleTime(ctx context.Context, key string) *DurationCmd

  105. 	Persist(ctx context.Context, key string) *BoolCmd

  106. 	PExpire(ctx context.Context, key string, expiration time.Duration) *BoolCmd

  107. 	PExpireAt(ctx context.Context, key string, tm time.Time) *BoolCmd

  108. 	PTTL(ctx context.Context, key string) *DurationCmd

  109. 	RandomKey(ctx context.Context) *StringCmd

  110. 	Rename(ctx context.Context, key, newkey string) *StatusCmd

  111. 	RenameNX(ctx context.Context, key, newkey string) *BoolCmd

  112. 	Restore(ctx context.Context, key string, ttl time.Duration, value string) *StatusCmd

  113. 	RestoreReplace(ctx context.Context, key string, ttl time.Duration, value string) *StatusCmd

  114. 	Sort(ctx context.Context, key string, sort *Sort) *StringSliceCmd

  115. 	SortStore(ctx context.Context, key, store string, sort *Sort) *IntCmd

  116. 	SortInterfaces(ctx context.Context, key string, sort *Sort) *SliceCmd

  117. 	Touch(ctx context.Context, keys ...string) *IntCmd

  118. 	TTL(ctx context.Context, key string) *DurationCmd

  119. 	Type(ctx context.Context, key string) *StatusCmd

  120. 	Append(ctx context.Context, key, value string) *IntCmd

  121. 	Decr(ctx context.Context, key string) *IntCmd

  122. 	DecrBy(ctx context.Context, key string, decrement int64) *IntCmd

  123. 	Get(ctx context.Context, key string) *StringCmd

  124. 	GetRange(ctx context.Context, key string, start, end int64) *StringCmd

  125. 	GetSet(ctx context.Context, key string, value interface{}) *StringCmd

  126. 	GetEx(ctx context.Context, key string, expiration time.Duration) *StringCmd

  127. 	GetDel(ctx context.Context, key string) *StringCmd

  128. 	Incr(ctx context.Context, key string) *IntCmd

  129. 	IncrBy(ctx context.Context, key string, value int64) *IntCmd

  130. 	IncrByFloat(ctx context.Context, key string, value float64) *FloatCmd

  131. 	MGet(ctx context.Context, keys ...string) *SliceCmd

  132. 	MSet(ctx context.Context, values ...interface{}) *StatusCmd

  133. 	MSetNX(ctx context.Context, values ...interface{}) *BoolCmd

  134. 	Set(ctx context.Context, key string, value interface{}, expiration time.Duration) *StatusCmd

  135. 	SetArgs(ctx context.Context, key string, value interface{}, a SetArgs) *StatusCmd

  136. 	// TODO: rename to SetEx

  137. 	SetEX(ctx context.Context, key string, value interface{}, expiration time.Duration) *StatusCmd

  138. 	SetNX(ctx context.Context, key string, value interface{}, expiration time.Duration) *BoolCmd

  139. 	SetXX(ctx context.Context, key string, value interface{}, expiration time.Duration) *BoolCmd

  140. 	SetRange(ctx context.Context, key string, offset int64, value string) *IntCmd

  141. 	StrLen(ctx context.Context, key string) *IntCmd

  142. 

  143. 	GetBit(ctx context.Context, key string, offset int64) *IntCmd

  144. 	SetBit(ctx context.Context, key string, offset int64, value int) *IntCmd

  145. 	BitCount(ctx context.Context, key string, bitCount *BitCount) *IntCmd

  146. 	BitOpAnd(ctx context.Context, destKey string, keys ...string) *IntCmd

  147. 	BitOpOr(ctx context.Context, destKey string, keys ...string) *IntCmd

  148. 	BitOpXor(ctx context.Context, destKey string, keys ...string) *IntCmd

  149. 	BitOpNot(ctx context.Context, destKey string, key string) *IntCmd

  150. 	BitPos(ctx context.Context, key string, bit int64, pos ...int64) *IntCmd

  151. 	BitField(ctx context.Context, key string, args ...interface{}) *IntSliceCmd

  152. 

  153. 	Scan(ctx context.Context, cursor uint64, match string, count int64) *ScanCmd

  154. 	ScanType(ctx context.Context, cursor uint64, match string, count int64, keyType string) *ScanCmd

  155. 	SScan(ctx context.Context, key string, cursor uint64, match string, count int64) *ScanCmd

  156. 	HScan(ctx context.Context, key string, cursor uint64, match string, count int64) *ScanCmd

  157. 	ZScan(ctx context.Context, key string, cursor uint64, match string, count int64) *ScanCmd

  158. 

  159. 	HDel(ctx context.Context, key string, fields ...string) *IntCmd

  160. 	HExists(ctx context.Context, key, field string) *BoolCmd

  161. 	HGet(ctx context.Context, key, field string) *StringCmd

  162. 	HGetAll(ctx context.Context, key string) *StringStringMapCmd

  163. 	HIncrBy(ctx context.Context, key, field string, incr int64) *IntCmd

  164. 	HIncrByFloat(ctx context.Context, key, field string, incr float64) *FloatCmd

  165. 	HKeys(ctx context.Context, key string) *StringSliceCmd

  166. 	HLen(ctx context.Context, key string) *IntCmd

  167. 	HMGet(ctx context.Context, key string, fields ...string) *SliceCmd

  168. 	HSet(ctx context.Context, key string, values ...interface{}) *IntCmd

  169. 	HMSet(ctx context.Context, key string, values ...interface{}) *BoolCmd

  170. 	HSetNX(ctx context.Context, key, field string, value interface{}) *BoolCmd

  171. 	HVals(ctx context.Context, key string) *StringSliceCmd

  172. 	HRandField(ctx context.Context, key string, count int, withValues bool) *StringSliceCmd

  173. 

  174. 	BLPop(ctx context.Context, timeout time.Duration, keys ...string) *StringSliceCmd

  175. 	BRPop(ctx context.Context, timeout time.Duration, keys ...string) *StringSliceCmd

  176. 	BRPopLPush(ctx context.Context, source, destination string, timeout time.Duration) *StringCmd

  177. 	LIndex(ctx context.Context, key string, index int64) *StringCmd

  178. 	LInsert(ctx context.Context, key, op string, pivot, value interface{}) *IntCmd

  179. 	LInsertBefore(ctx context.Context, key string, pivot, value interface{}) *IntCmd

  180. 	LInsertAfter(ctx context.Context, key string, pivot, value interface{}) *IntCmd

  181. 	LLen(ctx context.Context, key string) *IntCmd

  182. 	LPop(ctx context.Context, key string) *StringCmd

  183. 	LPopCount(ctx context.Context, key string, count int) *StringSliceCmd

  184. 	LPos(ctx context.Context, key string, value string, args LPosArgs) *IntCmd

  185. 	LPosCount(ctx context.Context, key string, value string, count int64, args LPosArgs) *IntSliceCmd

  186. 	LPush(ctx context.Context, key string, values ...interface{}) *IntCmd

  187. 	LPushX(ctx context.Context, key string, values ...interface{}) *IntCmd

  188. 	LRange(ctx context.Context, key string, start, stop int64) *StringSliceCmd

  189. 	LRem(ctx context.Context, key string, count int64, value interface{}) *IntCmd

  190. 	LSet(ctx context.Context, key string, index int64, value interface{}) *StatusCmd

  191. 	LTrim(ctx context.Context, key string, start, stop int64) *StatusCmd

  192. 	RPop(ctx context.Context, key string) *StringCmd

  193. 	RPopCount(ctx context.Context, key string, count int) *StringSliceCmd

  194. 	RPopLPush(ctx context.Context, source, destination string) *StringCmd

  195. 	RPush(ctx context.Context, key string, values ...interface{}) *IntCmd

  196. 	RPushX(ctx context.Context, key string, values ...interface{}) *IntCmd

  197. 	LMove(ctx context.Context, source, destination, srcpos, destpos string) *StringCmd

  198. 	BLMove(ctx context.Context, source, destination, srcpos, destpos string, timeout time.Duration) *StringCmd

  199. 

  200. 	SAdd(ctx context.Context, key string, members ...interface{}) *IntCmd

  201. 	SCard(ctx context.Context, key string) *IntCmd

  202. 	SDiff(ctx context.Context, keys ...string) *StringSliceCmd

  203. 	SDiffStore(ctx context.Context, destination string, keys ...string) *IntCmd

  204. 	SInter(ctx context.Context, keys ...string) *StringSliceCmd

  205. 	SInterStore(ctx context.Context, destination string, keys ...string) *IntCmd

  206. 	SIsMember(ctx context.Context, key string, member interface{}) *BoolCmd

  207. 	SMIsMember(ctx context.Context, key string, members ...interface{}) *BoolSliceCmd

  208. 	SMembers(ctx context.Context, key string) *StringSliceCmd

  209. 	SMembersMap(ctx context.Context, key string) *StringStructMapCmd

  210. 	SMove(ctx context.Context, source, destination string, member interface{}) *BoolCmd

  211. 	SPop(ctx context.Context, key string) *StringCmd

  212. 	SPopN(ctx context.Context, key string, count int64) *StringSliceCmd

  213. 	SRandMember(ctx context.Context, key string) *StringCmd

  214. 	SRandMemberN(ctx context.Context, key string, count int64) *StringSliceCmd

  215. 	SRem(ctx context.Context, key string, members ...interface{}) *IntCmd

  216. 	SUnion(ctx context.Context, keys ...string) *StringSliceCmd

  217. 	SUnionStore(ctx context.Context, destination string, keys ...string) *IntCmd

  218. 

  219. 	XAdd(ctx context.Context, a *XAddArgs) *StringCmd

  220. 	XDel(ctx context.Context, stream string, ids ...string) *IntCmd

  221. 	XLen(ctx context.Context, stream string) *IntCmd

  222. 	XRange(ctx context.Context, stream, start, stop string) *XMessageSliceCmd

  223. 	XRangeN(ctx context.Context, stream, start, stop string, count int64) *XMessageSliceCmd

  224. 	XRevRange(ctx context.Context, stream string, start, stop string) *XMessageSliceCmd

  225. 	XRevRangeN(ctx context.Context, stream string, start, stop string, count int64) *XMessageSliceCmd

  226. 	XRead(ctx context.Context, a *XReadArgs) *XStreamSliceCmd

  227. 	XReadStreams(ctx context.Context, streams ...string) *XStreamSliceCmd

  228. 	XGroupCreate(ctx context.Context, stream, group, start string) *StatusCmd

  229. 	XGroupCreateMkStream(ctx context.Context, stream, group, start string) *StatusCmd

  230. 	XGroupSetID(ctx context.Context, stream, group, start string) *StatusCmd

  231. 	XGroupDestroy(ctx context.Context, stream, group string) *IntCmd

  232. 	XGroupCreateConsumer(ctx context.Context, stream, group, consumer string) *IntCmd

  233. 	XGroupDelConsumer(ctx context.Context, stream, group, consumer string) *IntCmd

  234. 	XReadGroup(ctx context.Context, a *XReadGroupArgs) *XStreamSliceCmd

  235. 	XAck(ctx context.Context, stream, group string, ids ...string) *IntCmd

  236. 	XPending(ctx context.Context, stream, group string) *XPendingCmd

  237. 	XPendingExt(ctx context.Context, a *XPendingExtArgs) *XPendingExtCmd

  238. 	XClaim(ctx context.Context, a *XClaimArgs) *XMessageSliceCmd

  239. 	XClaimJustID(ctx context.Context, a *XClaimArgs) *StringSliceCmd

  240. 	XAutoClaim(ctx context.Context, a *XAutoClaimArgs) *XAutoClaimCmd

  241. 	XAutoClaimJustID(ctx context.Context, a *XAutoClaimArgs) *XAutoClaimJustIDCmd

  242. 

  243. 	// TODO: XTrim and XTrimApprox remove in v9.

  244. 	XTrim(ctx context.Context, key string, maxLen int64) *IntCmd

  245. 	XTrimApprox(ctx context.Context, key string, maxLen int64) *IntCmd

  246. 	XTrimMaxLen(ctx context.Context, key string, maxLen int64) *IntCmd

  247. 	XTrimMaxLenApprox(ctx context.Context, key string, maxLen, limit int64) *IntCmd

  248. 	XTrimMinID(ctx context.Context, key string, minID string) *IntCmd

  249. 	XTrimMinIDApprox(ctx context.Context, key string, minID string, limit int64) *IntCmd

  250. 	XInfoGroups(ctx context.Context, key string) *XInfoGroupsCmd

  251. 	XInfoStream(ctx context.Context, key string) *XInfoStreamCmd

  252. 	XInfoStreamFull(ctx context.Context, key string, count int) *XInfoStreamFullCmd

  253. 	XInfoConsumers(ctx context.Context, key string, group string) *XInfoConsumersCmd

  254. 

  255. 	BZPopMax(ctx context.Context, timeout time.Duration, keys ...string) *ZWithKeyCmd

  256. 	BZPopMin(ctx context.Context, timeout time.Duration, keys ...string) *ZWithKeyCmd

  257. 

  258. 	// TODO: remove

  259. 	//		ZAddCh

  260. 	//		ZIncr

  261. 	//		ZAddNXCh

  262. 	//		ZAddXXCh

  263. 	//		ZIncrNX

  264. 	//		ZIncrXX

  265. 	// 	in v9.

  266. 	// 	use ZAddArgs and ZAddArgsIncr.

  267. 

  268. 	ZAdd(ctx context.Context, key string, members ...*Z) *IntCmd

  269. 	ZAddNX(ctx context.Context, key string, members ...*Z) *IntCmd

  270. 	ZAddXX(ctx context.Context, key string, members ...*Z) *IntCmd

  271. 	ZAddCh(ctx context.Context, key string, members ...*Z) *IntCmd

  272. 	ZAddNXCh(ctx context.Context, key string, members ...*Z) *IntCmd

  273. 	ZAddXXCh(ctx context.Context, key string, members ...*Z) *IntCmd

  274. 	ZAddArgs(ctx context.Context, key string, args ZAddArgs) *IntCmd

  275. 	ZAddArgsIncr(ctx context.Context, key string, args ZAddArgs) *FloatCmd

  276. 	ZIncr(ctx context.Context, key string, member *Z) *FloatCmd

  277. 	ZIncrNX(ctx context.Context, key string, member *Z) *FloatCmd

  278. 	ZIncrXX(ctx context.Context, key string, member *Z) *FloatCmd

  279. 	ZCard(ctx context.Context, key string) *IntCmd

  280. 	ZCount(ctx context.Context, key, min, max string) *IntCmd

  281. 	ZLexCount(ctx context.Context, key, min, max string) *IntCmd

  282. 	ZIncrBy(ctx context.Context, key string, increment float64, member string) *FloatCmd

  283. 	ZInter(ctx context.Context, store *ZStore) *StringSliceCmd

  284. 	ZInterWithScores(ctx context.Context, store *ZStore) *ZSliceCmd

  285. 	ZInterStore(ctx context.Context, destination string, store *ZStore) *IntCmd

  286. 	ZMScore(ctx context.Context, key string, members ...string) *FloatSliceCmd

  287. 	ZPopMax(ctx context.Context, key string, count ...int64) *ZSliceCmd

  288. 	ZPopMin(ctx context.Context, key string, count ...int64) *ZSliceCmd

  289. 	ZRange(ctx context.Context, key string, start, stop int64) *StringSliceCmd

  290. 	ZRangeWithScores(ctx context.Context, key string, start, stop int64) *ZSliceCmd

  291. 	ZRangeByScore(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd

  292. 	ZRangeByLex(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd

  293. 	ZRangeByScoreWithScores(ctx context.Context, key string, opt *ZRangeBy) *ZSliceCmd

  294. 	ZRangeArgs(ctx context.Context, z ZRangeArgs) *StringSliceCmd

  295. 	ZRangeArgsWithScores(ctx context.Context, z ZRangeArgs) *ZSliceCmd

  296. 	ZRangeStore(ctx context.Context, dst string, z ZRangeArgs) *IntCmd

  297. 	ZRank(ctx context.Context, key, member string) *IntCmd

  298. 	ZRem(ctx context.Context, key string, members ...interface{}) *IntCmd

  299. 	ZRemRangeByRank(ctx context.Context, key string, start, stop int64) *IntCmd

  300. 	ZRemRangeByScore(ctx context.Context, key, min, max string) *IntCmd

  301. 	ZRemRangeByLex(ctx context.Context, key, min, max string) *IntCmd

  302. 	ZRevRange(ctx context.Context, key string, start, stop int64) *StringSliceCmd

  303. 	ZRevRangeWithScores(ctx context.Context, key string, start, stop int64) *ZSliceCmd

  304. 	ZRevRangeByScore(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd

  305. 	ZRevRangeByLex(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd

  306. 	ZRevRangeByScoreWithScores(ctx context.Context, key string, opt *ZRangeBy) *ZSliceCmd

  307. 	ZRevRank(ctx context.Context, key, member string) *IntCmd

  308. 	ZScore(ctx context.Context, key, member string) *FloatCmd

  309. 	ZUnionStore(ctx context.Context, dest string, store *ZStore) *IntCmd

  310. 	ZUnion(ctx context.Context, store ZStore) *StringSliceCmd

  311. 	ZUnionWithScores(ctx context.Context, store ZStore) *ZSliceCmd

  312. 	ZRandMember(ctx context.Context, key string, count int, withScores bool) *StringSliceCmd

  313. 	ZDiff(ctx context.Context, keys ...string) *StringSliceCmd

  314. 	ZDiffWithScores(ctx context.Context, keys ...string) *ZSliceCmd

  315. 	ZDiffStore(ctx context.Context, destination string, keys ...string) *IntCmd

  316. 

  317. 	PFAdd(ctx context.Context, key string, els ...interface{}) *IntCmd

  318. 	PFCount(ctx context.Context, keys ...string) *IntCmd

  319. 	PFMerge(ctx context.Context, dest string, keys ...string) *StatusCmd

  320. 

  321. 	BgRewriteAOF(ctx context.Context) *StatusCmd

  322. 	BgSave(ctx context.Context) *StatusCmd

  323. 	ClientKill(ctx context.Context, ipPort string) *StatusCmd

  324. 	ClientKillByFilter(ctx context.Context, keys ...string) *IntCmd

  325. 	ClientList(ctx context.Context) *StringCmd

  326. 	ClientPause(ctx context.Context, dur time.Duration) *BoolCmd

  327. 	ClientID(ctx context.Context) *IntCmd

  328. 	ConfigGet(ctx context.Context, parameter string) *SliceCmd

  329. 	ConfigResetStat(ctx context.Context) *StatusCmd

  330. 	ConfigSet(ctx context.Context, parameter, value string) *StatusCmd

  331. 	ConfigRewrite(ctx context.Context) *StatusCmd

  332. 	DBSize(ctx context.Context) *IntCmd

  333. 	FlushAll(ctx context.Context) *StatusCmd

  334. 	FlushAllAsync(ctx context.Context) *StatusCmd

  335. 	FlushDB(ctx context.Context) *StatusCmd

  336. 	FlushDBAsync(ctx context.Context) *StatusCmd

  337. 	Info(ctx context.Context, section ...string) *StringCmd

  338. 	LastSave(ctx context.Context) *IntCmd

  339. 	Save(ctx context.Context) *StatusCmd

  340. 	Shutdown(ctx context.Context) *StatusCmd

  341. 	ShutdownSave(ctx context.Context) *StatusCmd

  342. 	ShutdownNoSave(ctx context.Context) *StatusCmd

  343. 	SlaveOf(ctx context.Context, host, port string) *StatusCmd

  344. 	Time(ctx context.Context) *TimeCmd

  345. 	DebugObject(ctx context.Context, key string) *StringCmd

  346. 	ReadOnly(ctx context.Context) *StatusCmd

  347. 	ReadWrite(ctx context.Context) *StatusCmd

  348. 	MemoryUsage(ctx context.Context, key string, samples ...int) *IntCmd

  349. 

  350. 	Eval(ctx context.Context, script string, keys []string, args ...interface{}) *Cmd

  351. 	EvalSha(ctx context.Context, sha1 string, keys []string, args ...interface{}) *Cmd

  352. 	ScriptExists(ctx context.Context, hashes ...string) *BoolSliceCmd

  353. 	ScriptFlush(ctx context.Context) *StatusCmd

  354. 	ScriptKill(ctx context.Context) *StatusCmd

  355. 	ScriptLoad(ctx context.Context, script string) *StringCmd

  356. 

  357. 	Publish(ctx context.Context, channel string, message interface{}) *IntCmd

  358. 	PubSubChannels(ctx context.Context, pattern string) *StringSliceCmd

  359. 	PubSubNumSub(ctx context.Context, channels ...string) *StringIntMapCmd

  360. 	PubSubNumPat(ctx context.Context) *IntCmd

  361. 

  362. 	ClusterSlots(ctx context.Context) *ClusterSlotsCmd

  363. 	ClusterNodes(ctx context.Context) *StringCmd

  364. 	ClusterMeet(ctx context.Context, host, port string) *StatusCmd

  365. 	ClusterForget(ctx context.Context, nodeID string) *StatusCmd

  366. 	ClusterReplicate(ctx context.Context, nodeID string) *StatusCmd

  367. 	ClusterResetSoft(ctx context.Context) *StatusCmd

  368. 	ClusterResetHard(ctx context.Context) *StatusCmd

  369. 	ClusterInfo(ctx context.Context) *StringCmd

  370. 	ClusterKeySlot(ctx context.Context, key string) *IntCmd

  371. 	ClusterGetKeysInSlot(ctx context.Context, slot int, count int) *StringSliceCmd

  372. 	ClusterCountFailureReports(ctx context.Context, nodeID string) *IntCmd

  373. 	ClusterCountKeysInSlot(ctx context.Context, slot int) *IntCmd

  374. 	ClusterDelSlots(ctx context.Context, slots ...int) *StatusCmd

  375. 	ClusterDelSlotsRange(ctx context.Context, min, max int) *StatusCmd

  376. 	ClusterSaveConfig(ctx context.Context) *StatusCmd

  377. 	ClusterSlaves(ctx context.Context, nodeID string) *StringSliceCmd

  378. 	ClusterFailover(ctx context.Context) *StatusCmd

  379. 	ClusterAddSlots(ctx context.Context, slots ...int) *StatusCmd

  380. 	ClusterAddSlotsRange(ctx context.Context, min, max int) *StatusCmd

  381. 

  382. 	GeoAdd(ctx context.Context, key string, geoLocation ...*GeoLocation) *IntCmd

  383. 	GeoPos(ctx context.Context, key string, members ...string) *GeoPosCmd

  384. 	GeoRadius(ctx context.Context, key string, longitude, latitude float64, query *GeoRadiusQuery) *GeoLocationCmd

  385. 	GeoRadiusStore(ctx context.Context, key string, longitude, latitude float64, query *GeoRadiusQuery) *IntCmd

  386. 	GeoRadiusByMember(ctx context.Context, key, member string, query *GeoRadiusQuery) *GeoLocationCmd

  387. 	GeoRadiusByMemberStore(ctx context.Context, key, member string, query *GeoRadiusQuery) *IntCmd

  388. 	GeoSearch(ctx context.Context, key string, q *GeoSearchQuery) *StringSliceCmd

  389. 	GeoSearchLocation(ctx context.Context, key string, q *GeoSearchLocationQuery) *GeoSearchLocationCmd

  390. 	GeoSearchStore(ctx context.Context, key, store string, q *GeoSearchStoreQuery) *IntCmd

  391. 	GeoDist(ctx context.Context, key string, member1, member2, unit string) *FloatCmd

  392. 	GeoHash(ctx context.Context, key string, members ...string) *StringSliceCmd

  393. }

  394. 

  395. type StatefulCmdable interface {

  396. 	Cmdable

  397. 	Auth(ctx context.Context, password string) *StatusCmd

  398. 	AuthACL(ctx context.Context, username, password string) *StatusCmd

  399. 	Select(ctx context.Context, index int) *StatusCmd

  400. 	SwapDB(ctx context.Context, index1, index2 int) *StatusCmd

  401. 	ClientSetName(ctx context.Context, name string) *BoolCmd

  402. }

  403. 

  404. var (

  405. 	_ Cmdable = (*Client)(nil)

  406. 	_ Cmdable = (*Tx)(nil)

  407. 	_ Cmdable = (*Ring)(nil)

  408. 	_ Cmdable = (*ClusterClient)(nil)

  409. )

  410. 

  411. type cmdable func(ctx context.Context, cmd Cmder) error

  412. 

  413. type statefulCmdable func(ctx context.Context, cmd Cmder) error

  414. 

  415. //------------------------------------------------------------------------------

  416. 

  417. func (c statefulCmdable) Auth(ctx context.Context, password string) *StatusCmd {

  418. 	cmd := NewStatusCmd(ctx, "auth", password)

  419. 	_ = c(ctx, cmd)

  420. 	return cmd

  421. }

  422. 

  423. // AuthACL Perform an AUTH command, using the given user and pass.

  424. // Should be used to authenticate the current connection with one of the connections defined in the ACL list

  425. // when connecting to a Redis 6.0 instance, or greater, that is using the Redis ACL system.

  426. func (c statefulCmdable) AuthACL(ctx context.Context, username, password string) *StatusCmd {

  427. 	cmd := NewStatusCmd(ctx, "auth", username, password)

  428. 	_ = c(ctx, cmd)

  429. 	return cmd

  430. }

  431. 

  432. func (c cmdable) Wait(ctx context.Context, numSlaves int, timeout time.Duration) *IntCmd {

  433. 	cmd := NewIntCmd(ctx, "wait", numSlaves, int(timeout/time.Millisecond))

  434. 	_ = c(ctx, cmd)

  435. 	return cmd

  436. }

  437. 

  438. func (c statefulCmdable) Select(ctx context.Context, index int) *StatusCmd {

  439. 	cmd := NewStatusCmd(ctx, "select", index)

  440. 	_ = c(ctx, cmd)

  441. 	return cmd

  442. }

  443. 

  444. func (c statefulCmdable) SwapDB(ctx context.Context, index1, index2 int) *StatusCmd {

  445. 	cmd := NewStatusCmd(ctx, "swapdb", index1, index2)

  446. 	_ = c(ctx, cmd)

  447. 	return cmd

  448. }

  449. 

  450. // ClientSetName assigns a name to the connection.

  451. func (c statefulCmdable) ClientSetName(ctx context.Context, name string) *BoolCmd {

  452. 	cmd := NewBoolCmd(ctx, "client", "setname", name)

  453. 	_ = c(ctx, cmd)

  454. 	return cmd

  455. }

  456. 

  457. //------------------------------------------------------------------------------

  458. 

  459. func (c cmdable) Command(ctx context.Context) *CommandsInfoCmd {

  460. 	cmd := NewCommandsInfoCmd(ctx, "command")

  461. 	_ = c(ctx, cmd)

  462. 	return cmd

  463. }

  464. 

  465. // ClientGetName returns the name of the connection.

  466. func (c cmdable) ClientGetName(ctx context.Context) *StringCmd {

  467. 	cmd := NewStringCmd(ctx, "client", "getname")

  468. 	_ = c(ctx, cmd)

  469. 	return cmd

  470. }

  471. 

  472. func (c cmdable) Echo(ctx context.Context, message interface{}) *StringCmd {

  473. 	cmd := NewStringCmd(ctx, "echo", message)

  474. 	_ = c(ctx, cmd)

  475. 	return cmd

  476. }

  477. 

  478. func (c cmdable) Ping(ctx context.Context) *StatusCmd {

  479. 	cmd := NewStatusCmd(ctx, "ping")

  480. 	_ = c(ctx, cmd)

  481. 	return cmd

  482. }

  483. 

  484. func (c cmdable) Quit(_ context.Context) *StatusCmd {

  485. 	panic("not implemented")

  486. }

  487. 

  488. func (c cmdable) Del(ctx context.Context, keys ...string) *IntCmd {

  489. 	args := make([]interface{}, 1+len(keys))

  490. 	args[0] = "del"

  491. 	for i, key := range keys {

  492. 		args[1+i] = key

  493. 	}

  494. 	cmd := NewIntCmd(ctx, args...)

  495. 	_ = c(ctx, cmd)

  496. 	return cmd

  497. }

  498. 

  499. func (c cmdable) Unlink(ctx context.Context, keys ...string) *IntCmd {

  500. 	args := make([]interface{}, 1+len(keys))

  501. 	args[0] = "unlink"

  502. 	for i, key := range keys {

  503. 		args[1+i] = key

  504. 	}

  505. 	cmd := NewIntCmd(ctx, args...)

  506. 	_ = c(ctx, cmd)

  507. 	return cmd

  508. }

  509. 

  510. func (c cmdable) Dump(ctx context.Context, key string) *StringCmd {

  511. 	cmd := NewStringCmd(ctx, "dump", key)

  512. 	_ = c(ctx, cmd)

  513. 	return cmd

  514. }

  515. 

  516. func (c cmdable) Exists(ctx context.Context, keys ...string) *IntCmd {

  517. 	args := make([]interface{}, 1+len(keys))

  518. 	args[0] = "exists"

  519. 	for i, key := range keys {

  520. 		args[1+i] = key

  521. 	}

  522. 	cmd := NewIntCmd(ctx, args...)

  523. 	_ = c(ctx, cmd)

  524. 	return cmd

  525. }

  526. 

  527. func (c cmdable) Expire(ctx context.Context, key string, expiration time.Duration) *BoolCmd {

  528. 	cmd := NewBoolCmd(ctx, "expire", key, formatSec(ctx, expiration))

  529. 	_ = c(ctx, cmd)

  530. 	return cmd

  531. }

  532. 

  533. func (c cmdable) ExpireAt(ctx context.Context, key string, tm time.Time) *BoolCmd {

  534. 	cmd := NewBoolCmd(ctx, "expireat", key, tm.Unix())

  535. 	_ = c(ctx, cmd)

  536. 	return cmd

  537. }

  538. 

  539. func (c cmdable) Keys(ctx context.Context, pattern string) *StringSliceCmd {

  540. 	cmd := NewStringSliceCmd(ctx, "keys", pattern)

  541. 	_ = c(ctx, cmd)

  542. 	return cmd

  543. }

  544. 

  545. func (c cmdable) Migrate(ctx context.Context, host, port, key string, db int, timeout time.Duration) *StatusCmd {

  546. 	cmd := NewStatusCmd(

  547. 		ctx,

  548. 		"migrate",

  549. 		host,

  550. 		port,

  551. 		key,

  552. 		db,

  553. 		formatMs(ctx, timeout),

  554. 	)

  555. 	cmd.setReadTimeout(timeout)

  556. 	_ = c(ctx, cmd)

  557. 	return cmd

  558. }

  559. 

  560. func (c cmdable) Move(ctx context.Context, key string, db int) *BoolCmd {

  561. 	cmd := NewBoolCmd(ctx, "move", key, db)

  562. 	_ = c(ctx, cmd)

  563. 	return cmd

  564. }

  565. 

  566. func (c cmdable) ObjectRefCount(ctx context.Context, key string) *IntCmd {

  567. 	cmd := NewIntCmd(ctx, "object", "refcount", key)

  568. 	_ = c(ctx, cmd)

  569. 	return cmd

  570. }

  571. 

  572. func (c cmdable) ObjectEncoding(ctx context.Context, key string) *StringCmd {

  573. 	cmd := NewStringCmd(ctx, "object", "encoding", key)

  574. 	_ = c(ctx, cmd)

  575. 	return cmd

  576. }

  577. 

  578. func (c cmdable) ObjectIdleTime(ctx context.Context, key string) *DurationCmd {

  579. 	cmd := NewDurationCmd(ctx, time.Second, "object", "idletime", key)

  580. 	_ = c(ctx, cmd)

  581. 	return cmd

  582. }

  583. 

  584. func (c cmdable) Persist(ctx context.Context, key string) *BoolCmd {

  585. 	cmd := NewBoolCmd(ctx, "persist", key)

  586. 	_ = c(ctx, cmd)

  587. 	return cmd

  588. }

  589. 

  590. func (c cmdable) PExpire(ctx context.Context, key string, expiration time.Duration) *BoolCmd {

  591. 	cmd := NewBoolCmd(ctx, "pexpire", key, formatMs(ctx, expiration))

  592. 	_ = c(ctx, cmd)

  593. 	return cmd

  594. }

  595. 

  596. func (c cmdable) PExpireAt(ctx context.Context, key string, tm time.Time) *BoolCmd {

  597. 	cmd := NewBoolCmd(

  598. 		ctx,

  599. 		"pexpireat",

  600. 		key,

  601. 		tm.UnixNano()/int64(time.Millisecond),

  602. 	)

  603. 	_ = c(ctx, cmd)

  604. 	return cmd

  605. }

  606. 

  607. func (c cmdable) PTTL(ctx context.Context, key string) *DurationCmd {

  608. 	cmd := NewDurationCmd(ctx, time.Millisecond, "pttl", key)

  609. 	_ = c(ctx, cmd)

  610. 	return cmd

  611. }

  612. 

  613. func (c cmdable) RandomKey(ctx context.Context) *StringCmd {

  614. 	cmd := NewStringCmd(ctx, "randomkey")

  615. 	_ = c(ctx, cmd)

  616. 	return cmd

  617. }

  618. 

  619. func (c cmdable) Rename(ctx context.Context, key, newkey string) *StatusCmd {

  620. 	cmd := NewStatusCmd(ctx, "rename", key, newkey)

  621. 	_ = c(ctx, cmd)

  622. 	return cmd

  623. }

  624. 

  625. func (c cmdable) RenameNX(ctx context.Context, key, newkey string) *BoolCmd {

  626. 	cmd := NewBoolCmd(ctx, "renamenx", key, newkey)

  627. 	_ = c(ctx, cmd)

  628. 	return cmd

  629. }

  630. 

  631. func (c cmdable) Restore(ctx context.Context, key string, ttl time.Duration, value string) *StatusCmd {

  632. 	cmd := NewStatusCmd(

  633. 		ctx,

  634. 		"restore",

  635. 		key,

  636. 		formatMs(ctx, ttl),

  637. 		value,

  638. 	)

  639. 	_ = c(ctx, cmd)

  640. 	return cmd

  641. }

  642. 

  643. func (c cmdable) RestoreReplace(ctx context.Context, key string, ttl time.Duration, value string) *StatusCmd {

  644. 	cmd := NewStatusCmd(

  645. 		ctx,

  646. 		"restore",

  647. 		key,

  648. 		formatMs(ctx, ttl),

  649. 		value,

  650. 		"replace",

  651. 	)

  652. 	_ = c(ctx, cmd)

  653. 	return cmd

  654. }

  655. 

  656. type Sort struct {

  657. 	By            string

  658. 	Offset, Count int64

  659. 	Get           []string

  660. 	Order         string

  661. 	Alpha         bool

  662. }

  663. 

  664. func (sort *Sort) args(key string) []interface{} {

  665. 	args := []interface{}{"sort", key}

  666. 	if sort.By != "" {

  667. 		args = append(args, "by", sort.By)

  668. 	}

  669. 	if sort.Offset != 0 || sort.Count != 0 {

  670. 		args = append(args, "limit", sort.Offset, sort.Count)

  671. 	}

  672. 	for _, get := range sort.Get {

  673. 		args = append(args, "get", get)

  674. 	}

  675. 	if sort.Order != "" {

  676. 		args = append(args, sort.Order)

  677. 	}

  678. 	if sort.Alpha {

  679. 		args = append(args, "alpha")

  680. 	}

  681. 	return args

  682. }

  683. 

  684. func (c cmdable) Sort(ctx context.Context, key string, sort *Sort) *StringSliceCmd {

  685. 	cmd := NewStringSliceCmd(ctx, sort.args(key)...)

  686. 	_ = c(ctx, cmd)

  687. 	return cmd

  688. }

  689. 

  690. func (c cmdable) SortStore(ctx context.Context, key, store string, sort *Sort) *IntCmd {

  691. 	args := sort.args(key)

  692. 	if store != "" {

  693. 		args = append(args, "store", store)

  694. 	}

  695. 	cmd := NewIntCmd(ctx, args...)

  696. 	_ = c(ctx, cmd)

  697. 	return cmd

  698. }

  699. 

  700. func (c cmdable) SortInterfaces(ctx context.Context, key string, sort *Sort) *SliceCmd {

  701. 	cmd := NewSliceCmd(ctx, sort.args(key)...)

  702. 	_ = c(ctx, cmd)

  703. 	return cmd

  704. }

  705. 

  706. func (c cmdable) Touch(ctx context.Context, keys ...string) *IntCmd {

  707. 	args := make([]interface{}, len(keys)+1)

  708. 	args[0] = "touch"

  709. 	for i, key := range keys {

  710. 		args[i+1] = key

  711. 	}

  712. 	cmd := NewIntCmd(ctx, args...)

  713. 	_ = c(ctx, cmd)

  714. 	return cmd

  715. }

  716. 

  717. func (c cmdable) TTL(ctx context.Context, key string) *DurationCmd {

  718. 	cmd := NewDurationCmd(ctx, time.Second, "ttl", key)

  719. 	_ = c(ctx, cmd)

  720. 	return cmd

  721. }

  722. 

  723. func (c cmdable) Type(ctx context.Context, key string) *StatusCmd {

  724. 	cmd := NewStatusCmd(ctx, "type", key)

  725. 	_ = c(ctx, cmd)

  726. 	return cmd

  727. }

  728. 

  729. func (c cmdable) Append(ctx context.Context, key, value string) *IntCmd {

  730. 	cmd := NewIntCmd(ctx, "append", key, value)

  731. 	_ = c(ctx, cmd)

  732. 	return cmd

  733. }

  734. 

  735. func (c cmdable) Decr(ctx context.Context, key string) *IntCmd {

  736. 	cmd := NewIntCmd(ctx, "decr", key)

  737. 	_ = c(ctx, cmd)

  738. 	return cmd

  739. }

  740. 

  741. func (c cmdable) DecrBy(ctx context.Context, key string, decrement int64) *IntCmd {

  742. 	cmd := NewIntCmd(ctx, "decrby", key, decrement)

  743. 	_ = c(ctx, cmd)

  744. 	return cmd

  745. }

  746. 

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

  748. func (c cmdable) Get(ctx context.Context, key string) *StringCmd {

  749. 	cmd := NewStringCmd(ctx, "get", key)

  750. 	_ = c(ctx, cmd)

  751. 	return cmd

  752. }

  753. 

  754. func (c cmdable) GetRange(ctx context.Context, key string, start, end int64) *StringCmd {

  755. 	cmd := NewStringCmd(ctx, "getrange", key, start, end)

  756. 	_ = c(ctx, cmd)

  757. 	return cmd

  758. }

  759. 

  760. func (c cmdable) GetSet(ctx context.Context, key string, value interface{}) *StringCmd {

  761. 	cmd := NewStringCmd(ctx, "getset", key, value)

  762. 	_ = c(ctx, cmd)

  763. 	return cmd

  764. }

  765. 

  766. // GetEx An expiration of zero removes the TTL associated with the key (i.e. GETEX key persist).

  767. // Requires Redis >= 6.2.0.

  768. func (c cmdable) GetEx(ctx context.Context, key string, expiration time.Duration) *StringCmd {

  769. 	args := make([]interface{}, 0, 4)

  770. 	args = append(args, "getex", key)

  771. 	if expiration > 0 {

  772. 		if usePrecise(expiration) {

  773. 			args = append(args, "px", formatMs(ctx, expiration))

  774. 		} else {

  775. 			args = append(args, "ex", formatSec(ctx, expiration))

  776. 		}

  777. 	} else if expiration == 0 {

  778. 		args = append(args, "persist")

  779. 	}

  780. 

  781. 	cmd := NewStringCmd(ctx, args...)

  782. 	_ = c(ctx, cmd)

  783. 	return cmd

  784. }

  785. 

  786. // GetDel redis-server version >= 6.2.0.

  787. func (c cmdable) GetDel(ctx context.Context, key string) *StringCmd {

  788. 	cmd := NewStringCmd(ctx, "getdel", key)

  789. 	_ = c(ctx, cmd)

  790. 	return cmd

  791. }

  792. 

  793. func (c cmdable) Incr(ctx context.Context, key string) *IntCmd {

  794. 	cmd := NewIntCmd(ctx, "incr", key)

  795. 	_ = c(ctx, cmd)

  796. 	return cmd

  797. }

  798. 

  799. func (c cmdable) IncrBy(ctx context.Context, key string, value int64) *IntCmd {

  800. 	cmd := NewIntCmd(ctx, "incrby", key, value)

  801. 	_ = c(ctx, cmd)

  802. 	return cmd

  803. }

  804. 

  805. func (c cmdable) IncrByFloat(ctx context.Context, key string, value float64) *FloatCmd {

  806. 	cmd := NewFloatCmd(ctx, "incrbyfloat", key, value)

  807. 	_ = c(ctx, cmd)

  808. 	return cmd

  809. }

  810. 

  811. func (c cmdable) MGet(ctx context.Context, keys ...string) *SliceCmd {

  812. 	args := make([]interface{}, 1+len(keys))

  813. 	args[0] = "mget"

  814. 	for i, key := range keys {

  815. 		args[1+i] = key

  816. 	}

  817. 	cmd := NewSliceCmd(ctx, args...)

  818. 	_ = c(ctx, cmd)

  819. 	return cmd

  820. }

  821. 

  822. // MSet is like Set but accepts multiple values:

  823. //   - MSet("key1", "value1", "key2", "value2")

  824. //   - MSet([]string{"key1", "value1", "key2", "value2"})

  825. //   - MSet(map[string]interface{}{"key1": "value1", "key2": "value2"})

  826. func (c cmdable) MSet(ctx context.Context, values ...interface{}) *StatusCmd {

  827. 	args := make([]interface{}, 1, 1+len(values))

  828. 	args[0] = "mset"

  829. 	args = appendArgs(args, values)

  830. 	cmd := NewStatusCmd(ctx, args...)

  831. 	_ = c(ctx, cmd)

  832. 	return cmd

  833. }

  834. 

  835. // MSetNX is like SetNX but accepts multiple values:

  836. //   - MSetNX("key1", "value1", "key2", "value2")

  837. //   - MSetNX([]string{"key1", "value1", "key2", "value2"})

  838. //   - MSetNX(map[string]interface{}{"key1": "value1", "key2": "value2"})

  839. func (c cmdable) MSetNX(ctx context.Context, values ...interface{}) *BoolCmd {

  840. 	args := make([]interface{}, 1, 1+len(values))

  841. 	args[0] = "msetnx"

  842. 	args = appendArgs(args, values)

  843. 	cmd := NewBoolCmd(ctx, args...)

  844. 	_ = c(ctx, cmd)

  845. 	return cmd

  846. }

  847. 

  848. // Set Redis `SET key value [expiration]` command.

  849. // Use expiration for `SETEX`-like behavior.

  850. //

  851. // Zero expiration means the key has no expiration time.

  852. // KeepTTL is a Redis KEEPTTL option to keep existing TTL, it requires your redis-server version >= 6.0,

  853. // otherwise you will receive an error: (error) ERR syntax error.

  854. func (c cmdable) Set(ctx context.Context, key string, value interface{}, expiration time.Duration) *StatusCmd {

  855. 	args := make([]interface{}, 3, 5)

  856. 	args[0] = "set"

  857. 	args[1] = key

  858. 	args[2] = value

  859. 	if expiration > 0 {

  860. 		if usePrecise(expiration) {

  861. 			args = append(args, "px", formatMs(ctx, expiration))

  862. 		} else {

  863. 			args = append(args, "ex", formatSec(ctx, expiration))

  864. 		}

  865. 	} else if expiration == KeepTTL {

  866. 		args = append(args, "keepttl")

  867. 	}

  868. 

  869. 	cmd := NewStatusCmd(ctx, args...)

  870. 	_ = c(ctx, cmd)

  871. 	return cmd

  872. }

  873. 

  874. // SetArgs provides arguments for the SetArgs function.

  875. type SetArgs struct {

  876. 	// Mode can be `NX` or `XX` or empty.

  877. 	Mode string

  878. 

  879. 	// Zero `TTL` or `Expiration` means that the key has no expiration time.

  880. 	TTL      time.Duration

  881. 	ExpireAt time.Time

  882. 

  883. 	// When Get is true, the command returns the old value stored at key, or nil when key did not exist.

  884. 	Get bool

  885. 

  886. 	// KeepTTL is a Redis KEEPTTL option to keep existing TTL, it requires your redis-server version >= 6.0,

  887. 	// otherwise you will receive an error: (error) ERR syntax error.

  888. 	KeepTTL bool

  889. }

  890. 

  891. // SetArgs supports all the options that the SET command supports.

  892. // It is the alternative to the Set function when you want

  893. // to have more control over the options.

  894. func (c cmdable) SetArgs(ctx context.Context, key string, value interface{}, a SetArgs) *StatusCmd {

  895. 	args := []interface{}{"set", key, value}

  896. 

  897. 	if a.KeepTTL {

  898. 		args = append(args, "keepttl")

  899. 	}

  900. 

  901. 	if !a.ExpireAt.IsZero() {

  902. 		args = append(args, "exat", a.ExpireAt.Unix())

  903. 	}

  904. 	if a.TTL > 0 {

  905. 		if usePrecise(a.TTL) {

  906. 			args = append(args, "px", formatMs(ctx, a.TTL))

  907. 		} else {

  908. 			args = append(args, "ex", formatSec(ctx, a.TTL))

  909. 		}

  910. 	}

  911. 

  912. 	if a.Mode != "" {

  913. 		args = append(args, a.Mode)

  914. 	}

  915. 

  916. 	if a.Get {

  917. 		args = append(args, "get")

  918. 	}

  919. 

  920. 	cmd := NewStatusCmd(ctx, args...)

  921. 	_ = c(ctx, cmd)

  922. 	return cmd

  923. }

  924. 

  925. // SetEX Redis `SETEX key expiration value` command.

  926. func (c cmdable) SetEX(ctx context.Context, key string, value interface{}, expiration time.Duration) *StatusCmd {

  927. 	cmd := NewStatusCmd(ctx, "setex", key, formatSec(ctx, expiration), value)

  928. 	_ = c(ctx, cmd)

  929. 	return cmd

  930. }

  931. 

  932. // SetNX Redis `SET key value [expiration] NX` command.

  933. //

  934. // Zero expiration means the key has no expiration time.

  935. // KeepTTL is a Redis KEEPTTL option to keep existing TTL, it requires your redis-server version >= 6.0,

  936. // otherwise you will receive an error: (error) ERR syntax error.

  937. func (c cmdable) SetNX(ctx context.Context, key string, value interface{}, expiration time.Duration) *BoolCmd {

  938. 	var cmd *BoolCmd

  939. 	switch expiration {

  940. 	case 0:

  941. 		// Use old `SETNX` to support old Redis versions.

  942. 		cmd = NewBoolCmd(ctx, "setnx", key, value)

  943. 	case KeepTTL:

  944. 		cmd = NewBoolCmd(ctx, "set", key, value, "keepttl", "nx")

  945. 	default:

  946. 		if usePrecise(expiration) {

  947. 			cmd = NewBoolCmd(ctx, "set", key, value, "px", formatMs(ctx, expiration), "nx")

  948. 		} else {

  949. 			cmd = NewBoolCmd(ctx, "set", key, value, "ex", formatSec(ctx, expiration), "nx")

  950. 		}

  951. 	}

  952. 

  953. 	_ = c(ctx, cmd)

  954. 	return cmd

  955. }

  956. 

  957. // SetXX Redis `SET key value [expiration] XX` command.

  958. //

  959. // Zero expiration means the key has no expiration time.

  960. // KeepTTL is a Redis KEEPTTL option to keep existing TTL, it requires your redis-server version >= 6.0,

  961. // otherwise you will receive an error: (error) ERR syntax error.

  962. func (c cmdable) SetXX(ctx context.Context, key string, value interface{}, expiration time.Duration) *BoolCmd {

  963. 	var cmd *BoolCmd

  964. 	switch expiration {

  965. 	case 0:

  966. 		cmd = NewBoolCmd(ctx, "set", key, value, "xx")

  967. 	case KeepTTL:

  968. 		cmd = NewBoolCmd(ctx, "set", key, value, "keepttl", "xx")

  969. 	default:

  970. 		if usePrecise(expiration) {

  971. 			cmd = NewBoolCmd(ctx, "set", key, value, "px", formatMs(ctx, expiration), "xx")

  972. 		} else {

  973. 			cmd = NewBoolCmd(ctx, "set", key, value, "ex", formatSec(ctx, expiration), "xx")

  974. 		}

  975. 	}

  976. 

  977. 	_ = c(ctx, cmd)

  978. 	return cmd

  979. }

  980. 

  981. func (c cmdable) SetRange(ctx context.Context, key string, offset int64, value string) *IntCmd {

  982. 	cmd := NewIntCmd(ctx, "setrange", key, offset, value)

  983. 	_ = c(ctx, cmd)

  984. 	return cmd

  985. }

  986. 

  987. func (c cmdable) StrLen(ctx context.Context, key string) *IntCmd {

  988. 	cmd := NewIntCmd(ctx, "strlen", key)

  989. 	_ = c(ctx, cmd)

  990. 	return cmd

  991. }

  992. 

  993. //------------------------------------------------------------------------------

  994. 

  995. func (c cmdable) GetBit(ctx context.Context, key string, offset int64) *IntCmd {

  996. 	cmd := NewIntCmd(ctx, "getbit", key, offset)

  997. 	_ = c(ctx, cmd)

  998. 	return cmd

  999. }

  1000. 

  1001. func (c cmdable) SetBit(ctx context.Context, key string, offset int64, value int) *IntCmd {

  1002. 	cmd := NewIntCmd(

  1003. 		ctx,

  1004. 		"setbit",

  1005. 		key,

  1006. 		offset,

  1007. 		value,

  1008. 	)

  1009. 	_ = c(ctx, cmd)

  1010. 	return cmd

  1011. }

  1012. 

  1013. type BitCount struct {

  1014. 	Start, End int64

  1015. }

  1016. 

  1017. func (c cmdable) BitCount(ctx context.Context, key string, bitCount *BitCount) *IntCmd {

  1018. 	args := []interface{}{"bitcount", key}

  1019. 	if bitCount != nil {

  1020. 		args = append(

  1021. 			args,

  1022. 			bitCount.Start,

  1023. 			bitCount.End,

  1024. 		)

  1025. 	}

  1026. 	cmd := NewIntCmd(ctx, args...)

  1027. 	_ = c(ctx, cmd)

  1028. 	return cmd

  1029. }

  1030. 

  1031. func (c cmdable) bitOp(ctx context.Context, op, destKey string, keys ...string) *IntCmd {

  1032. 	args := make([]interface{}, 3+len(keys))

  1033. 	args[0] = "bitop"

  1034. 	args[1] = op

  1035. 	args[2] = destKey

  1036. 	for i, key := range keys {

  1037. 		args[3+i] = key

  1038. 	}

  1039. 	cmd := NewIntCmd(ctx, args...)

  1040. 	_ = c(ctx, cmd)

  1041. 	return cmd

  1042. }

  1043. 

  1044. func (c cmdable) BitOpAnd(ctx context.Context, destKey string, keys ...string) *IntCmd {

  1045. 	return c.bitOp(ctx, "and", destKey, keys...)

  1046. }

  1047. 

  1048. func (c cmdable) BitOpOr(ctx context.Context, destKey string, keys ...string) *IntCmd {

  1049. 	return c.bitOp(ctx, "or", destKey, keys...)

  1050. }

  1051. 

  1052. func (c cmdable) BitOpXor(ctx context.Context, destKey string, keys ...string) *IntCmd {

  1053. 	return c.bitOp(ctx, "xor", destKey, keys...)

  1054. }

  1055. 

  1056. func (c cmdable) BitOpNot(ctx context.Context, destKey string, key string) *IntCmd {

  1057. 	return c.bitOp(ctx, "not", destKey, key)

  1058. }

  1059. 

  1060. func (c cmdable) BitPos(ctx context.Context, key string, bit int64, pos ...int64) *IntCmd {

  1061. 	args := make([]interface{}, 3+len(pos))

  1062. 	args[0] = "bitpos"

  1063. 	args[1] = key

  1064. 	args[2] = bit

  1065. 	switch len(pos) {

  1066. 	case 0:

  1067. 	case 1:

  1068. 		args[3] = pos[0]

  1069. 	case 2:

  1070. 		args[3] = pos[0]

  1071. 		args[4] = pos[1]

  1072. 	default:

  1073. 		panic("too many arguments")

  1074. 	}

  1075. 	cmd := NewIntCmd(ctx, args...)

  1076. 	_ = c(ctx, cmd)

  1077. 	return cmd

  1078. }

  1079. 

  1080. func (c cmdable) BitField(ctx context.Context, key string, args ...interface{}) *IntSliceCmd {

  1081. 	a := make([]interface{}, 0, 2+len(args))

  1082. 	a = append(a, "bitfield")

  1083. 	a = append(a, key)

  1084. 	a = append(a, args...)

  1085. 	cmd := NewIntSliceCmd(ctx, a...)

  1086. 	_ = c(ctx, cmd)

  1087. 	return cmd

  1088. }

  1089. 

  1090. //------------------------------------------------------------------------------

  1091. 

  1092. func (c cmdable) Scan(ctx context.Context, cursor uint64, match string, count int64) *ScanCmd {

  1093. 	args := []interface{}{"scan", cursor}

  1094. 	if match != "" {

  1095. 		args = append(args, "match", match)

  1096. 	}

  1097. 	if count > 0 {

  1098. 		args = append(args, "count", count)

  1099. 	}

  1100. 	cmd := NewScanCmd(ctx, c, args...)

  1101. 	_ = c(ctx, cmd)

  1102. 	return cmd

  1103. }

  1104. 

  1105. func (c cmdable) ScanType(ctx context.Context, cursor uint64, match string, count int64, keyType string) *ScanCmd {

  1106. 	args := []interface{}{"scan", cursor}

  1107. 	if match != "" {

  1108. 		args = append(args, "match", match)

  1109. 	}

  1110. 	if count > 0 {

  1111. 		args = append(args, "count", count)

  1112. 	}

  1113. 	if keyType != "" {

  1114. 		args = append(args, "type", keyType)

  1115. 	}

  1116. 	cmd := NewScanCmd(ctx, c, args...)

  1117. 	_ = c(ctx, cmd)

  1118. 	return cmd

  1119. }

  1120. 

  1121. func (c cmdable) SScan(ctx context.Context, key string, cursor uint64, match string, count int64) *ScanCmd {

  1122. 	args := []interface{}{"sscan", key, cursor}

  1123. 	if match != "" {

  1124. 		args = append(args, "match", match)

  1125. 	}

  1126. 	if count > 0 {

  1127. 		args = append(args, "count", count)

  1128. 	}

  1129. 	cmd := NewScanCmd(ctx, c, args...)

  1130. 	_ = c(ctx, cmd)

  1131. 	return cmd

  1132. }

  1133. 

  1134. func (c cmdable) HScan(ctx context.Context, key string, cursor uint64, match string, count int64) *ScanCmd {

  1135. 	args := []interface{}{"hscan", key, cursor}

  1136. 	if match != "" {

  1137. 		args = append(args, "match", match)

  1138. 	}

  1139. 	if count > 0 {

  1140. 		args = append(args, "count", count)

  1141. 	}

  1142. 	cmd := NewScanCmd(ctx, c, args...)

  1143. 	_ = c(ctx, cmd)

  1144. 	return cmd

  1145. }

  1146. 

  1147. func (c cmdable) ZScan(ctx context.Context, key string, cursor uint64, match string, count int64) *ScanCmd {

  1148. 	args := []interface{}{"zscan", key, cursor}

  1149. 	if match != "" {

  1150. 		args = append(args, "match", match)

  1151. 	}

  1152. 	if count > 0 {

  1153. 		args = append(args, "count", count)

  1154. 	}

  1155. 	cmd := NewScanCmd(ctx, c, args...)

  1156. 	_ = c(ctx, cmd)

  1157. 	return cmd

  1158. }

  1159. 

  1160. //------------------------------------------------------------------------------

  1161. 

  1162. func (c cmdable) HDel(ctx context.Context, key string, fields ...string) *IntCmd {

  1163. 	args := make([]interface{}, 2+len(fields))

  1164. 	args[0] = "hdel"

  1165. 	args[1] = key

  1166. 	for i, field := range fields {

  1167. 		args[2+i] = field

  1168. 	}

  1169. 	cmd := NewIntCmd(ctx, args...)

  1170. 	_ = c(ctx, cmd)

  1171. 	return cmd

  1172. }

  1173. 

  1174. func (c cmdable) HExists(ctx context.Context, key, field string) *BoolCmd {

  1175. 	cmd := NewBoolCmd(ctx, "hexists", key, field)

  1176. 	_ = c(ctx, cmd)

  1177. 	return cmd

  1178. }

  1179. 

  1180. func (c cmdable) HGet(ctx context.Context, key, field string) *StringCmd {

  1181. 	cmd := NewStringCmd(ctx, "hget", key, field)

  1182. 	_ = c(ctx, cmd)

  1183. 	return cmd

  1184. }

  1185. 

  1186. func (c cmdable) HGetAll(ctx context.Context, key string) *StringStringMapCmd {

  1187. 	cmd := NewStringStringMapCmd(ctx, "hgetall", key)

  1188. 	_ = c(ctx, cmd)

  1189. 	return cmd

  1190. }

  1191. 

  1192. func (c cmdable) HIncrBy(ctx context.Context, key, field string, incr int64) *IntCmd {

  1193. 	cmd := NewIntCmd(ctx, "hincrby", key, field, incr)

  1194. 	_ = c(ctx, cmd)

  1195. 	return cmd

  1196. }

  1197. 

  1198. func (c cmdable) HIncrByFloat(ctx context.Context, key, field string, incr float64) *FloatCmd {

  1199. 	cmd := NewFloatCmd(ctx, "hincrbyfloat", key, field, incr)

  1200. 	_ = c(ctx, cmd)

  1201. 	return cmd

  1202. }

  1203. 

  1204. func (c cmdable) HKeys(ctx context.Context, key string) *StringSliceCmd {

  1205. 	cmd := NewStringSliceCmd(ctx, "hkeys", key)

  1206. 	_ = c(ctx, cmd)

  1207. 	return cmd

  1208. }

  1209. 

  1210. func (c cmdable) HLen(ctx context.Context, key string) *IntCmd {

  1211. 	cmd := NewIntCmd(ctx, "hlen", key)

  1212. 	_ = c(ctx, cmd)

  1213. 	return cmd

  1214. }

  1215. 

  1216. // HMGet returns the values for the specified fields in the hash stored at key.

  1217. // It returns an interface{} to distinguish between empty string and nil value.

  1218. func (c cmdable) HMGet(ctx context.Context, key string, fields ...string) *SliceCmd {

  1219. 	args := make([]interface{}, 2+len(fields))

  1220. 	args[0] = "hmget"

  1221. 	args[1] = key

  1222. 	for i, field := range fields {

  1223. 		args[2+i] = field

  1224. 	}

  1225. 	cmd := NewSliceCmd(ctx, args...)

  1226. 	_ = c(ctx, cmd)

  1227. 	return cmd

  1228. }

  1229. 

  1230. // HSet accepts values in following formats:

  1231. //   - HSet("myhash", "key1", "value1", "key2", "value2")

  1232. //   - HSet("myhash", []string{"key1", "value1", "key2", "value2"})

  1233. //   - HSet("myhash", map[string]interface{}{"key1": "value1", "key2": "value2"})

  1234. //

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

  1236. func (c cmdable) HSet(ctx context.Context, key string, values ...interface{}) *IntCmd {

  1237. 	args := make([]interface{}, 2, 2+len(values))

  1238. 	args[0] = "hset"

  1239. 	args[1] = key

  1240. 	args = appendArgs(args, values)

  1241. 	cmd := NewIntCmd(ctx, args...)

  1242. 	_ = c(ctx, cmd)

  1243. 	return cmd

  1244. }

  1245. 

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

  1247. func (c cmdable) HMSet(ctx context.Context, key string, values ...interface{}) *BoolCmd {

  1248. 	args := make([]interface{}, 2, 2+len(values))

  1249. 	args[0] = "hmset"

  1250. 	args[1] = key

  1251. 	args = appendArgs(args, values)

  1252. 	cmd := NewBoolCmd(ctx, args...)

  1253. 	_ = c(ctx, cmd)

  1254. 	return cmd

  1255. }

  1256. 

  1257. func (c cmdable) HSetNX(ctx context.Context, key, field string, value interface{}) *BoolCmd {

  1258. 	cmd := NewBoolCmd(ctx, "hsetnx", key, field, value)

  1259. 	_ = c(ctx, cmd)

  1260. 	return cmd

  1261. }

  1262. 

  1263. func (c cmdable) HVals(ctx context.Context, key string) *StringSliceCmd {

  1264. 	cmd := NewStringSliceCmd(ctx, "hvals", key)

  1265. 	_ = c(ctx, cmd)

  1266. 	return cmd

  1267. }

  1268. 

  1269. // HRandField redis-server version >= 6.2.0.

  1270. func (c cmdable) HRandField(ctx context.Context, key string, count int, withValues bool) *StringSliceCmd {

  1271. 	args := make([]interface{}, 0, 4)

  1272. 

  1273. 	// Although count=0 is meaningless, redis accepts count=0.

  1274. 	args = append(args, "hrandfield", key, count)

  1275. 	if withValues {

  1276. 		args = append(args, "withvalues")

  1277. 	}

  1278. 

  1279. 	cmd := NewStringSliceCmd(ctx, args...)

  1280. 	_ = c(ctx, cmd)

  1281. 	return cmd

  1282. }

  1283. 

  1284. //------------------------------------------------------------------------------

  1285. 

  1286. func (c cmdable) BLPop(ctx context.Context, timeout time.Duration, keys ...string) *StringSliceCmd {

  1287. 	args := make([]interface{}, 1+len(keys)+1)

  1288. 	args[0] = "blpop"

  1289. 	for i, key := range keys {

  1290. 		args[1+i] = key

  1291. 	}

  1292. 	args[len(args)-1] = formatSec(ctx, timeout)

  1293. 	cmd := NewStringSliceCmd(ctx, args...)

  1294. 	cmd.setReadTimeout(timeout)

  1295. 	_ = c(ctx, cmd)

  1296. 	return cmd

  1297. }

  1298. 

  1299. func (c cmdable) BRPop(ctx context.Context, timeout time.Duration, keys ...string) *StringSliceCmd {

  1300. 	args := make([]interface{}, 1+len(keys)+1)

  1301. 	args[0] = "brpop"

  1302. 	for i, key := range keys {

  1303. 		args[1+i] = key

  1304. 	}

  1305. 	args[len(keys)+1] = formatSec(ctx, timeout)

  1306. 	cmd := NewStringSliceCmd(ctx, args...)

  1307. 	cmd.setReadTimeout(timeout)

  1308. 	_ = c(ctx, cmd)

  1309. 	return cmd

  1310. }

  1311. 

  1312. func (c cmdable) BRPopLPush(ctx context.Context, source, destination string, timeout time.Duration) *StringCmd {

  1313. 	cmd := NewStringCmd(

  1314. 		ctx,

  1315. 		"brpoplpush",

  1316. 		source,

  1317. 		destination,

  1318. 		formatSec(ctx, timeout),

  1319. 	)

  1320. 	cmd.setReadTimeout(timeout)

  1321. 	_ = c(ctx, cmd)

  1322. 	return cmd

  1323. }

  1324. 

  1325. func (c cmdable) LIndex(ctx context.Context, key string, index int64) *StringCmd {

  1326. 	cmd := NewStringCmd(ctx, "lindex", key, index)

  1327. 	_ = c(ctx, cmd)

  1328. 	return cmd

  1329. }

  1330. 

  1331. func (c cmdable) LInsert(ctx context.Context, key, op string, pivot, value interface{}) *IntCmd {

  1332. 	cmd := NewIntCmd(ctx, "linsert", key, op, pivot, value)

  1333. 	_ = c(ctx, cmd)

  1334. 	return cmd

  1335. }

  1336. 

  1337. func (c cmdable) LInsertBefore(ctx context.Context, key string, pivot, value interface{}) *IntCmd {

  1338. 	cmd := NewIntCmd(ctx, "linsert", key, "before", pivot, value)

  1339. 	_ = c(ctx, cmd)

  1340. 	return cmd

  1341. }

  1342. 

  1343. func (c cmdable) LInsertAfter(ctx context.Context, key string, pivot, value interface{}) *IntCmd {

  1344. 	cmd := NewIntCmd(ctx, "linsert", key, "after", pivot, value)

  1345. 	_ = c(ctx, cmd)

  1346. 	return cmd

  1347. }

  1348. 

  1349. func (c cmdable) LLen(ctx context.Context, key string) *IntCmd {

  1350. 	cmd := NewIntCmd(ctx, "llen", key)

  1351. 	_ = c(ctx, cmd)

  1352. 	return cmd

  1353. }

  1354. 

  1355. func (c cmdable) LPop(ctx context.Context, key string) *StringCmd {

  1356. 	cmd := NewStringCmd(ctx, "lpop", key)

  1357. 	_ = c(ctx, cmd)

  1358. 	return cmd

  1359. }

  1360. 

  1361. func (c cmdable) LPopCount(ctx context.Context, key string, count int) *StringSliceCmd {

  1362. 	cmd := NewStringSliceCmd(ctx, "lpop", key, count)

  1363. 	_ = c(ctx, cmd)

  1364. 	return cmd

  1365. }

  1366. 

  1367. type LPosArgs struct {

  1368. 	Rank, MaxLen int64

  1369. }

  1370. 

  1371. func (c cmdable) LPos(ctx context.Context, key string, value string, a LPosArgs) *IntCmd {

  1372. 	args := []interface{}{"lpos", key, value}

  1373. 	if a.Rank != 0 {

  1374. 		args = append(args, "rank", a.Rank)

  1375. 	}

  1376. 	if a.MaxLen != 0 {

  1377. 		args = append(args, "maxlen", a.MaxLen)

  1378. 	}

  1379. 

  1380. 	cmd := NewIntCmd(ctx, args...)

  1381. 	_ = c(ctx, cmd)

  1382. 	return cmd

  1383. }

  1384. 

  1385. func (c cmdable) LPosCount(ctx context.Context, key string, value string, count int64, a LPosArgs) *IntSliceCmd {

  1386. 	args := []interface{}{"lpos", key, value, "count", count}

  1387. 	if a.Rank != 0 {

  1388. 		args = append(args, "rank", a.Rank)

  1389. 	}

  1390. 	if a.MaxLen != 0 {

  1391. 		args = append(args, "maxlen", a.MaxLen)

  1392. 	}

  1393. 	cmd := NewIntSliceCmd(ctx, args...)

  1394. 	_ = c(ctx, cmd)

  1395. 	return cmd

  1396. }

  1397. 

  1398. func (c cmdable) LPush(ctx context.Context, key string, values ...interface{}) *IntCmd {

  1399. 	args := make([]interface{}, 2, 2+len(values))

  1400. 	args[0] = "lpush"

  1401. 	args[1] = key

  1402. 	args = appendArgs(args, values)

  1403. 	cmd := NewIntCmd(ctx, args...)

  1404. 	_ = c(ctx, cmd)

  1405. 	return cmd

  1406. }

  1407. 

  1408. func (c cmdable) LPushX(ctx context.Context, key string, values ...interface{}) *IntCmd {

  1409. 	args := make([]interface{}, 2, 2+len(values))

  1410. 	args[0] = "lpushx"

  1411. 	args[1] = key

  1412. 	args = appendArgs(args, values)

  1413. 	cmd := NewIntCmd(ctx, args...)

  1414. 	_ = c(ctx, cmd)

  1415. 	return cmd

  1416. }

  1417. 

  1418. func (c cmdable) LRange(ctx context.Context, key string, start, stop int64) *StringSliceCmd {

  1419. 	cmd := NewStringSliceCmd(

  1420. 		ctx,

  1421. 		"lrange",

  1422. 		key,

  1423. 		start,

  1424. 		stop,

  1425. 	)

  1426. 	_ = c(ctx, cmd)

  1427. 	return cmd

  1428. }

  1429. 

  1430. func (c cmdable) LRem(ctx context.Context, key string, count int64, value interface{}) *IntCmd {

  1431. 	cmd := NewIntCmd(ctx, "lrem", key, count, value)

  1432. 	_ = c(ctx, cmd)

  1433. 	return cmd

  1434. }

  1435. 

  1436. func (c cmdable) LSet(ctx context.Context, key string, index int64, value interface{}) *StatusCmd {

  1437. 	cmd := NewStatusCmd(ctx, "lset", key, index, value)

  1438. 	_ = c(ctx, cmd)

  1439. 	return cmd

  1440. }

  1441. 

  1442. func (c cmdable) LTrim(ctx context.Context, key string, start, stop int64) *StatusCmd {

  1443. 	cmd := NewStatusCmd(

  1444. 		ctx,

  1445. 		"ltrim",

  1446. 		key,

  1447. 		start,

  1448. 		stop,

  1449. 	)

  1450. 	_ = c(ctx, cmd)

  1451. 	return cmd

  1452. }

  1453. 

  1454. func (c cmdable) RPop(ctx context.Context, key string) *StringCmd {

  1455. 	cmd := NewStringCmd(ctx, "rpop", key)

  1456. 	_ = c(ctx, cmd)

  1457. 	return cmd

  1458. }

  1459. 

  1460. func (c cmdable) RPopCount(ctx context.Context, key string, count int) *StringSliceCmd {

  1461. 	cmd := NewStringSliceCmd(ctx, "rpop", key, count)

  1462. 	_ = c(ctx, cmd)

  1463. 	return cmd

  1464. }

  1465. 

  1466. func (c cmdable) RPopLPush(ctx context.Context, source, destination string) *StringCmd {

  1467. 	cmd := NewStringCmd(ctx, "rpoplpush", source, destination)

  1468. 	_ = c(ctx, cmd)

  1469. 	return cmd

  1470. }

  1471. 

  1472. func (c cmdable) RPush(ctx context.Context, key string, values ...interface{}) *IntCmd {

  1473. 	args := make([]interface{}, 2, 2+len(values))

  1474. 	args[0] = "rpush"

  1475. 	args[1] = key

  1476. 	args = appendArgs(args, values)

  1477. 	cmd := NewIntCmd(ctx, args...)

  1478. 	_ = c(ctx, cmd)

  1479. 	return cmd

  1480. }

  1481. 

  1482. func (c cmdable) RPushX(ctx context.Context, key string, values ...interface{}) *IntCmd {

  1483. 	args := make([]interface{}, 2, 2+len(values))

  1484. 	args[0] = "rpushx"

  1485. 	args[1] = key

  1486. 	args = appendArgs(args, values)

  1487. 	cmd := NewIntCmd(ctx, args...)

  1488. 	_ = c(ctx, cmd)

  1489. 	return cmd

  1490. }

  1491. 

  1492. func (c cmdable) LMove(ctx context.Context, source, destination, srcpos, destpos string) *StringCmd {

  1493. 	cmd := NewStringCmd(ctx, "lmove", source, destination, srcpos, destpos)

  1494. 	_ = c(ctx, cmd)

  1495. 	return cmd

  1496. }

  1497. 

  1498. func (c cmdable) BLMove(

  1499. 	ctx context.Context, source, destination, srcpos, destpos string, timeout time.Duration,

  1500. ) *StringCmd {

  1501. 	cmd := NewStringCmd(ctx, "blmove", source, destination, srcpos, destpos, formatSec(ctx, timeout))

  1502. 	cmd.setReadTimeout(timeout)

  1503. 	_ = c(ctx, cmd)

  1504. 	return cmd

  1505. }

  1506. 

  1507. //------------------------------------------------------------------------------

  1508. 

  1509. func (c cmdable) SAdd(ctx context.Context, key string, members ...interface{}) *IntCmd {

  1510. 	args := make([]interface{}, 2, 2+len(members))

  1511. 	args[0] = "sadd"

  1512. 	args[1] = key

  1513. 	args = appendArgs(args, members)

  1514. 	cmd := NewIntCmd(ctx, args...)

  1515. 	_ = c(ctx, cmd)

  1516. 	return cmd

  1517. }

  1518. 

  1519. func (c cmdable) SCard(ctx context.Context, key string) *IntCmd {

  1520. 	cmd := NewIntCmd(ctx, "scard", key)

  1521. 	_ = c(ctx, cmd)

  1522. 	return cmd

  1523. }

  1524. 

  1525. func (c cmdable) SDiff(ctx context.Context, keys ...string) *StringSliceCmd {

  1526. 	args := make([]interface{}, 1+len(keys))

  1527. 	args[0] = "sdiff"

  1528. 	for i, key := range keys {

  1529. 		args[1+i] = key

  1530. 	}

  1531. 	cmd := NewStringSliceCmd(ctx, args...)

  1532. 	_ = c(ctx, cmd)

  1533. 	return cmd

  1534. }

  1535. 

  1536. func (c cmdable) SDiffStore(ctx context.Context, destination string, keys ...string) *IntCmd {

  1537. 	args := make([]interface{}, 2+len(keys))

  1538. 	args[0] = "sdiffstore"

  1539. 	args[1] = destination

  1540. 	for i, key := range keys {

  1541. 		args[2+i] = key

  1542. 	}

  1543. 	cmd := NewIntCmd(ctx, args...)

  1544. 	_ = c(ctx, cmd)

  1545. 	return cmd

  1546. }

  1547. 

  1548. func (c cmdable) SInter(ctx context.Context, keys ...string) *StringSliceCmd {

  1549. 	args := make([]interface{}, 1+len(keys))

  1550. 	args[0] = "sinter"

  1551. 	for i, key := range keys {

  1552. 		args[1+i] = key

  1553. 	}

  1554. 	cmd := NewStringSliceCmd(ctx, args...)

  1555. 	_ = c(ctx, cmd)

  1556. 	return cmd

  1557. }

  1558. 

  1559. func (c cmdable) SInterStore(ctx context.Context, destination string, keys ...string) *IntCmd {

  1560. 	args := make([]interface{}, 2+len(keys))

  1561. 	args[0] = "sinterstore"

  1562. 	args[1] = destination

  1563. 	for i, key := range keys {

  1564. 		args[2+i] = key

  1565. 	}

  1566. 	cmd := NewIntCmd(ctx, args...)

  1567. 	_ = c(ctx, cmd)

  1568. 	return cmd

  1569. }

  1570. 

  1571. func (c cmdable) SIsMember(ctx context.Context, key string, member interface{}) *BoolCmd {

  1572. 	cmd := NewBoolCmd(ctx, "sismember", key, member)

  1573. 	_ = c(ctx, cmd)

  1574. 	return cmd

  1575. }

  1576. 

  1577. // SMIsMember Redis `SMISMEMBER key member [member ...]` command.

  1578. func (c cmdable) SMIsMember(ctx context.Context, key string, members ...interface{}) *BoolSliceCmd {

  1579. 	args := make([]interface{}, 2, 2+len(members))

  1580. 	args[0] = "smismember"

  1581. 	args[1] = key

  1582. 	args = appendArgs(args, members)

  1583. 	cmd := NewBoolSliceCmd(ctx, args...)

  1584. 	_ = c(ctx, cmd)

  1585. 	return cmd

  1586. }

  1587. 

  1588. // SMembers Redis `SMEMBERS key` command output as a slice.

  1589. func (c cmdable) SMembers(ctx context.Context, key string) *StringSliceCmd {

  1590. 	cmd := NewStringSliceCmd(ctx, "smembers", key)

  1591. 	_ = c(ctx, cmd)

  1592. 	return cmd

  1593. }

  1594. 

  1595. // SMembersMap Redis `SMEMBERS key` command output as a map.

  1596. func (c cmdable) SMembersMap(ctx context.Context, key string) *StringStructMapCmd {

  1597. 	cmd := NewStringStructMapCmd(ctx, "smembers", key)

  1598. 	_ = c(ctx, cmd)

  1599. 	return cmd

  1600. }

  1601. 

  1602. func (c cmdable) SMove(ctx context.Context, source, destination string, member interface{}) *BoolCmd {

  1603. 	cmd := NewBoolCmd(ctx, "smove", source, destination, member)

  1604. 	_ = c(ctx, cmd)

  1605. 	return cmd

  1606. }

  1607. 

  1608. // SPop Redis `SPOP key` command.

  1609. func (c cmdable) SPop(ctx context.Context, key string) *StringCmd {

  1610. 	cmd := NewStringCmd(ctx, "spop", key)

  1611. 	_ = c(ctx, cmd)

  1612. 	return cmd

  1613. }

  1614. 

  1615. // SPopN Redis `SPOP key count` command.

  1616. func (c cmdable) SPopN(ctx context.Context, key string, count int64) *StringSliceCmd {

  1617. 	cmd := NewStringSliceCmd(ctx, "spop", key, count)

  1618. 	_ = c(ctx, cmd)

  1619. 	return cmd

  1620. }

  1621. 

  1622. // SRandMember Redis `SRANDMEMBER key` command.

  1623. func (c cmdable) SRandMember(ctx context.Context, key string) *StringCmd {

  1624. 	cmd := NewStringCmd(ctx, "srandmember", key)

  1625. 	_ = c(ctx, cmd)

  1626. 	return cmd

  1627. }

  1628. 

  1629. // SRandMemberN Redis `SRANDMEMBER key count` command.

  1630. func (c cmdable) SRandMemberN(ctx context.Context, key string, count int64) *StringSliceCmd {

  1631. 	cmd := NewStringSliceCmd(ctx, "srandmember", key, count)

  1632. 	_ = c(ctx, cmd)

  1633. 	return cmd

  1634. }

  1635. 

  1636. func (c cmdable) SRem(ctx context.Context, key string, members ...interface{}) *IntCmd {

  1637. 	args := make([]interface{}, 2, 2+len(members))

  1638. 	args[0] = "srem"

  1639. 	args[1] = key

  1640. 	args = appendArgs(args, members)

  1641. 	cmd := NewIntCmd(ctx, args...)

  1642. 	_ = c(ctx, cmd)

  1643. 	return cmd

  1644. }

  1645. 

  1646. func (c cmdable) SUnion(ctx context.Context, keys ...string) *StringSliceCmd {

  1647. 	args := make([]interface{}, 1+len(keys))

  1648. 	args[0] = "sunion"

  1649. 	for i, key := range keys {

  1650. 		args[1+i] = key

  1651. 	}

  1652. 	cmd := NewStringSliceCmd(ctx, args...)

  1653. 	_ = c(ctx, cmd)

  1654. 	return cmd

  1655. }

  1656. 

  1657. func (c cmdable) SUnionStore(ctx context.Context, destination string, keys ...string) *IntCmd {

  1658. 	args := make([]interface{}, 2+len(keys))

  1659. 	args[0] = "sunionstore"

  1660. 	args[1] = destination

  1661. 	for i, key := range keys {

  1662. 		args[2+i] = key

  1663. 	}

  1664. 	cmd := NewIntCmd(ctx, args...)

  1665. 	_ = c(ctx, cmd)

  1666. 	return cmd

  1667. }

  1668. 

  1669. //------------------------------------------------------------------------------

  1670. 

  1671. // XAddArgs accepts values in the following formats:

  1672. //   - XAddArgs.Values = []interface{}{"key1", "value1", "key2", "value2"}

  1673. //   - XAddArgs.Values = []string("key1", "value1", "key2", "value2")

  1674. //   - XAddArgs.Values = map[string]interface{}{"key1": "value1", "key2": "value2"}

  1675. //

  1676. // Note that map will not preserve the order of key-value pairs.

  1677. // MaxLen/MaxLenApprox and MinID are in conflict, only one of them can be used.

  1678. type XAddArgs struct {

  1679. 	Stream     string

  1680. 	NoMkStream bool

  1681. 	MaxLen     int64 // MAXLEN N

  1682. 

  1683. 	// Deprecated: use MaxLen+Approx, remove in v9.

  1684. 	MaxLenApprox int64 // MAXLEN ~ N

  1685. 

  1686. 	MinID string

  1687. 	// Approx causes MaxLen and MinID to use "~" matcher (instead of "=").

  1688. 	Approx bool

  1689. 	Limit  int64

  1690. 	ID     string

  1691. 	Values interface{}

  1692. }

  1693. 

  1694. // XAdd a.Limit has a bug, please confirm it and use it.

  1695. // issue: https://github.com/redis/redis/issues/9046

  1696. func (c cmdable) XAdd(ctx context.Context, a *XAddArgs) *StringCmd {

  1697. 	args := make([]interface{}, 0, 11)

  1698. 	args = append(args, "xadd", a.Stream)

  1699. 	if a.NoMkStream {

  1700. 		args = append(args, "nomkstream")

  1701. 	}

  1702. 	switch {

  1703. 	case a.MaxLen > 0:

  1704. 		if a.Approx {

  1705. 			args = append(args, "maxlen", "~", a.MaxLen)

  1706. 		} else {

  1707. 			args = append(args, "maxlen", a.MaxLen)

  1708. 		}

  1709. 	case a.MaxLenApprox > 0:

  1710. 		// TODO remove in v9.

  1711. 		args = append(args, "maxlen", "~", a.MaxLenApprox)

  1712. 	case a.MinID != "":

  1713. 		if a.Approx {

  1714. 			args = append(args, "minid", "~", a.MinID)

  1715. 		} else {

  1716. 			args = append(args, "minid", a.MinID)

  1717. 		}

  1718. 	}

  1719. 	if a.Limit > 0 {

  1720. 		args = append(args, "limit", a.Limit)

  1721. 	}

  1722. 	if a.ID != "" {

  1723. 		args = append(args, a.ID)

  1724. 	} else {

  1725. 		args = append(args, "*")

  1726. 	}

  1727. 	args = appendArg(args, a.Values)

  1728. 

  1729. 	cmd := NewStringCmd(ctx, args...)

  1730. 	_ = c(ctx, cmd)

  1731. 	return cmd

  1732. }

  1733. 

  1734. func (c cmdable) XDel(ctx context.Context, stream string, ids ...string) *IntCmd {

  1735. 	args := []interface{}{"xdel", stream}

  1736. 	for _, id := range ids {

  1737. 		args = append(args, id)

  1738. 	}

  1739. 	cmd := NewIntCmd(ctx, args...)

  1740. 	_ = c(ctx, cmd)

  1741. 	return cmd

  1742. }

  1743. 

  1744. func (c cmdable) XLen(ctx context.Context, stream string) *IntCmd {

  1745. 	cmd := NewIntCmd(ctx, "xlen", stream)

  1746. 	_ = c(ctx, cmd)

  1747. 	return cmd

  1748. }

  1749. 

  1750. func (c cmdable) XRange(ctx context.Context, stream, start, stop string) *XMessageSliceCmd {

  1751. 	cmd := NewXMessageSliceCmd(ctx, "xrange", stream, start, stop)

  1752. 	_ = c(ctx, cmd)

  1753. 	return cmd

  1754. }

  1755. 

  1756. func (c cmdable) XRangeN(ctx context.Context, stream, start, stop string, count int64) *XMessageSliceCmd {

  1757. 	cmd := NewXMessageSliceCmd(ctx, "xrange", stream, start, stop, "count", count)

  1758. 	_ = c(ctx, cmd)

  1759. 	return cmd

  1760. }

  1761. 

  1762. func (c cmdable) XRevRange(ctx context.Context, stream, start, stop string) *XMessageSliceCmd {

  1763. 	cmd := NewXMessageSliceCmd(ctx, "xrevrange", stream, start, stop)

  1764. 	_ = c(ctx, cmd)

  1765. 	return cmd

  1766. }

  1767. 

  1768. func (c cmdable) XRevRangeN(ctx context.Context, stream, start, stop string, count int64) *XMessageSliceCmd {

  1769. 	cmd := NewXMessageSliceCmd(ctx, "xrevrange", stream, start, stop, "count", count)

  1770. 	_ = c(ctx, cmd)

  1771. 	return cmd

  1772. }

  1773. 

  1774. type XReadArgs struct {

  1775. 	Streams []string // list of streams and ids, e.g. stream1 stream2 id1 id2

  1776. 	Count   int64

  1777. 	Block   time.Duration

  1778. }

  1779. 

  1780. func (c cmdable) XRead(ctx context.Context, a *XReadArgs) *XStreamSliceCmd {

  1781. 	args := make([]interface{}, 0, 5+len(a.Streams))

  1782. 	args = append(args, "xread")

  1783. 

  1784. 	keyPos := int8(1)

  1785. 	if a.Count > 0 {

  1786. 		args = append(args, "count")

  1787. 		args = append(args, a.Count)

  1788. 		keyPos += 2

  1789. 	}

  1790. 	if a.Block >= 0 {

  1791. 		args = append(args, "block")

  1792. 		args = append(args, int64(a.Block/time.Millisecond))

  1793. 		keyPos += 2

  1794. 	}

  1795. 	args = append(args, "streams")

  1796. 	keyPos++

  1797. 	for _, s := range a.Streams {

  1798. 		args = append(args, s)

  1799. 	}

  1800. 

  1801. 	cmd := NewXStreamSliceCmd(ctx, args...)

  1802. 	if a.Block >= 0 {

  1803. 		cmd.setReadTimeout(a.Block)

  1804. 	}

  1805. 	cmd.setFirstKeyPos(keyPos)

  1806. 	_ = c(ctx, cmd)

  1807. 	return cmd

  1808. }

  1809. 

  1810. func (c cmdable) XReadStreams(ctx context.Context, streams ...string) *XStreamSliceCmd {

  1811. 	return c.XRead(ctx, &XReadArgs{

  1812. 		Streams: streams,

  1813. 		Block:   -1,

  1814. 	})

  1815. }

  1816. 

  1817. func (c cmdable) XGroupCreate(ctx context.Context, stream, group, start string) *StatusCmd {

  1818. 	cmd := NewStatusCmd(ctx, "xgroup", "create", stream, group, start)

  1819. 	_ = c(ctx, cmd)

  1820. 	return cmd

  1821. }

  1822. 

  1823. func (c cmdable) XGroupCreateMkStream(ctx context.Context, stream, group, start string) *StatusCmd {

  1824. 	cmd := NewStatusCmd(ctx, "xgroup", "create", stream, group, start, "mkstream")

  1825. 	_ = c(ctx, cmd)

  1826. 	return cmd

  1827. }

  1828. 

  1829. func (c cmdable) XGroupSetID(ctx context.Context, stream, group, start string) *StatusCmd {

  1830. 	cmd := NewStatusCmd(ctx, "xgroup", "setid", stream, group, start)

  1831. 	_ = c(ctx, cmd)

  1832. 	return cmd

  1833. }

  1834. 

  1835. func (c cmdable) XGroupDestroy(ctx context.Context, stream, group string) *IntCmd {

  1836. 	cmd := NewIntCmd(ctx, "xgroup", "destroy", stream, group)

  1837. 	_ = c(ctx, cmd)

  1838. 	return cmd

  1839. }

  1840. 

  1841. func (c cmdable) XGroupCreateConsumer(ctx context.Context, stream, group, consumer string) *IntCmd {

  1842. 	cmd := NewIntCmd(ctx, "xgroup", "createconsumer", stream, group, consumer)

  1843. 	_ = c(ctx, cmd)

  1844. 	return cmd

  1845. }

  1846. 

  1847. func (c cmdable) XGroupDelConsumer(ctx context.Context, stream, group, consumer string) *IntCmd {

  1848. 	cmd := NewIntCmd(ctx, "xgroup", "delconsumer", stream, group, consumer)

  1849. 	_ = c(ctx, cmd)

  1850. 	return cmd

  1851. }

  1852. 

  1853. type XReadGroupArgs struct {

  1854. 	Group    string

  1855. 	Consumer string

  1856. 	Streams  []string // list of streams and ids, e.g. stream1 stream2 id1 id2

  1857. 	Count    int64

  1858. 	Block    time.Duration

  1859. 	NoAck    bool

  1860. }

  1861. 

  1862. func (c cmdable) XReadGroup(ctx context.Context, a *XReadGroupArgs) *XStreamSliceCmd {

  1863. 	args := make([]interface{}, 0, 8+len(a.Streams))

  1864. 	args = append(args, "xreadgroup", "group", a.Group, a.Consumer)

  1865. 

  1866. 	keyPos := int8(4)

  1867. 	if a.Count > 0 {

  1868. 		args = append(args, "count", a.Count)

  1869. 		keyPos += 2

  1870. 	}

  1871. 	if a.Block >= 0 {

  1872. 		args = append(args, "block", int64(a.Block/time.Millisecond))

  1873. 		keyPos += 2

  1874. 	}

  1875. 	if a.NoAck {

  1876. 		args = append(args, "noack")

  1877. 		keyPos++

  1878. 	}

  1879. 	args = append(args, "streams")

  1880. 	keyPos++

  1881. 	for _, s := range a.Streams {

  1882. 		args = append(args, s)

  1883. 	}

  1884. 

  1885. 	cmd := NewXStreamSliceCmd(ctx, args...)

  1886. 	if a.Block >= 0 {

  1887. 		cmd.setReadTimeout(a.Block)

  1888. 	}

  1889. 	cmd.setFirstKeyPos(keyPos)

  1890. 	_ = c(ctx, cmd)

  1891. 	return cmd

  1892. }

  1893. 

  1894. func (c cmdable) XAck(ctx context.Context, stream, group string, ids ...string) *IntCmd {

  1895. 	args := []interface{}{"xack", stream, group}

  1896. 	for _, id := range ids {

  1897. 		args = append(args, id)

  1898. 	}

  1899. 	cmd := NewIntCmd(ctx, args...)

  1900. 	_ = c(ctx, cmd)

  1901. 	return cmd

  1902. }

  1903. 

  1904. func (c cmdable) XPending(ctx context.Context, stream, group string) *XPendingCmd {

  1905. 	cmd := NewXPendingCmd(ctx, "xpending", stream, group)

  1906. 	_ = c(ctx, cmd)

  1907. 	return cmd

  1908. }

  1909. 

  1910. type XPendingExtArgs struct {

  1911. 	Stream   string

  1912. 	Group    string

  1913. 	Idle     time.Duration

  1914. 	Start    string

  1915. 	End      string

  1916. 	Count    int64

  1917. 	Consumer string

  1918. }

  1919. 

  1920. func (c cmdable) XPendingExt(ctx context.Context, a *XPendingExtArgs) *XPendingExtCmd {

  1921. 	args := make([]interface{}, 0, 9)

  1922. 	args = append(args, "xpending", a.Stream, a.Group)

  1923. 	if a.Idle != 0 {

  1924. 		args = append(args, "idle", formatMs(ctx, a.Idle))

  1925. 	}

  1926. 	args = append(args, a.Start, a.End, a.Count)

  1927. 	if a.Consumer != "" {

  1928. 		args = append(args, a.Consumer)

  1929. 	}

  1930. 	cmd := NewXPendingExtCmd(ctx, args...)

  1931. 	_ = c(ctx, cmd)

  1932. 	return cmd

  1933. }

  1934. 

  1935. type XAutoClaimArgs struct {

  1936. 	Stream   string

  1937. 	Group    string

  1938. 	MinIdle  time.Duration

  1939. 	Start    string

  1940. 	Count    int64

  1941. 	Consumer string

  1942. }

  1943. 

  1944. func (c cmdable) XAutoClaim(ctx context.Context, a *XAutoClaimArgs) *XAutoClaimCmd {

  1945. 	args := xAutoClaimArgs(ctx, a)

  1946. 	cmd := NewXAutoClaimCmd(ctx, args...)

  1947. 	_ = c(ctx, cmd)

  1948. 	return cmd

  1949. }

  1950. 

  1951. func (c cmdable) XAutoClaimJustID(ctx context.Context, a *XAutoClaimArgs) *XAutoClaimJustIDCmd {

  1952. 	args := xAutoClaimArgs(ctx, a)

  1953. 	args = append(args, "justid")

  1954. 	cmd := NewXAutoClaimJustIDCmd(ctx, args...)

  1955. 	_ = c(ctx, cmd)

  1956. 	return cmd

  1957. }

  1958. 

  1959. func xAutoClaimArgs(ctx context.Context, a *XAutoClaimArgs) []interface{} {

  1960. 	args := make([]interface{}, 0, 9)

  1961. 	args = append(args, "xautoclaim", a.Stream, a.Group, a.Consumer, formatMs(ctx, a.MinIdle), a.Start)

  1962. 	if a.Count > 0 {

  1963. 		args = append(args, "count", a.Count)

  1964. 	}

  1965. 	return args

  1966. }

  1967. 

  1968. type XClaimArgs struct {

  1969. 	Stream   string

  1970. 	Group    string

  1971. 	Consumer string

  1972. 	MinIdle  time.Duration

  1973. 	Messages []string

  1974. }

  1975. 

  1976. func (c cmdable) XClaim(ctx context.Context, a *XClaimArgs) *XMessageSliceCmd {

  1977. 	args := xClaimArgs(a)

  1978. 	cmd := NewXMessageSliceCmd(ctx, args...)

  1979. 	_ = c(ctx, cmd)

  1980. 	return cmd

  1981. }

  1982. 

  1983. func (c cmdable) XClaimJustID(ctx context.Context, a *XClaimArgs) *StringSliceCmd {

  1984. 	args := xClaimArgs(a)

  1985. 	args = append(args, "justid")

  1986. 	cmd := NewStringSliceCmd(ctx, args...)

  1987. 	_ = c(ctx, cmd)

  1988. 	return cmd

  1989. }

  1990. 

  1991. func xClaimArgs(a *XClaimArgs) []interface{} {

  1992. 	args := make([]interface{}, 0, 4+len(a.Messages))

  1993. 	args = append(args,

  1994. 		"xclaim",

  1995. 		a.Stream,

  1996. 		a.Group, a.Consumer,

  1997. 		int64(a.MinIdle/time.Millisecond))

  1998. 	for _, id := range a.Messages {

  1999. 		args = append(args, id)

  2000. 	}

  2001. 	return args

  2002. }

  2003. 

  2004. // xTrim If approx is true, add the "~" parameter, otherwise it is the default "=" (redis default).

  2005. // example:

  2006. //		XTRIM key MAXLEN/MINID threshold LIMIT limit.

  2007. //		XTRIM key MAXLEN/MINID ~ threshold LIMIT limit.

  2008. // The redis-server version is lower than 6.2, please set limit to 0.

  2009. func (c cmdable) xTrim(

  2010. 	ctx context.Context, key, strategy string,

  2011. 	approx bool, threshold interface{}, limit int64,

  2012. ) *IntCmd {

  2013. 	args := make([]interface{}, 0, 7)

  2014. 	args = append(args, "xtrim", key, strategy)

  2015. 	if approx {

  2016. 		args = append(args, "~")

  2017. 	}

  2018. 	args = append(args, threshold)

  2019. 	if limit > 0 {

  2020. 		args = append(args, "limit", limit)

  2021. 	}

  2022. 	cmd := NewIntCmd(ctx, args...)

  2023. 	_ = c(ctx, cmd)

  2024. 	return cmd

  2025. }

  2026. 

  2027. // Deprecated: use XTrimMaxLen, remove in v9.

  2028. func (c cmdable) XTrim(ctx context.Context, key string, maxLen int64) *IntCmd {

  2029. 	return c.xTrim(ctx, key, "maxlen", false, maxLen, 0)

  2030. }

  2031. 

  2032. // Deprecated: use XTrimMaxLenApprox, remove in v9.

  2033. func (c cmdable) XTrimApprox(ctx context.Context, key string, maxLen int64) *IntCmd {

  2034. 	return c.xTrim(ctx, key, "maxlen", true, maxLen, 0)

  2035. }

  2036. 

  2037. // XTrimMaxLen No `~` rules are used, `limit` cannot be used.

  2038. // cmd: XTRIM key MAXLEN maxLen

  2039. func (c cmdable) XTrimMaxLen(ctx context.Context, key string, maxLen int64) *IntCmd {

  2040. 	return c.xTrim(ctx, key, "maxlen", false, maxLen, 0)

  2041. }

  2042. 

  2043. // XTrimMaxLenApprox LIMIT has a bug, please confirm it and use it.

  2044. // issue: https://github.com/redis/redis/issues/9046

  2045. // cmd: XTRIM key MAXLEN ~ maxLen LIMIT limit

  2046. func (c cmdable) XTrimMaxLenApprox(ctx context.Context, key string, maxLen, limit int64) *IntCmd {

  2047. 	return c.xTrim(ctx, key, "maxlen", true, maxLen, limit)

  2048. }

  2049. 

  2050. // XTrimMinID No `~` rules are used, `limit` cannot be used.

  2051. // cmd: XTRIM key MINID minID

  2052. func (c cmdable) XTrimMinID(ctx context.Context, key string, minID string) *IntCmd {

  2053. 	return c.xTrim(ctx, key, "minid", false, minID, 0)

  2054. }

  2055. 

  2056. // XTrimMinIDApprox LIMIT has a bug, please confirm it and use it.

  2057. // issue: https://github.com/redis/redis/issues/9046

  2058. // cmd: XTRIM key MINID ~ minID LIMIT limit

  2059. func (c cmdable) XTrimMinIDApprox(ctx context.Context, key string, minID string, limit int64) *IntCmd {

  2060. 	return c.xTrim(ctx, key, "minid", true, minID, limit)

  2061. }

  2062. 

  2063. func (c cmdable) XInfoConsumers(ctx context.Context, key string, group string) *XInfoConsumersCmd {

  2064. 	cmd := NewXInfoConsumersCmd(ctx, key, group)

  2065. 	_ = c(ctx, cmd)

  2066. 	return cmd

  2067. }

  2068. 

  2069. func (c cmdable) XInfoGroups(ctx context.Context, key string) *XInfoGroupsCmd {

  2070. 	cmd := NewXInfoGroupsCmd(ctx, key)

  2071. 	_ = c(ctx, cmd)

  2072. 	return cmd

  2073. }

  2074. 

  2075. func (c cmdable) XInfoStream(ctx context.Context, key string) *XInfoStreamCmd {

  2076. 	cmd := NewXInfoStreamCmd(ctx, key)

  2077. 	_ = c(ctx, cmd)

  2078. 	return cmd

  2079. }

  2080. 

  2081. // XInfoStreamFull XINFO STREAM FULL [COUNT count]

  2082. // redis-server >= 6.0.

  2083. func (c cmdable) XInfoStreamFull(ctx context.Context, key string, count int) *XInfoStreamFullCmd {

  2084. 	args := make([]interface{}, 0, 6)

  2085. 	args = append(args, "xinfo", "stream", key, "full")

  2086. 	if count > 0 {

  2087. 		args = append(args, "count", count)

  2088. 	}

  2089. 	cmd := NewXInfoStreamFullCmd(ctx, args...)

  2090. 	_ = c(ctx, cmd)

  2091. 	return cmd

  2092. }

  2093. 

  2094. //------------------------------------------------------------------------------

  2095. 

  2096. // Z represents sorted set member.

  2097. type Z struct {

  2098. 	Score  float64

  2099. 	Member interface{}

  2100. }

  2101. 

  2102. // ZWithKey represents sorted set member including the name of the key where it was popped.

  2103. type ZWithKey struct {

  2104. 	Z

  2105. 	Key string

  2106. }

  2107. 

  2108. // ZStore is used as an arg to ZInter/ZInterStore and ZUnion/ZUnionStore.

  2109. type ZStore struct {

  2110. 	Keys    []string

  2111. 	Weights []float64

  2112. 	// Can be SUM, MIN or MAX.

  2113. 	Aggregate string

  2114. }

  2115. 

  2116. func (z ZStore) len() (n int) {

  2117. 	n = len(z.Keys)

  2118. 	if len(z.Weights) > 0 {

  2119. 		n += 1 + len(z.Weights)

  2120. 	}

  2121. 	if z.Aggregate != "" {

  2122. 		n += 2

  2123. 	}

  2124. 	return n

  2125. }

  2126. 

  2127. func (z ZStore) appendArgs(args []interface{}) []interface{} {

  2128. 	for _, key := range z.Keys {

  2129. 		args = append(args, key)

  2130. 	}

  2131. 	if len(z.Weights) > 0 {

  2132. 		args = append(args, "weights")

  2133. 		for _, weights := range z.Weights {

  2134. 			args = append(args, weights)

  2135. 		}

  2136. 	}

  2137. 	if z.Aggregate != "" {

  2138. 		args = append(args, "aggregate", z.Aggregate)

  2139. 	}

  2140. 	return args

  2141. }

  2142. 

  2143. // BZPopMax Redis `BZPOPMAX key [key ...] timeout` command.

  2144. func (c cmdable) BZPopMax(ctx context.Context, timeout time.Duration, keys ...string) *ZWithKeyCmd {

  2145. 	args := make([]interface{}, 1+len(keys)+1)

  2146. 	args[0] = "bzpopmax"

  2147. 	for i, key := range keys {

  2148. 		args[1+i] = key

  2149. 	}

  2150. 	args[len(args)-1] = formatSec(ctx, timeout)

  2151. 	cmd := NewZWithKeyCmd(ctx, args...)

  2152. 	cmd.setReadTimeout(timeout)

  2153. 	_ = c(ctx, cmd)

  2154. 	return cmd

  2155. }

  2156. 

  2157. // BZPopMin Redis `BZPOPMIN key [key ...] timeout` command.

  2158. func (c cmdable) BZPopMin(ctx context.Context, timeout time.Duration, keys ...string) *ZWithKeyCmd {

  2159. 	args := make([]interface{}, 1+len(keys)+1)

  2160. 	args[0] = "bzpopmin"

  2161. 	for i, key := range keys {

  2162. 		args[1+i] = key

  2163. 	}

  2164. 	args[len(args)-1] = formatSec(ctx, timeout)

  2165. 	cmd := NewZWithKeyCmd(ctx, args...)

  2166. 	cmd.setReadTimeout(timeout)

  2167. 	_ = c(ctx, cmd)

  2168. 	return cmd

  2169. }

  2170. 

  2171. // ZAddArgs WARN: The GT, LT and NX options are mutually exclusive.

  2172. type ZAddArgs struct {

  2173. 	NX      bool

  2174. 	XX      bool

  2175. 	LT      bool

  2176. 	GT      bool

  2177. 	Ch      bool

  2178. 	Members []Z

  2179. }

  2180. 

  2181. func (c cmdable) zAddArgs(key string, args ZAddArgs, incr bool) []interface{} {

  2182. 	a := make([]interface{}, 0, 6+2*len(args.Members))

  2183. 	a = append(a, "zadd", key)

  2184. 

  2185. 	// The GT, LT and NX options are mutually exclusive.

  2186. 	if args.NX {

  2187. 		a = append(a, "nx")

  2188. 	} else {

  2189. 		if args.XX {

  2190. 			a = append(a, "xx")

  2191. 		}

  2192. 		if args.GT {

  2193. 			a = append(a, "gt")

  2194. 		} else if args.LT {

  2195. 			a = append(a, "lt")

  2196. 		}

  2197. 	}

  2198. 	if args.Ch {

  2199. 		a = append(a, "ch")

  2200. 	}

  2201. 	if incr {

  2202. 		a = append(a, "incr")

  2203. 	}

  2204. 	for _, m := range args.Members {

  2205. 		a = append(a, m.Score)

  2206. 		a = append(a, m.Member)

  2207. 	}

  2208. 	return a

  2209. }

  2210. 

  2211. func (c cmdable) ZAddArgs(ctx context.Context, key string, args ZAddArgs) *IntCmd {

  2212. 	cmd := NewIntCmd(ctx, c.zAddArgs(key, args, false)...)

  2213. 	_ = c(ctx, cmd)

  2214. 	return cmd

  2215. }

  2216. 

  2217. func (c cmdable) ZAddArgsIncr(ctx context.Context, key string, args ZAddArgs) *FloatCmd {

  2218. 	cmd := NewFloatCmd(ctx, c.zAddArgs(key, args, true)...)

  2219. 	_ = c(ctx, cmd)

  2220. 	return cmd

  2221. }

  2222. 

  2223. // TODO: Compatible with v8 api, will be removed in v9.

  2224. func (c cmdable) zAdd(ctx context.Context, key string, args ZAddArgs, members ...*Z) *IntCmd {

  2225. 	args.Members = make([]Z, len(members))

  2226. 	for i, m := range members {

  2227. 		args.Members[i] = *m

  2228. 	}

  2229. 	cmd := NewIntCmd(ctx, c.zAddArgs(key, args, false)...)

  2230. 	_ = c(ctx, cmd)

  2231. 	return cmd

  2232. }

  2233. 

  2234. // ZAdd Redis `ZADD key score member [score member ...]` command.

  2235. func (c cmdable) ZAdd(ctx context.Context, key string, members ...*Z) *IntCmd {

  2236. 	return c.zAdd(ctx, key, ZAddArgs{}, members...)

  2237. }

  2238. 

  2239. // ZAddNX Redis `ZADD key NX score member [score member ...]` command.

  2240. func (c cmdable) ZAddNX(ctx context.Context, key string, members ...*Z) *IntCmd {

  2241. 	return c.zAdd(ctx, key, ZAddArgs{

  2242. 		NX: true,

  2243. 	}, members...)

  2244. }

  2245. 

  2246. // ZAddXX Redis `ZADD key XX score member [score member ...]` command.

  2247. func (c cmdable) ZAddXX(ctx context.Context, key string, members ...*Z) *IntCmd {

  2248. 	return c.zAdd(ctx, key, ZAddArgs{

  2249. 		XX: true,

  2250. 	}, members...)

  2251. }

  2252. 

  2253. // ZAddCh Redis `ZADD key CH score member [score member ...]` command.

  2254. // Deprecated: Use

  2255. //		client.ZAddArgs(ctx, ZAddArgs{

  2256. //			Ch: true,

  2257. //			Members: []Z,

  2258. //		})

  2259. //	remove in v9.

  2260. func (c cmdable) ZAddCh(ctx context.Context, key string, members ...*Z) *IntCmd {

  2261. 	return c.zAdd(ctx, key, ZAddArgs{

  2262. 		Ch: true,

  2263. 	}, members...)

  2264. }

  2265. 

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

  2267. // Deprecated: Use

  2268. //		client.ZAddArgs(ctx, ZAddArgs{

  2269. //			NX: true,

  2270. //			Ch: true,

  2271. //			Members: []Z,

  2272. //		})

  2273. //	remove in v9.

  2274. func (c cmdable) ZAddNXCh(ctx context.Context, key string, members ...*Z) *IntCmd {

  2275. 	return c.zAdd(ctx, key, ZAddArgs{

  2276. 		NX: true,

  2277. 		Ch: true,

  2278. 	}, members...)

  2279. }

  2280. 

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

  2282. // Deprecated: Use

  2283. //		client.ZAddArgs(ctx, ZAddArgs{

  2284. //			XX: true,

  2285. //			Ch: true,

  2286. //			Members: []Z,

  2287. //		})

  2288. //	remove in v9.

  2289. func (c cmdable) ZAddXXCh(ctx context.Context, key string, members ...*Z) *IntCmd {

  2290. 	return c.zAdd(ctx, key, ZAddArgs{

  2291. 		XX: true,

  2292. 		Ch: true,

  2293. 	}, members...)

  2294. }

  2295. 

  2296. // ZIncr Redis `ZADD key INCR score member` command.

  2297. // Deprecated: Use

  2298. //		client.ZAddArgsIncr(ctx, ZAddArgs{

  2299. //			Members: []Z,

  2300. //		})

  2301. //	remove in v9.

  2302. func (c cmdable) ZIncr(ctx context.Context, key string, member *Z) *FloatCmd {

  2303. 	return c.ZAddArgsIncr(ctx, key, ZAddArgs{

  2304. 		Members: []Z{*member},

  2305. 	})

  2306. }

  2307. 

  2308. // ZIncrNX Redis `ZADD key NX INCR score member` command.

  2309. // Deprecated: Use

  2310. //		client.ZAddArgsIncr(ctx, ZAddArgs{

  2311. //			NX: true,

  2312. //			Members: []Z,

  2313. //		})

  2314. //	remove in v9.

  2315. func (c cmdable) ZIncrNX(ctx context.Context, key string, member *Z) *FloatCmd {

  2316. 	return c.ZAddArgsIncr(ctx, key, ZAddArgs{

  2317. 		NX:      true,

  2318. 		Members: []Z{*member},

  2319. 	})

  2320. }

  2321. 

  2322. // ZIncrXX Redis `ZADD key XX INCR score member` command.

  2323. // Deprecated: Use

  2324. //		client.ZAddArgsIncr(ctx, ZAddArgs{

  2325. //			XX: true,

  2326. //			Members: []Z,

  2327. //		})

  2328. //	remove in v9.

  2329. func (c cmdable) ZIncrXX(ctx context.Context, key string, member *Z) *FloatCmd {

  2330. 	return c.ZAddArgsIncr(ctx, key, ZAddArgs{

  2331. 		XX:      true,

  2332. 		Members: []Z{*member},

  2333. 	})

  2334. }

  2335. 

  2336. func (c cmdable) ZCard(ctx context.Context, key string) *IntCmd {

  2337. 	cmd := NewIntCmd(ctx, "zcard", key)

  2338. 	_ = c(ctx, cmd)

  2339. 	return cmd

  2340. }

  2341. 

  2342. func (c cmdable) ZCount(ctx context.Context, key, min, max string) *IntCmd {

  2343. 	cmd := NewIntCmd(ctx, "zcount", key, min, max)

  2344. 	_ = c(ctx, cmd)

  2345. 	return cmd

  2346. }

  2347. 

  2348. func (c cmdable) ZLexCount(ctx context.Context, key, min, max string) *IntCmd {

  2349. 	cmd := NewIntCmd(ctx, "zlexcount", key, min, max)

  2350. 	_ = c(ctx, cmd)

  2351. 	return cmd

  2352. }

  2353. 

  2354. func (c cmdable) ZIncrBy(ctx context.Context, key string, increment float64, member string) *FloatCmd {

  2355. 	cmd := NewFloatCmd(ctx, "zincrby", key, increment, member)

  2356. 	_ = c(ctx, cmd)

  2357. 	return cmd

  2358. }

  2359. 

  2360. func (c cmdable) ZInterStore(ctx context.Context, destination string, store *ZStore) *IntCmd {

  2361. 	args := make([]interface{}, 0, 3+store.len())

  2362. 	args = append(args, "zinterstore", destination, len(store.Keys))

  2363. 	args = store.appendArgs(args)

  2364. 	cmd := NewIntCmd(ctx, args...)

  2365. 	cmd.setFirstKeyPos(3)

  2366. 	_ = c(ctx, cmd)

  2367. 	return cmd

  2368. }

  2369. 

  2370. func (c cmdable) ZInter(ctx context.Context, store *ZStore) *StringSliceCmd {

  2371. 	args := make([]interface{}, 0, 2+store.len())

  2372. 	args = append(args, "zinter", len(store.Keys))

  2373. 	args = store.appendArgs(args)

  2374. 	cmd := NewStringSliceCmd(ctx, args...)

  2375. 	cmd.setFirstKeyPos(2)

  2376. 	_ = c(ctx, cmd)

  2377. 	return cmd

  2378. }

  2379. 

  2380. func (c cmdable) ZInterWithScores(ctx context.Context, store *ZStore) *ZSliceCmd {

  2381. 	args := make([]interface{}, 0, 3+store.len())

  2382. 	args = append(args, "zinter", len(store.Keys))

  2383. 	args = store.appendArgs(args)

  2384. 	args = append(args, "withscores")

  2385. 	cmd := NewZSliceCmd(ctx, args...)

  2386. 	cmd.setFirstKeyPos(2)

  2387. 	_ = c(ctx, cmd)

  2388. 	return cmd

  2389. }

  2390. 

  2391. func (c cmdable) ZMScore(ctx context.Context, key string, members ...string) *FloatSliceCmd {

  2392. 	args := make([]interface{}, 2+len(members))

  2393. 	args[0] = "zmscore"

  2394. 	args[1] = key

  2395. 	for i, member := range members {

  2396. 		args[2+i] = member

  2397. 	}

  2398. 	cmd := NewFloatSliceCmd(ctx, args...)

  2399. 	_ = c(ctx, cmd)

  2400. 	return cmd

  2401. }

  2402. 

  2403. func (c cmdable) ZPopMax(ctx context.Context, key string, count ...int64) *ZSliceCmd {

  2404. 	args := []interface{}{

  2405. 		"zpopmax",

  2406. 		key,

  2407. 	}

  2408. 

  2409. 	switch len(count) {

  2410. 	case 0:

  2411. 		break

  2412. 	case 1:

  2413. 		args = append(args, count[0])

  2414. 	default:

  2415. 		panic("too many arguments")

  2416. 	}

  2417. 

  2418. 	cmd := NewZSliceCmd(ctx, args...)

  2419. 	_ = c(ctx, cmd)

  2420. 	return cmd

  2421. }

  2422. 

  2423. func (c cmdable) ZPopMin(ctx context.Context, key string, count ...int64) *ZSliceCmd {

  2424. 	args := []interface{}{

  2425. 		"zpopmin",

  2426. 		key,

  2427. 	}

  2428. 

  2429. 	switch len(count) {

  2430. 	case 0:

  2431. 		break

  2432. 	case 1:

  2433. 		args = append(args, count[0])

  2434. 	default:

  2435. 		panic("too many arguments")

  2436. 	}

  2437. 

  2438. 	cmd := NewZSliceCmd(ctx, args...)

  2439. 	_ = c(ctx, cmd)

  2440. 	return cmd

  2441. }

  2442. 

  2443. // ZRangeArgs is all the options of the ZRange command.

  2444. // In version> 6.2.0, you can replace the(cmd):

  2445. //		ZREVRANGE,

  2446. //		ZRANGEBYSCORE,

  2447. //		ZREVRANGEBYSCORE,

  2448. //		ZRANGEBYLEX,

  2449. //		ZREVRANGEBYLEX.

  2450. // Please pay attention to your redis-server version.

  2451. //

  2452. // Rev, ByScore, ByLex and Offset+Count options require redis-server 6.2.0 and higher.

  2453. type ZRangeArgs struct {

  2454. 	Key string

  2455. 

  2456. 	// When the ByScore option is provided, the open interval(exclusive) can be set.

  2457. 	// By default, the score intervals specified by <Start> and <Stop> are closed (inclusive).

  2458. 	// It is similar to the deprecated(6.2.0+) ZRangeByScore command.

  2459. 	// For example:

  2460. 	//		ZRangeArgs{

  2461. 	//			Key: 				"example-key",

  2462. 	//	 		Start: 				"(3",

  2463. 	//	 		Stop: 				8,

  2464. 	//			ByScore:			true,

  2465. 	//	 	}

  2466. 	// 	 	cmd: "ZRange example-key (3 8 ByScore"  (3 < score <= 8).

  2467. 	//

  2468. 	// For the ByLex option, it is similar to the deprecated(6.2.0+) ZRangeByLex command.

  2469. 	// You can set the <Start> and <Stop> options as follows:

  2470. 	//		ZRangeArgs{

  2471. 	//			Key: 				"example-key",

  2472. 	//	 		Start: 				"[abc",

  2473. 	//	 		Stop: 				"(def",

  2474. 	//			ByLex:				true,

  2475. 	//	 	}

  2476. 	//		cmd: "ZRange example-key [abc (def ByLex"

  2477. 	//

  2478. 	// For normal cases (ByScore==false && ByLex==false), <Start> and <Stop> should be set to the index range (int).

  2479. 	// You can read the documentation for more information: https://redis.io/commands/zrange

  2480. 	Start interface{}

  2481. 	Stop  interface{}

  2482. 

  2483. 	// The ByScore and ByLex options are mutually exclusive.

  2484. 	ByScore bool

  2485. 	ByLex   bool

  2486. 

  2487. 	Rev bool

  2488. 

  2489. 	// limit offset count.

  2490. 	Offset int64

  2491. 	Count  int64

  2492. }

  2493. 

  2494. func (z ZRangeArgs) appendArgs(args []interface{}) []interface{} {

  2495. 	// For Rev+ByScore/ByLex, we need to adjust the position of <Start> and <Stop>.

  2496. 	if z.Rev && (z.ByScore || z.ByLex) {

  2497. 		args = append(args, z.Key, z.Stop, z.Start)

  2498. 	} else {

  2499. 		args = append(args, z.Key, z.Start, z.Stop)

  2500. 	}

  2501. 

  2502. 	if z.ByScore {

  2503. 		args = append(args, "byscore")

  2504. 	} else if z.ByLex {

  2505. 		args = append(args, "bylex")

  2506. 	}

  2507. 	if z.Rev {

  2508. 		args = append(args, "rev")

  2509. 	}

  2510. 	if z.Offset != 0 || z.Count != 0 {

  2511. 		args = append(args, "limit", z.Offset, z.Count)

  2512. 	}

  2513. 	return args

  2514. }

  2515. 

  2516. func (c cmdable) ZRangeArgs(ctx context.Context, z ZRangeArgs) *StringSliceCmd {

  2517. 	args := make([]interface{}, 0, 9)

  2518. 	args = append(args, "zrange")

  2519. 	args = z.appendArgs(args)

  2520. 	cmd := NewStringSliceCmd(ctx, args...)

  2521. 	_ = c(ctx, cmd)

  2522. 	return cmd

  2523. }

  2524. 

  2525. func (c cmdable) ZRangeArgsWithScores(ctx context.Context, z ZRangeArgs) *ZSliceCmd {

  2526. 	args := make([]interface{}, 0, 10)

  2527. 	args = append(args, "zrange")

  2528. 	args = z.appendArgs(args)

  2529. 	args = append(args, "withscores")

  2530. 	cmd := NewZSliceCmd(ctx, args...)

  2531. 	_ = c(ctx, cmd)

  2532. 	return cmd

  2533. }

  2534. 

  2535. func (c cmdable) ZRange(ctx context.Context, key string, start, stop int64) *StringSliceCmd {

  2536. 	return c.ZRangeArgs(ctx, ZRangeArgs{

  2537. 		Key:   key,

  2538. 		Start: start,

  2539. 		Stop:  stop,

  2540. 	})

  2541. }

  2542. 

  2543. func (c cmdable) ZRangeWithScores(ctx context.Context, key string, start, stop int64) *ZSliceCmd {

  2544. 	return c.ZRangeArgsWithScores(ctx, ZRangeArgs{

  2545. 		Key:   key,

  2546. 		Start: start,

  2547. 		Stop:  stop,

  2548. 	})

  2549. }

  2550. 

  2551. type ZRangeBy struct {

  2552. 	Min, Max      string

  2553. 	Offset, Count int64

  2554. }

  2555. 

  2556. func (c cmdable) zRangeBy(ctx context.Context, zcmd, key string, opt *ZRangeBy, withScores bool) *StringSliceCmd {

  2557. 	args := []interface{}{zcmd, key, opt.Min, opt.Max}

  2558. 	if withScores {

  2559. 		args = append(args, "withscores")

  2560. 	}

  2561. 	if opt.Offset != 0 || opt.Count != 0 {

  2562. 		args = append(

  2563. 			args,

  2564. 			"limit",

  2565. 			opt.Offset,

  2566. 			opt.Count,

  2567. 		)

  2568. 	}

  2569. 	cmd := NewStringSliceCmd(ctx, args...)

  2570. 	_ = c(ctx, cmd)

  2571. 	return cmd

  2572. }

  2573. 

  2574. func (c cmdable) ZRangeByScore(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd {

  2575. 	return c.zRangeBy(ctx, "zrangebyscore", key, opt, false)

  2576. }

  2577. 

  2578. func (c cmdable) ZRangeByLex(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd {

  2579. 	return c.zRangeBy(ctx, "zrangebylex", key, opt, false)

  2580. }

  2581. 

  2582. func (c cmdable) ZRangeByScoreWithScores(ctx context.Context, key string, opt *ZRangeBy) *ZSliceCmd {

  2583. 	args := []interface{}{"zrangebyscore", key, opt.Min, opt.Max, "withscores"}

  2584. 	if opt.Offset != 0 || opt.Count != 0 {

  2585. 		args = append(

  2586. 			args,

  2587. 			"limit",

  2588. 			opt.Offset,

  2589. 			opt.Count,

  2590. 		)

  2591. 	}

  2592. 	cmd := NewZSliceCmd(ctx, args...)

  2593. 	_ = c(ctx, cmd)

  2594. 	return cmd

  2595. }

  2596. 

  2597. func (c cmdable) ZRangeStore(ctx context.Context, dst string, z ZRangeArgs) *IntCmd {

  2598. 	args := make([]interface{}, 0, 10)

  2599. 	args = append(args, "zrangestore", dst)

  2600. 	args = z.appendArgs(args)

  2601. 	cmd := NewIntCmd(ctx, args...)

  2602. 	_ = c(ctx, cmd)

  2603. 	return cmd

  2604. }

  2605. 

  2606. func (c cmdable) ZRank(ctx context.Context, key, member string) *IntCmd {

  2607. 	cmd := NewIntCmd(ctx, "zrank", key, member)

  2608. 	_ = c(ctx, cmd)

  2609. 	return cmd

  2610. }

  2611. 

  2612. func (c cmdable) ZRem(ctx context.Context, key string, members ...interface{}) *IntCmd {

  2613. 	args := make([]interface{}, 2, 2+len(members))

  2614. 	args[0] = "zrem"

  2615. 	args[1] = key

  2616. 	args = appendArgs(args, members)

  2617. 	cmd := NewIntCmd(ctx, args...)

  2618. 	_ = c(ctx, cmd)

  2619. 	return cmd

  2620. }

  2621. 

  2622. func (c cmdable) ZRemRangeByRank(ctx context.Context, key string, start, stop int64) *IntCmd {

  2623. 	cmd := NewIntCmd(

  2624. 		ctx,

  2625. 		"zremrangebyrank",

  2626. 		key,

  2627. 		start,

  2628. 		stop,

  2629. 	)

  2630. 	_ = c(ctx, cmd)

  2631. 	return cmd

  2632. }

  2633. 

  2634. func (c cmdable) ZRemRangeByScore(ctx context.Context, key, min, max string) *IntCmd {

  2635. 	cmd := NewIntCmd(ctx, "zremrangebyscore", key, min, max)

  2636. 	_ = c(ctx, cmd)

  2637. 	return cmd

  2638. }

  2639. 

  2640. func (c cmdable) ZRemRangeByLex(ctx context.Context, key, min, max string) *IntCmd {

  2641. 	cmd := NewIntCmd(ctx, "zremrangebylex", key, min, max)

  2642. 	_ = c(ctx, cmd)

  2643. 	return cmd

  2644. }

  2645. 

  2646. func (c cmdable) ZRevRange(ctx context.Context, key string, start, stop int64) *StringSliceCmd {

  2647. 	cmd := NewStringSliceCmd(ctx, "zrevrange", key, start, stop)

  2648. 	_ = c(ctx, cmd)

  2649. 	return cmd

  2650. }

  2651. 

  2652. func (c cmdable) ZRevRangeWithScores(ctx context.Context, key string, start, stop int64) *ZSliceCmd {

  2653. 	cmd := NewZSliceCmd(ctx, "zrevrange", key, start, stop, "withscores")

  2654. 	_ = c(ctx, cmd)

  2655. 	return cmd

  2656. }

  2657. 

  2658. func (c cmdable) zRevRangeBy(ctx context.Context, zcmd, key string, opt *ZRangeBy) *StringSliceCmd {

  2659. 	args := []interface{}{zcmd, key, opt.Max, opt.Min}

  2660. 	if opt.Offset != 0 || opt.Count != 0 {

  2661. 		args = append(

  2662. 			args,

  2663. 			"limit",

  2664. 			opt.Offset,

  2665. 			opt.Count,

  2666. 		)

  2667. 	}

  2668. 	cmd := NewStringSliceCmd(ctx, args...)

  2669. 	_ = c(ctx, cmd)

  2670. 	return cmd

  2671. }

  2672. 

  2673. func (c cmdable) ZRevRangeByScore(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd {

  2674. 	return c.zRevRangeBy(ctx, "zrevrangebyscore", key, opt)

  2675. }

  2676. 

  2677. func (c cmdable) ZRevRangeByLex(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd {

  2678. 	return c.zRevRangeBy(ctx, "zrevrangebylex", key, opt)

  2679. }

  2680. 

  2681. func (c cmdable) ZRevRangeByScoreWithScores(ctx context.Context, key string, opt *ZRangeBy) *ZSliceCmd {

  2682. 	args := []interface{}{"zrevrangebyscore", key, opt.Max, opt.Min, "withscores"}

  2683. 	if opt.Offset != 0 || opt.Count != 0 {

  2684. 		args = append(

  2685. 			args,

  2686. 			"limit",

  2687. 			opt.Offset,

  2688. 			opt.Count,

  2689. 		)

  2690. 	}

  2691. 	cmd := NewZSliceCmd(ctx, args...)

  2692. 	_ = c(ctx, cmd)

  2693. 	return cmd

  2694. }

  2695. 

  2696. func (c cmdable) ZRevRank(ctx context.Context, key, member string) *IntCmd {

  2697. 	cmd := NewIntCmd(ctx, "zrevrank", key, member)

  2698. 	_ = c(ctx, cmd)

  2699. 	return cmd

  2700. }

  2701. 

  2702. func (c cmdable) ZScore(ctx context.Context, key, member string) *FloatCmd {

  2703. 	cmd := NewFloatCmd(ctx, "zscore", key, member)

  2704. 	_ = c(ctx, cmd)

  2705. 	return cmd

  2706. }

  2707. 

  2708. func (c cmdable) ZUnion(ctx context.Context, store ZStore) *StringSliceCmd {

  2709. 	args := make([]interface{}, 0, 2+store.len())

  2710. 	args = append(args, "zunion", len(store.Keys))

  2711. 	args = store.appendArgs(args)

  2712. 	cmd := NewStringSliceCmd(ctx, args...)

  2713. 	cmd.setFirstKeyPos(2)

  2714. 	_ = c(ctx, cmd)

  2715. 	return cmd

  2716. }

  2717. 

  2718. func (c cmdable) ZUnionWithScores(ctx context.Context, store ZStore) *ZSliceCmd {

  2719. 	args := make([]interface{}, 0, 3+store.len())

  2720. 	args = append(args, "zunion", len(store.Keys))

  2721. 	args = store.appendArgs(args)

  2722. 	args = append(args, "withscores")

  2723. 	cmd := NewZSliceCmd(ctx, args...)

  2724. 	cmd.setFirstKeyPos(2)

  2725. 	_ = c(ctx, cmd)

  2726. 	return cmd

  2727. }

  2728. 

  2729. func (c cmdable) ZUnionStore(ctx context.Context, dest string, store *ZStore) *IntCmd {

  2730. 	args := make([]interface{}, 0, 3+store.len())

  2731. 	args = append(args, "zunionstore", dest, len(store.Keys))

  2732. 	args = store.appendArgs(args)

  2733. 	cmd := NewIntCmd(ctx, args...)

  2734. 	cmd.setFirstKeyPos(3)

  2735. 	_ = c(ctx, cmd)

  2736. 	return cmd

  2737. }

  2738. 

  2739. // ZRandMember redis-server version >= 6.2.0.

  2740. func (c cmdable) ZRandMember(ctx context.Context, key string, count int, withScores bool) *StringSliceCmd {

  2741. 	args := make([]interface{}, 0, 4)

  2742. 

  2743. 	// Although count=0 is meaningless, redis accepts count=0.

  2744. 	args = append(args, "zrandmember", key, count)

  2745. 	if withScores {

  2746. 		args = append(args, "withscores")

  2747. 	}

  2748. 

  2749. 	cmd := NewStringSliceCmd(ctx, args...)

  2750. 	_ = c(ctx, cmd)

  2751. 	return cmd

  2752. }

  2753. 

  2754. // ZDiff redis-server version >= 6.2.0.

  2755. func (c cmdable) ZDiff(ctx context.Context, keys ...string) *StringSliceCmd {

  2756. 	args := make([]interface{}, 2+len(keys))

  2757. 	args[0] = "zdiff"

  2758. 	args[1] = len(keys)

  2759. 	for i, key := range keys {

  2760. 		args[i+2] = key

  2761. 	}

  2762. 

  2763. 	cmd := NewStringSliceCmd(ctx, args...)

  2764. 	cmd.setFirstKeyPos(2)

  2765. 	_ = c(ctx, cmd)

  2766. 	return cmd

  2767. }

  2768. 

  2769. // ZDiffWithScores redis-server version >= 6.2.0.

  2770. func (c cmdable) ZDiffWithScores(ctx context.Context, keys ...string) *ZSliceCmd {

  2771. 	args := make([]interface{}, 3+len(keys))

  2772. 	args[0] = "zdiff"

  2773. 	args[1] = len(keys)

  2774. 	for i, key := range keys {

  2775. 		args[i+2] = key

  2776. 	}

  2777. 	args[len(keys)+2] = "withscores"

  2778. 

  2779. 	cmd := NewZSliceCmd(ctx, args...)

  2780. 	cmd.setFirstKeyPos(2)

  2781. 	_ = c(ctx, cmd)

  2782. 	return cmd

  2783. }

  2784. 

  2785. // ZDiffStore redis-server version >=6.2.0.

  2786. func (c cmdable) ZDiffStore(ctx context.Context, destination string, keys ...string) *IntCmd {

  2787. 	args := make([]interface{}, 0, 3+len(keys))

  2788. 	args = append(args, "zdiffstore", destination, len(keys))

  2789. 	for _, key := range keys {

  2790. 		args = append(args, key)

  2791. 	}

  2792. 	cmd := NewIntCmd(ctx, args...)

  2793. 	_ = c(ctx, cmd)

  2794. 	return cmd

  2795. }

  2796. 

  2797. //------------------------------------------------------------------------------

  2798. 

  2799. func (c cmdable) PFAdd(ctx context.Context, key string, els ...interface{}) *IntCmd {

  2800. 	args := make([]interface{}, 2, 2+len(els))

  2801. 	args[0] = "pfadd"

  2802. 	args[1] = key

  2803. 	args = appendArgs(args, els)

  2804. 	cmd := NewIntCmd(ctx, args...)

  2805. 	_ = c(ctx, cmd)

  2806. 	return cmd

  2807. }

  2808. 

  2809. func (c cmdable) PFCount(ctx context.Context, keys ...string) *IntCmd {

  2810. 	args := make([]interface{}, 1+len(keys))

  2811. 	args[0] = "pfcount"

  2812. 	for i, key := range keys {

  2813. 		args[1+i] = key

  2814. 	}

  2815. 	cmd := NewIntCmd(ctx, args...)

  2816. 	_ = c(ctx, cmd)

  2817. 	return cmd

  2818. }

  2819. 

  2820. func (c cmdable) PFMerge(ctx context.Context, dest string, keys ...string) *StatusCmd {

  2821. 	args := make([]interface{}, 2+len(keys))

  2822. 	args[0] = "pfmerge"

  2823. 	args[1] = dest

  2824. 	for i, key := range keys {

  2825. 		args[2+i] = key

  2826. 	}

  2827. 	cmd := NewStatusCmd(ctx, args...)

  2828. 	_ = c(ctx, cmd)

  2829. 	return cmd

  2830. }

  2831. 

  2832. //------------------------------------------------------------------------------

  2833. 

  2834. func (c cmdable) BgRewriteAOF(ctx context.Context) *StatusCmd {

  2835. 	cmd := NewStatusCmd(ctx, "bgrewriteaof")

  2836. 	_ = c(ctx, cmd)

  2837. 	return cmd

  2838. }

  2839. 

  2840. func (c cmdable) BgSave(ctx context.Context) *StatusCmd {

  2841. 	cmd := NewStatusCmd(ctx, "bgsave")

  2842. 	_ = c(ctx, cmd)

  2843. 	return cmd

  2844. }

  2845. 

  2846. func (c cmdable) ClientKill(ctx context.Context, ipPort string) *StatusCmd {

  2847. 	cmd := NewStatusCmd(ctx, "client", "kill", ipPort)

  2848. 	_ = c(ctx, cmd)

  2849. 	return cmd

  2850. }

  2851. 

  2852. // ClientKillByFilter is new style syntax, while the ClientKill is old

  2853. //

  2854. //   CLIENT KILL <option> [value] ... <option> [value]

  2855. func (c cmdable) ClientKillByFilter(ctx context.Context, keys ...string) *IntCmd {

  2856. 	args := make([]interface{}, 2+len(keys))

  2857. 	args[0] = "client"

  2858. 	args[1] = "kill"

  2859. 	for i, key := range keys {

  2860. 		args[2+i] = key

  2861. 	}

  2862. 	cmd := NewIntCmd(ctx, args...)

  2863. 	_ = c(ctx, cmd)

  2864. 	return cmd

  2865. }

  2866. 

  2867. func (c cmdable) ClientList(ctx context.Context) *StringCmd {

  2868. 	cmd := NewStringCmd(ctx, "client", "list")

  2869. 	_ = c(ctx, cmd)

  2870. 	return cmd

  2871. }

  2872. 

  2873. func (c cmdable) ClientPause(ctx context.Context, dur time.Duration) *BoolCmd {

  2874. 	cmd := NewBoolCmd(ctx, "client", "pause", formatMs(ctx, dur))

  2875. 	_ = c(ctx, cmd)

  2876. 	return cmd

  2877. }

  2878. 

  2879. func (c cmdable) ClientID(ctx context.Context) *IntCmd {

  2880. 	cmd := NewIntCmd(ctx, "client", "id")

  2881. 	_ = c(ctx, cmd)

  2882. 	return cmd

  2883. }

  2884. 

  2885. func (c cmdable) ClientUnblock(ctx context.Context, id int64) *IntCmd {

  2886. 	cmd := NewIntCmd(ctx, "client", "unblock", id)

  2887. 	_ = c(ctx, cmd)

  2888. 	return cmd

  2889. }

  2890. 

  2891. func (c cmdable) ClientUnblockWithError(ctx context.Context, id int64) *IntCmd {

  2892. 	cmd := NewIntCmd(ctx, "client", "unblock", id, "error")

  2893. 	_ = c(ctx, cmd)

  2894. 	return cmd

  2895. }

  2896. 

  2897. func (c cmdable) ConfigGet(ctx context.Context, parameter string) *SliceCmd {

  2898. 	cmd := NewSliceCmd(ctx, "config", "get", parameter)

  2899. 	_ = c(ctx, cmd)

  2900. 	return cmd

  2901. }

  2902. 

  2903. func (c cmdable) ConfigResetStat(ctx context.Context) *StatusCmd {

  2904. 	cmd := NewStatusCmd(ctx, "config", "resetstat")

  2905. 	_ = c(ctx, cmd)

  2906. 	return cmd

  2907. }

  2908. 

  2909. func (c cmdable) ConfigSet(ctx context.Context, parameter, value string) *StatusCmd {

  2910. 	cmd := NewStatusCmd(ctx, "config", "set", parameter, value)

  2911. 	_ = c(ctx, cmd)

  2912. 	return cmd

  2913. }

  2914. 

  2915. func (c cmdable) ConfigRewrite(ctx context.Context) *StatusCmd {

  2916. 	cmd := NewStatusCmd(ctx, "config", "rewrite")

  2917. 	_ = c(ctx, cmd)

  2918. 	return cmd

  2919. }

  2920. 

  2921. func (c cmdable) DBSize(ctx context.Context) *IntCmd {

  2922. 	cmd := NewIntCmd(ctx, "dbsize")

  2923. 	_ = c(ctx, cmd)

  2924. 	return cmd

  2925. }

  2926. 

  2927. func (c cmdable) FlushAll(ctx context.Context) *StatusCmd {

  2928. 	cmd := NewStatusCmd(ctx, "flushall")

  2929. 	_ = c(ctx, cmd)

  2930. 	return cmd

  2931. }

  2932. 

  2933. func (c cmdable) FlushAllAsync(ctx context.Context) *StatusCmd {

  2934. 	cmd := NewStatusCmd(ctx, "flushall", "async")

  2935. 	_ = c(ctx, cmd)

  2936. 	return cmd

  2937. }

  2938. 

  2939. func (c cmdable) FlushDB(ctx context.Context) *StatusCmd {

  2940. 	cmd := NewStatusCmd(ctx, "flushdb")

  2941. 	_ = c(ctx, cmd)

  2942. 	return cmd

  2943. }

  2944. 

  2945. func (c cmdable) FlushDBAsync(ctx context.Context) *StatusCmd {

  2946. 	cmd := NewStatusCmd(ctx, "flushdb", "async")

  2947. 	_ = c(ctx, cmd)

  2948. 	return cmd

  2949. }

  2950. 

  2951. func (c cmdable) Info(ctx context.Context, section ...string) *StringCmd {

  2952. 	args := []interface{}{"info"}

  2953. 	if len(section) > 0 {

  2954. 		args = append(args, section[0])

  2955. 	}

  2956. 	cmd := NewStringCmd(ctx, args...)

  2957. 	_ = c(ctx, cmd)

  2958. 	return cmd

  2959. }

  2960. 

  2961. func (c cmdable) LastSave(ctx context.Context) *IntCmd {

  2962. 	cmd := NewIntCmd(ctx, "lastsave")

  2963. 	_ = c(ctx, cmd)

  2964. 	return cmd

  2965. }

  2966. 

  2967. func (c cmdable) Save(ctx context.Context) *StatusCmd {

  2968. 	cmd := NewStatusCmd(ctx, "save")

  2969. 	_ = c(ctx, cmd)

  2970. 	return cmd

  2971. }

  2972. 

  2973. func (c cmdable) shutdown(ctx context.Context, modifier string) *StatusCmd {

  2974. 	var args []interface{}

  2975. 	if modifier == "" {

  2976. 		args = []interface{}{"shutdown"}

  2977. 	} else {

  2978. 		args = []interface{}{"shutdown", modifier}

  2979. 	}

  2980. 	cmd := NewStatusCmd(ctx, args...)

  2981. 	_ = c(ctx, cmd)

  2982. 	if err := cmd.Err(); err != nil {

  2983. 		if err == io.EOF {

  2984. 			// Server quit as expected.

  2985. 			cmd.err = nil

  2986. 		}

  2987. 	} else {

  2988. 		// Server did not quit. String reply contains the reason.

  2989. 		cmd.err = errors.New(cmd.val)

  2990. 		cmd.val = ""

  2991. 	}

  2992. 	return cmd

  2993. }

  2994. 

  2995. func (c cmdable) Shutdown(ctx context.Context) *StatusCmd {

  2996. 	return c.shutdown(ctx, "")

  2997. }

  2998. 

  2999. func (c cmdable) ShutdownSave(ctx context.Context) *StatusCmd {

  3000. 	return c.shutdown(ctx, "save")

  3001. }

  3002. 

  3003. func (c cmdable) ShutdownNoSave(ctx context.Context) *StatusCmd {

  3004. 	return c.shutdown(ctx, "nosave")

  3005. }

  3006. 

  3007. func (c cmdable) SlaveOf(ctx context.Context, host, port string) *StatusCmd {

  3008. 	cmd := NewStatusCmd(ctx, "slaveof", host, port)

  3009. 	_ = c(ctx, cmd)

  3010. 	return cmd

  3011. }

  3012. 

  3013. func (c cmdable) SlowLogGet(ctx context.Context, num int64) *SlowLogCmd {

  3014. 	cmd := NewSlowLogCmd(context.Background(), "slowlog", "get", num)

  3015. 	_ = c(ctx, cmd)

  3016. 	return cmd

  3017. }

  3018. 

  3019. func (c cmdable) Sync(_ context.Context) {

  3020. 	panic("not implemented")

  3021. }

  3022. 

  3023. func (c cmdable) Time(ctx context.Context) *TimeCmd {

  3024. 	cmd := NewTimeCmd(ctx, "time")

  3025. 	_ = c(ctx, cmd)

  3026. 	return cmd

  3027. }

  3028. 

  3029. func (c cmdable) DebugObject(ctx context.Context, key string) *StringCmd {

  3030. 	cmd := NewStringCmd(ctx, "debug", "object", key)

  3031. 	_ = c(ctx, cmd)

  3032. 	return cmd

  3033. }

  3034. 

  3035. func (c cmdable) ReadOnly(ctx context.Context) *StatusCmd {

  3036. 	cmd := NewStatusCmd(ctx, "readonly")

  3037. 	_ = c(ctx, cmd)

  3038. 	return cmd

  3039. }

  3040. 

  3041. func (c cmdable) ReadWrite(ctx context.Context) *StatusCmd {

  3042. 	cmd := NewStatusCmd(ctx, "readwrite")

  3043. 	_ = c(ctx, cmd)

  3044. 	return cmd

  3045. }

  3046. 

  3047. func (c cmdable) MemoryUsage(ctx context.Context, key string, samples ...int) *IntCmd {

  3048. 	args := []interface{}{"memory", "usage", key}

  3049. 	if len(samples) > 0 {

  3050. 		if len(samples) != 1 {

  3051. 			panic("MemoryUsage expects single sample count")

  3052. 		}

  3053. 		args = append(args, "SAMPLES", samples[0])

  3054. 	}

  3055. 	cmd := NewIntCmd(ctx, args...)

  3056. 	cmd.setFirstKeyPos(2)

  3057. 	_ = c(ctx, cmd)

  3058. 	return cmd

  3059. }

  3060. 

  3061. //------------------------------------------------------------------------------

  3062. 

  3063. func (c cmdable) Eval(ctx context.Context, script string, keys []string, args ...interface{}) *Cmd {

  3064. 	cmdArgs := make([]interface{}, 3+len(keys), 3+len(keys)+len(args))

  3065. 	cmdArgs[0] = "eval"

  3066. 	cmdArgs[1] = script

  3067. 	cmdArgs[2] = len(keys)

  3068. 	for i, key := range keys {

  3069. 		cmdArgs[3+i] = key

  3070. 	}

  3071. 	cmdArgs = appendArgs(cmdArgs, args)

  3072. 	cmd := NewCmd(ctx, cmdArgs...)

  3073. 	cmd.setFirstKeyPos(3)

  3074. 	_ = c(ctx, cmd)

  3075. 	return cmd

  3076. }

  3077. 

  3078. func (c cmdable) EvalSha(ctx context.Context, sha1 string, keys []string, args ...interface{}) *Cmd {

  3079. 	cmdArgs := make([]interface{}, 3+len(keys), 3+len(keys)+len(args))

  3080. 	cmdArgs[0] = "evalsha"

  3081. 	cmdArgs[1] = sha1

  3082. 	cmdArgs[2] = len(keys)

  3083. 	for i, key := range keys {

  3084. 		cmdArgs[3+i] = key

  3085. 	}

  3086. 	cmdArgs = appendArgs(cmdArgs, args)

  3087. 	cmd := NewCmd(ctx, cmdArgs...)

  3088. 	cmd.setFirstKeyPos(3)

  3089. 	_ = c(ctx, cmd)

  3090. 	return cmd

  3091. }

  3092. 

  3093. func (c cmdable) ScriptExists(ctx context.Context, hashes ...string) *BoolSliceCmd {

  3094. 	args := make([]interface{}, 2+len(hashes))

  3095. 	args[0] = "script"

  3096. 	args[1] = "exists"

  3097. 	for i, hash := range hashes {

  3098. 		args[2+i] = hash

  3099. 	}

  3100. 	cmd := NewBoolSliceCmd(ctx, args...)

  3101. 	_ = c(ctx, cmd)

  3102. 	return cmd

  3103. }

  3104. 

  3105. func (c cmdable) ScriptFlush(ctx context.Context) *StatusCmd {

  3106. 	cmd := NewStatusCmd(ctx, "script", "flush")

  3107. 	_ = c(ctx, cmd)

  3108. 	return cmd

  3109. }

  3110. 

  3111. func (c cmdable) ScriptKill(ctx context.Context) *StatusCmd {

  3112. 	cmd := NewStatusCmd(ctx, "script", "kill")

  3113. 	_ = c(ctx, cmd)

  3114. 	return cmd

  3115. }

  3116. 

  3117. func (c cmdable) ScriptLoad(ctx context.Context, script string) *StringCmd {

  3118. 	cmd := NewStringCmd(ctx, "script", "load", script)

  3119. 	_ = c(ctx, cmd)

  3120. 	return cmd

  3121. }

  3122. 

  3123. //------------------------------------------------------------------------------

  3124. 

  3125. // Publish posts the message to the channel.

  3126. func (c cmdable) Publish(ctx context.Context, channel string, message interface{}) *IntCmd {

  3127. 	cmd := NewIntCmd(ctx, "publish", channel, message)

  3128. 	_ = c(ctx, cmd)

  3129. 	return cmd

  3130. }

  3131. 

  3132. func (c cmdable) PubSubChannels(ctx context.Context, pattern string) *StringSliceCmd {

  3133. 	args := []interface{}{"pubsub", "channels"}

  3134. 	if pattern != "*" {

  3135. 		args = append(args, pattern)

  3136. 	}

  3137. 	cmd := NewStringSliceCmd(ctx, args...)

  3138. 	_ = c(ctx, cmd)

  3139. 	return cmd

  3140. }

  3141. 

  3142. func (c cmdable) PubSubNumSub(ctx context.Context, channels ...string) *StringIntMapCmd {

  3143. 	args := make([]interface{}, 2+len(channels))

  3144. 	args[0] = "pubsub"

  3145. 	args[1] = "numsub"

  3146. 	for i, channel := range channels {

  3147. 		args[2+i] = channel

  3148. 	}

  3149. 	cmd := NewStringIntMapCmd(ctx, args...)

  3150. 	_ = c(ctx, cmd)

  3151. 	return cmd

  3152. }

  3153. 

  3154. func (c cmdable) PubSubNumPat(ctx context.Context) *IntCmd {

  3155. 	cmd := NewIntCmd(ctx, "pubsub", "numpat")

  3156. 	_ = c(ctx, cmd)

  3157. 	return cmd

  3158. }

  3159. 

  3160. //------------------------------------------------------------------------------

  3161. 

  3162. func (c cmdable) ClusterSlots(ctx context.Context) *ClusterSlotsCmd {

  3163. 	cmd := NewClusterSlotsCmd(ctx, "cluster", "slots")

  3164. 	_ = c(ctx, cmd)

  3165. 	return cmd

  3166. }

  3167. 

  3168. func (c cmdable) ClusterNodes(ctx context.Context) *StringCmd {

  3169. 	cmd := NewStringCmd(ctx, "cluster", "nodes")

  3170. 	_ = c(ctx, cmd)

  3171. 	return cmd

  3172. }

  3173. 

  3174. func (c cmdable) ClusterMeet(ctx context.Context, host, port string) *StatusCmd {

  3175. 	cmd := NewStatusCmd(ctx, "cluster", "meet", host, port)

  3176. 	_ = c(ctx, cmd)

  3177. 	return cmd

  3178. }

  3179. 

  3180. func (c cmdable) ClusterForget(ctx context.Context, nodeID string) *StatusCmd {

  3181. 	cmd := NewStatusCmd(ctx, "cluster", "forget", nodeID)

  3182. 	_ = c(ctx, cmd)

  3183. 	return cmd

  3184. }

  3185. 

  3186. func (c cmdable) ClusterReplicate(ctx context.Context, nodeID string) *StatusCmd {

  3187. 	cmd := NewStatusCmd(ctx, "cluster", "replicate", nodeID)

  3188. 	_ = c(ctx, cmd)

  3189. 	return cmd

  3190. }

  3191. 

  3192. func (c cmdable) ClusterResetSoft(ctx context.Context) *StatusCmd {

  3193. 	cmd := NewStatusCmd(ctx, "cluster", "reset", "soft")

  3194. 	_ = c(ctx, cmd)

  3195. 	return cmd

  3196. }

  3197. 

  3198. func (c cmdable) ClusterResetHard(ctx context.Context) *StatusCmd {

  3199. 	cmd := NewStatusCmd(ctx, "cluster", "reset", "hard")

  3200. 	_ = c(ctx, cmd)

  3201. 	return cmd

  3202. }

  3203. 

  3204. func (c cmdable) ClusterInfo(ctx context.Context) *StringCmd {

  3205. 	cmd := NewStringCmd(ctx, "cluster", "info")

  3206. 	_ = c(ctx, cmd)

  3207. 	return cmd

  3208. }

  3209. 

  3210. func (c cmdable) ClusterKeySlot(ctx context.Context, key string) *IntCmd {

  3211. 	cmd := NewIntCmd(ctx, "cluster", "keyslot", key)

  3212. 	_ = c(ctx, cmd)

  3213. 	return cmd

  3214. }

  3215. 

  3216. func (c cmdable) ClusterGetKeysInSlot(ctx context.Context, slot int, count int) *StringSliceCmd {

  3217. 	cmd := NewStringSliceCmd(ctx, "cluster", "getkeysinslot", slot, count)

  3218. 	_ = c(ctx, cmd)

  3219. 	return cmd

  3220. }

  3221. 

  3222. func (c cmdable) ClusterCountFailureReports(ctx context.Context, nodeID string) *IntCmd {

  3223. 	cmd := NewIntCmd(ctx, "cluster", "count-failure-reports", nodeID)

  3224. 	_ = c(ctx, cmd)

  3225. 	return cmd

  3226. }

  3227. 

  3228. func (c cmdable) ClusterCountKeysInSlot(ctx context.Context, slot int) *IntCmd {

  3229. 	cmd := NewIntCmd(ctx, "cluster", "countkeysinslot", slot)

  3230. 	_ = c(ctx, cmd)

  3231. 	return cmd

  3232. }

  3233. 

  3234. func (c cmdable) ClusterDelSlots(ctx context.Context, slots ...int) *StatusCmd {

  3235. 	args := make([]interface{}, 2+len(slots))

  3236. 	args[0] = "cluster"

  3237. 	args[1] = "delslots"

  3238. 	for i, slot := range slots {

  3239. 		args[2+i] = slot

  3240. 	}

  3241. 	cmd := NewStatusCmd(ctx, args...)

  3242. 	_ = c(ctx, cmd)

  3243. 	return cmd

  3244. }

  3245. 

  3246. func (c cmdable) ClusterDelSlotsRange(ctx context.Context, min, max int) *StatusCmd {

  3247. 	size := max - min + 1

  3248. 	slots := make([]int, size)

  3249. 	for i := 0; i < size; i++ {

  3250. 		slots[i] = min + i

  3251. 	}

  3252. 	return c.ClusterDelSlots(ctx, slots...)

  3253. }

  3254. 

  3255. func (c cmdable) ClusterSaveConfig(ctx context.Context) *StatusCmd {

  3256. 	cmd := NewStatusCmd(ctx, "cluster", "saveconfig")

  3257. 	_ = c(ctx, cmd)

  3258. 	return cmd

  3259. }

  3260. 

  3261. func (c cmdable) ClusterSlaves(ctx context.Context, nodeID string) *StringSliceCmd {

  3262. 	cmd := NewStringSliceCmd(ctx, "cluster", "slaves", nodeID)

  3263. 	_ = c(ctx, cmd)

  3264. 	return cmd

  3265. }

  3266. 

  3267. func (c cmdable) ClusterFailover(ctx context.Context) *StatusCmd {

  3268. 	cmd := NewStatusCmd(ctx, "cluster", "failover")

  3269. 	_ = c(ctx, cmd)

  3270. 	return cmd

  3271. }

  3272. 

  3273. func (c cmdable) ClusterAddSlots(ctx context.Context, slots ...int) *StatusCmd {

  3274. 	args := make([]interface{}, 2+len(slots))

  3275. 	args[0] = "cluster"

  3276. 	args[1] = "addslots"

  3277. 	for i, num := range slots {

  3278. 		args[2+i] = num

  3279. 	}

  3280. 	cmd := NewStatusCmd(ctx, args...)

  3281. 	_ = c(ctx, cmd)

  3282. 	return cmd

  3283. }

  3284. 

  3285. func (c cmdable) ClusterAddSlotsRange(ctx context.Context, min, max int) *StatusCmd {

  3286. 	size := max - min + 1

  3287. 	slots := make([]int, size)

  3288. 	for i := 0; i < size; i++ {

  3289. 		slots[i] = min + i

  3290. 	}

  3291. 	return c.ClusterAddSlots(ctx, slots...)

  3292. }

  3293. 

  3294. //------------------------------------------------------------------------------

  3295. 

  3296. func (c cmdable) GeoAdd(ctx context.Context, key string, geoLocation ...*GeoLocation) *IntCmd {

  3297. 	args := make([]interface{}, 2+3*len(geoLocation))

  3298. 	args[0] = "geoadd"

  3299. 	args[1] = key

  3300. 	for i, eachLoc := range geoLocation {

  3301. 		args[2+3*i] = eachLoc.Longitude

  3302. 		args[2+3*i+1] = eachLoc.Latitude

  3303. 		args[2+3*i+2] = eachLoc.Name

  3304. 	}

  3305. 	cmd := NewIntCmd(ctx, args...)

  3306. 	_ = c(ctx, cmd)

  3307. 	return cmd

  3308. }

  3309. 

  3310. // GeoRadius is a read-only GEORADIUS_RO command.

  3311. func (c cmdable) GeoRadius(

  3312. 	ctx context.Context, key string, longitude, latitude float64, query *GeoRadiusQuery,

  3313. ) *GeoLocationCmd {

  3314. 	cmd := NewGeoLocationCmd(ctx, query, "georadius_ro", key, longitude, latitude)

  3315. 	if query.Store != "" || query.StoreDist != "" {

  3316. 		cmd.SetErr(errors.New("GeoRadius does not support Store or StoreDist"))

  3317. 		return cmd

  3318. 	}

  3319. 	_ = c(ctx, cmd)

  3320. 	return cmd

  3321. }

  3322. 

  3323. // GeoRadiusStore is a writing GEORADIUS command.

  3324. func (c cmdable) GeoRadiusStore(

  3325. 	ctx context.Context, key string, longitude, latitude float64, query *GeoRadiusQuery,

  3326. ) *IntCmd {

  3327. 	args := geoLocationArgs(query, "georadius", key, longitude, latitude)

  3328. 	cmd := NewIntCmd(ctx, args...)

  3329. 	if query.Store == "" && query.StoreDist == "" {

  3330. 		cmd.SetErr(errors.New("GeoRadiusStore requires Store or StoreDist"))

  3331. 		return cmd

  3332. 	}

  3333. 	_ = c(ctx, cmd)

  3334. 	return cmd

  3335. }

  3336. 

  3337. // GeoRadiusByMember is a read-only GEORADIUSBYMEMBER_RO command.

  3338. func (c cmdable) GeoRadiusByMember(

  3339. 	ctx context.Context, key, member string, query *GeoRadiusQuery,

  3340. ) *GeoLocationCmd {

  3341. 	cmd := NewGeoLocationCmd(ctx, query, "georadiusbymember_ro", key, member)

  3342. 	if query.Store != "" || query.StoreDist != "" {

  3343. 		cmd.SetErr(errors.New("GeoRadiusByMember does not support Store or StoreDist"))

  3344. 		return cmd

  3345. 	}

  3346. 	_ = c(ctx, cmd)

  3347. 	return cmd

  3348. }

  3349. 

  3350. // GeoRadiusByMemberStore is a writing GEORADIUSBYMEMBER command.

  3351. func (c cmdable) GeoRadiusByMemberStore(

  3352. 	ctx context.Context, key, member string, query *GeoRadiusQuery,

  3353. ) *IntCmd {

  3354. 	args := geoLocationArgs(query, "georadiusbymember", key, member)

  3355. 	cmd := NewIntCmd(ctx, args...)

  3356. 	if query.Store == "" && query.StoreDist == "" {

  3357. 		cmd.SetErr(errors.New("GeoRadiusByMemberStore requires Store or StoreDist"))

  3358. 		return cmd

  3359. 	}

  3360. 	_ = c(ctx, cmd)

  3361. 	return cmd

  3362. }

  3363. 

  3364. func (c cmdable) GeoSearch(ctx context.Context, key string, q *GeoSearchQuery) *StringSliceCmd {

  3365. 	args := make([]interface{}, 0, 13)

  3366. 	args = append(args, "geosearch", key)

  3367. 	args = geoSearchArgs(q, args)

  3368. 	cmd := NewStringSliceCmd(ctx, args...)

  3369. 	_ = c(ctx, cmd)

  3370. 	return cmd

  3371. }

  3372. 

  3373. func (c cmdable) GeoSearchLocation(

  3374. 	ctx context.Context, key string, q *GeoSearchLocationQuery,

  3375. ) *GeoSearchLocationCmd {

  3376. 	args := make([]interface{}, 0, 16)

  3377. 	args = append(args, "geosearch", key)

  3378. 	args = geoSearchLocationArgs(q, args)

  3379. 	cmd := NewGeoSearchLocationCmd(ctx, q, args...)

  3380. 	_ = c(ctx, cmd)

  3381. 	return cmd

  3382. }

  3383. 

  3384. func (c cmdable) GeoSearchStore(ctx context.Context, key, store string, q *GeoSearchStoreQuery) *IntCmd {

  3385. 	args := make([]interface{}, 0, 15)

  3386. 	args = append(args, "geosearchstore", store, key)

  3387. 	args = geoSearchArgs(&q.GeoSearchQuery, args)

  3388. 	if q.StoreDist {

  3389. 		args = append(args, "storedist")

  3390. 	}

  3391. 	cmd := NewIntCmd(ctx, args...)

  3392. 	_ = c(ctx, cmd)

  3393. 	return cmd

  3394. }

  3395. 

  3396. func (c cmdable) GeoDist(

  3397. 	ctx context.Context, key string, member1, member2, unit string,

  3398. ) *FloatCmd {

  3399. 	if unit == "" {

  3400. 		unit = "km"

  3401. 	}

  3402. 	cmd := NewFloatCmd(ctx, "geodist", key, member1, member2, unit)

  3403. 	_ = c(ctx, cmd)

  3404. 	return cmd

  3405. }

  3406. 

  3407. func (c cmdable) GeoHash(ctx context.Context, key string, members ...string) *StringSliceCmd {

  3408. 	args := make([]interface{}, 2+len(members))

  3409. 	args[0] = "geohash"

  3410. 	args[1] = key

  3411. 	for i, member := range members {

  3412. 		args[2+i] = member

  3413. 	}

  3414. 	cmd := NewStringSliceCmd(ctx, args...)

  3415. 	_ = c(ctx, cmd)

  3416. 	return cmd

  3417. }

  3418. 

  3419. func (c cmdable) GeoPos(ctx context.Context, key string, members ...string) *GeoPosCmd {

  3420. 	args := make([]interface{}, 2+len(members))

  3421. 	args[0] = "geopos"

  3422. 	args[1] = key

  3423. 	for i, member := range members {

  3424. 		args[2+i] = member

  3425. 	}

  3426. 	cmd := NewGeoPosCmd(ctx, args...)

  3427. 	_ = c(ctx, cmd)

  3428. 	return cmd

  3429. }