1 package redis_test
2
3 import (
4 "context"
5 "fmt"
6 "strings"
7
8 . "github.com/bsm/ginkgo/v2"
9 . "github.com/bsm/gomega"
10
11 "github.com/redis/go-redis/v9"
12 )
13
14 var _ = Describe("RedisTimeseries commands", Label("timeseries"), func() {
15 ctx := context.TODO()
16
17 setupRedisClient := func(protocolVersion int) *redis.Client {
18 return redis.NewClient(&redis.Options{
19 Addr: "localhost:6379",
20 DB: 0,
21 Protocol: protocolVersion,
22 UnstableResp3: true,
23 })
24 }
25
26 protocols := []int{2, 3}
27 for _, protocol := range protocols {
28 protocol := protocol
29
30 Context(fmt.Sprintf("with protocol version %d", protocol), func() {
31 var client *redis.Client
32
33 BeforeEach(func() {
34 client = setupRedisClient(protocol)
35 Expect(client.FlushAll(ctx).Err()).NotTo(HaveOccurred())
36 })
37
38 AfterEach(func() {
39 if client != nil {
40 client.FlushDB(ctx)
41 client.Close()
42 }
43 })
44
45 It("should TSCreate and TSCreateWithArgs", Label("timeseries", "tscreate", "tscreateWithArgs", "NonRedisEnterprise"), func() {
46 SkipBeforeRedisVersion(7.4, "older redis stack has different results for timeseries module")
47 result, err := client.TSCreate(ctx, "1").Result()
48 Expect(err).NotTo(HaveOccurred())
49 Expect(result).To(BeEquivalentTo("OK"))
50
51 opt := &redis.TSOptions{Retention: 5}
52 result, err = client.TSCreateWithArgs(ctx, "2", opt).Result()
53 Expect(err).NotTo(HaveOccurred())
54 Expect(result).To(BeEquivalentTo("OK"))
55 opt = &redis.TSOptions{Labels: map[string]string{"Redis": "Labs"}}
56 result, err = client.TSCreateWithArgs(ctx, "3", opt).Result()
57 Expect(err).NotTo(HaveOccurred())
58 Expect(result).To(BeEquivalentTo("OK"))
59 opt = &redis.TSOptions{Labels: map[string]string{"Time": "Series"}, Retention: 20}
60 result, err = client.TSCreateWithArgs(ctx, "4", opt).Result()
61 Expect(err).NotTo(HaveOccurred())
62 Expect(result).To(BeEquivalentTo("OK"))
63 resultInfo, err := client.TSInfo(ctx, "4").Result()
64 Expect(err).NotTo(HaveOccurred())
65 if client.Options().Protocol == 2 {
66 Expect(resultInfo["labels"].([]interface{})[0]).To(BeEquivalentTo([]interface{}{"Time", "Series"}))
67 } else {
68 Expect(resultInfo["labels"].(map[interface{}]interface{})["Time"]).To(BeEquivalentTo("Series"))
69 }
70
71 opt = &redis.TSOptions{ChunkSize: 128}
72 result, err = client.TSCreateWithArgs(ctx, "ts-cs-1", opt).Result()
73 Expect(err).NotTo(HaveOccurred())
74 Expect(result).To(BeEquivalentTo("OK"))
75 resultInfo, err = client.TSInfo(ctx, "ts-cs-1").Result()
76 Expect(err).NotTo(HaveOccurred())
77 Expect(resultInfo["chunkSize"]).To(BeEquivalentTo(128))
78
79 duplicate_policies := []string{"BLOCK", "LAST", "FIRST", "MIN", "MAX"}
80 for _, dup := range duplicate_policies {
81 keyName := "ts-dup-" + dup
82 opt = &redis.TSOptions{DuplicatePolicy: dup}
83 result, err = client.TSCreateWithArgs(ctx, keyName, opt).Result()
84 Expect(err).NotTo(HaveOccurred())
85 Expect(result).To(BeEquivalentTo("OK"))
86 resultInfo, err = client.TSInfo(ctx, keyName).Result()
87 Expect(err).NotTo(HaveOccurred())
88 Expect(strings.ToUpper(resultInfo["duplicatePolicy"].(string))).To(BeEquivalentTo(dup))
89 }
90
91 opt = &redis.TSOptions{IgnoreMaxTimeDiff: 5, DuplicatePolicy: "LAST", IgnoreMaxValDiff: 10.0}
92 result, err = client.TSCreateWithArgs(ctx, "ts-if-1", opt).Result()
93 Expect(err).NotTo(HaveOccurred())
94 Expect(result).To(BeEquivalentTo("OK"))
95 resultAdd, err := client.TSAdd(ctx, "ts-if-1", 1000, 1.0).Result()
96 Expect(err).NotTo(HaveOccurred())
97 Expect(resultAdd).To(BeEquivalentTo(1000))
98 resultAdd, err = client.TSAdd(ctx, "ts-if-1", 1010, 11.0).Result()
99 Expect(err).NotTo(HaveOccurred())
100 Expect(resultAdd).To(BeEquivalentTo(1010))
101 resultAdd, err = client.TSAdd(ctx, "ts-if-1", 1013, 10.0).Result()
102 Expect(err).NotTo(HaveOccurred())
103 Expect(resultAdd).To(BeEquivalentTo(1010))
104 resultAdd, err = client.TSAdd(ctx, "ts-if-1", 1020, 11.5).Result()
105 Expect(err).NotTo(HaveOccurred())
106 Expect(resultAdd).To(BeEquivalentTo(1020))
107 resultAdd, err = client.TSAdd(ctx, "ts-if-1", 1021, 22.0).Result()
108 Expect(err).NotTo(HaveOccurred())
109 Expect(resultAdd).To(BeEquivalentTo(1021))
110
111 rangePoints, err := client.TSRange(ctx, "ts-if-1", 1000, 1021).Result()
112 Expect(err).NotTo(HaveOccurred())
113 Expect(len(rangePoints)).To(BeEquivalentTo(4))
114 Expect(rangePoints).To(BeEquivalentTo([]redis.TSTimestampValue{
115 {Timestamp: 1000, Value: 1.0},
116 {Timestamp: 1010, Value: 11.0},
117 {Timestamp: 1020, Value: 11.5},
118 {Timestamp: 1021, Value: 22.0}}))
119
120 opt = &redis.TSOptions{IgnoreMaxTimeDiff: 5, IgnoreMaxValDiff: 10.0}
121 result, err = client.TSCreateWithArgs(ctx, "ts-if-2", opt).Result()
122 Expect(err).NotTo(HaveOccurred())
123 Expect(result).To(BeEquivalentTo("OK"))
124 resultAdd1, err := client.TSAdd(ctx, "ts-if-1", 1000, 1.0).Result()
125 Expect(err).NotTo(HaveOccurred())
126 Expect(resultAdd1).To(BeEquivalentTo(1000))
127 resultAdd1, err = client.TSAdd(ctx, "ts-if-1", 1010, 11.0).Result()
128 Expect(err).NotTo(HaveOccurred())
129 Expect(resultAdd1).To(BeEquivalentTo(1010))
130 resultAdd1, err = client.TSAdd(ctx, "ts-if-1", 1013, 10.0).Result()
131 Expect(err).NotTo(HaveOccurred())
132 Expect(resultAdd1).To(BeEquivalentTo(1013))
133
134 rangePoints, err = client.TSRange(ctx, "ts-if-1", 1000, 1013).Result()
135 Expect(err).NotTo(HaveOccurred())
136 Expect(len(rangePoints)).To(BeEquivalentTo(3))
137 Expect(rangePoints).To(BeEquivalentTo([]redis.TSTimestampValue{
138 {Timestamp: 1000, Value: 1.0},
139 {Timestamp: 1010, Value: 11.0},
140 {Timestamp: 1013, Value: 10.0}}))
141 })
142 It("should TSAdd and TSAddWithArgs", Label("timeseries", "tsadd", "tsaddWithArgs", "NonRedisEnterprise"), func() {
143 SkipBeforeRedisVersion(7.4, "older redis stack has different results for timeseries module")
144 result, err := client.TSAdd(ctx, "1", 1, 1).Result()
145 Expect(err).NotTo(HaveOccurred())
146 Expect(result).To(BeEquivalentTo(1))
147
148 opt := &redis.TSOptions{Retention: 10}
149 result, err = client.TSAddWithArgs(ctx, "2", 2, 3, opt).Result()
150 Expect(err).NotTo(HaveOccurred())
151 Expect(result).To(BeEquivalentTo(2))
152 opt = &redis.TSOptions{Labels: map[string]string{"Redis": "Labs"}}
153 result, err = client.TSAddWithArgs(ctx, "3", 3, 2, opt).Result()
154 Expect(err).NotTo(HaveOccurred())
155 Expect(result).To(BeEquivalentTo(3))
156 opt = &redis.TSOptions{Labels: map[string]string{"Redis": "Labs", "Time": "Series"}, Retention: 10}
157 result, err = client.TSAddWithArgs(ctx, "4", 4, 2, opt).Result()
158 Expect(err).NotTo(HaveOccurred())
159 Expect(result).To(BeEquivalentTo(4))
160 resultInfo, err := client.TSInfo(ctx, "4").Result()
161 Expect(err).NotTo(HaveOccurred())
162 if client.Options().Protocol == 2 {
163 Expect(resultInfo["labels"].([]interface{})).To(ContainElement([]interface{}{"Time", "Series"}))
164 } else {
165 Expect(resultInfo["labels"].(map[interface{}]interface{})["Time"]).To(BeEquivalentTo("Series"))
166 }
167
168 opt = &redis.TSOptions{ChunkSize: 128}
169 result, err = client.TSAddWithArgs(ctx, "ts-cs-1", 1, 10, opt).Result()
170 Expect(err).NotTo(HaveOccurred())
171 Expect(result).To(BeEquivalentTo(1))
172 resultInfo, err = client.TSInfo(ctx, "ts-cs-1").Result()
173 Expect(err).NotTo(HaveOccurred())
174 Expect(resultInfo["chunkSize"]).To(BeEquivalentTo(128))
175
176
177 opt = &redis.TSOptions{DuplicatePolicy: "LAST"}
178 result, err = client.TSAddWithArgs(ctx, "tsal-1", 1, 5, opt).Result()
179 Expect(err).NotTo(HaveOccurred())
180 Expect(result).To(BeEquivalentTo(1))
181 result, err = client.TSAddWithArgs(ctx, "tsal-1", 1, 10, opt).Result()
182 Expect(err).NotTo(HaveOccurred())
183 Expect(result).To(BeEquivalentTo(1))
184 resultGet, err := client.TSGet(ctx, "tsal-1").Result()
185 Expect(err).NotTo(HaveOccurred())
186 Expect(resultGet.Value).To(BeEquivalentTo(10))
187
188 opt = &redis.TSOptions{DuplicatePolicy: "FIRST"}
189 result, err = client.TSAddWithArgs(ctx, "tsaf-1", 1, 5, opt).Result()
190 Expect(err).NotTo(HaveOccurred())
191 Expect(result).To(BeEquivalentTo(1))
192 result, err = client.TSAddWithArgs(ctx, "tsaf-1", 1, 10, opt).Result()
193 Expect(err).NotTo(HaveOccurred())
194 Expect(result).To(BeEquivalentTo(1))
195 resultGet, err = client.TSGet(ctx, "tsaf-1").Result()
196 Expect(err).NotTo(HaveOccurred())
197 Expect(resultGet.Value).To(BeEquivalentTo(5))
198
199 opt = &redis.TSOptions{DuplicatePolicy: "MAX"}
200 result, err = client.TSAddWithArgs(ctx, "tsam-1", 1, 5, opt).Result()
201 Expect(err).NotTo(HaveOccurred())
202 Expect(result).To(BeEquivalentTo(1))
203 result, err = client.TSAddWithArgs(ctx, "tsam-1", 1, 10, opt).Result()
204 Expect(err).NotTo(HaveOccurred())
205 Expect(result).To(BeEquivalentTo(1))
206 resultGet, err = client.TSGet(ctx, "tsam-1").Result()
207 Expect(err).NotTo(HaveOccurred())
208 Expect(resultGet.Value).To(BeEquivalentTo(10))
209
210 opt = &redis.TSOptions{DuplicatePolicy: "MIN"}
211 result, err = client.TSAddWithArgs(ctx, "tsami-1", 1, 5, opt).Result()
212 Expect(err).NotTo(HaveOccurred())
213 Expect(result).To(BeEquivalentTo(1))
214 result, err = client.TSAddWithArgs(ctx, "tsami-1", 1, 10, opt).Result()
215 Expect(err).NotTo(HaveOccurred())
216 Expect(result).To(BeEquivalentTo(1))
217 resultGet, err = client.TSGet(ctx, "tsami-1").Result()
218 Expect(err).NotTo(HaveOccurred())
219 Expect(resultGet.Value).To(BeEquivalentTo(5))
220
221 opt = &redis.TSOptions{IgnoreMaxTimeDiff: 5, IgnoreMaxValDiff: 10.0, DuplicatePolicy: "LAST"}
222 result, err = client.TSAddWithArgs(ctx, "ts-if-1", 1000, 1.0, opt).Result()
223 Expect(err).NotTo(HaveOccurred())
224 Expect(result).To(BeEquivalentTo(1000))
225
226 result, err = client.TSAddWithArgs(ctx, "ts-if-1", 1004, 3.0, opt).Result()
227 Expect(err).NotTo(HaveOccurred())
228 Expect(result).To(BeEquivalentTo(1000))
229
230 rangePoints, err := client.TSRange(ctx, "ts-if-1", 1000, 1004).Result()
231 Expect(err).NotTo(HaveOccurred())
232 Expect(len(rangePoints)).To(BeEquivalentTo(1))
233 Expect(rangePoints).To(BeEquivalentTo([]redis.TSTimestampValue{{Timestamp: 1000, Value: 1.0}}))
234 })
235
236 It("should TSAlter", Label("timeseries", "tsalter", "NonRedisEnterprise"), func() {
237 SkipBeforeRedisVersion(7.4, "older redis stack has different results for timeseries module")
238 result, err := client.TSCreate(ctx, "1").Result()
239 Expect(err).NotTo(HaveOccurred())
240 Expect(result).To(BeEquivalentTo("OK"))
241 resultInfo, err := client.TSInfo(ctx, "1").Result()
242 Expect(err).NotTo(HaveOccurred())
243 Expect(resultInfo["retentionTime"]).To(BeEquivalentTo(0))
244
245 opt := &redis.TSAlterOptions{Retention: 10}
246 resultAlter, err := client.TSAlter(ctx, "1", opt).Result()
247 Expect(err).NotTo(HaveOccurred())
248 Expect(resultAlter).To(BeEquivalentTo("OK"))
249
250 resultInfo, err = client.TSInfo(ctx, "1").Result()
251 Expect(err).NotTo(HaveOccurred())
252 Expect(resultInfo["retentionTime"]).To(BeEquivalentTo(10))
253
254 resultInfo, err = client.TSInfo(ctx, "1").Result()
255 Expect(err).NotTo(HaveOccurred())
256 if client.Options().Protocol == 2 {
257 Expect(resultInfo["labels"]).To(BeEquivalentTo([]interface{}{}))
258 } else {
259 Expect(resultInfo["labels"]).To(BeEquivalentTo(map[interface{}]interface{}{}))
260 }
261
262 opt = &redis.TSAlterOptions{Labels: map[string]string{"Time": "Series"}}
263 resultAlter, err = client.TSAlter(ctx, "1", opt).Result()
264 Expect(err).NotTo(HaveOccurred())
265 Expect(resultAlter).To(BeEquivalentTo("OK"))
266
267 resultInfo, err = client.TSInfo(ctx, "1").Result()
268 Expect(err).NotTo(HaveOccurred())
269 if client.Options().Protocol == 2 {
270 Expect(resultInfo["labels"].([]interface{})[0]).To(BeEquivalentTo([]interface{}{"Time", "Series"}))
271 Expect(resultInfo["retentionTime"]).To(BeEquivalentTo(10))
272 if RedisVersion >= 8 {
273 Expect(resultInfo["duplicatePolicy"]).To(BeEquivalentTo("block"))
274 } else {
275
276 Expect(resultInfo["duplicatePolicy"]).To(BeEquivalentTo(redis.Nil))
277 }
278 } else {
279 Expect(resultInfo["labels"].(map[interface{}]interface{})["Time"]).To(BeEquivalentTo("Series"))
280 Expect(resultInfo["retentionTime"]).To(BeEquivalentTo(10))
281 if RedisVersion >= 8 {
282 Expect(resultInfo["duplicatePolicy"]).To(BeEquivalentTo("block"))
283 } else {
284
285 Expect(resultInfo["duplicatePolicy"]).To(BeEquivalentTo(redis.Nil))
286 }
287 }
288 opt = &redis.TSAlterOptions{DuplicatePolicy: "min"}
289 resultAlter, err = client.TSAlter(ctx, "1", opt).Result()
290 Expect(err).NotTo(HaveOccurred())
291 Expect(resultAlter).To(BeEquivalentTo("OK"))
292
293 resultInfo, err = client.TSInfo(ctx, "1").Result()
294 Expect(err).NotTo(HaveOccurred())
295 Expect(resultInfo["duplicatePolicy"]).To(BeEquivalentTo("min"))
296
297 resultAdd, err := client.TSAdd(ctx, "ts-if-1", 1000, 1.0).Result()
298 Expect(err).NotTo(HaveOccurred())
299 Expect(resultAdd).To(BeEquivalentTo(1000))
300 resultAdd, err = client.TSAdd(ctx, "ts-if-1", 1010, 11.0).Result()
301 Expect(err).NotTo(HaveOccurred())
302 Expect(resultAdd).To(BeEquivalentTo(1010))
303 resultAdd, err = client.TSAdd(ctx, "ts-if-1", 1013, 10.0).Result()
304 Expect(err).NotTo(HaveOccurred())
305 Expect(resultAdd).To(BeEquivalentTo(1013))
306
307 alterOpt := &redis.TSAlterOptions{IgnoreMaxTimeDiff: 5, IgnoreMaxValDiff: 10.0, DuplicatePolicy: "LAST"}
308 resultAlter, err = client.TSAlter(ctx, "ts-if-1", alterOpt).Result()
309 Expect(err).NotTo(HaveOccurred())
310 Expect(resultAlter).To(BeEquivalentTo("OK"))
311
312 resultAdd, err = client.TSAdd(ctx, "ts-if-1", 1015, 11.5).Result()
313 Expect(err).NotTo(HaveOccurred())
314 Expect(resultAdd).To(BeEquivalentTo(1013))
315
316 rangePoints, err := client.TSRange(ctx, "ts-if-1", 1000, 1013).Result()
317 Expect(err).NotTo(HaveOccurred())
318 Expect(len(rangePoints)).To(BeEquivalentTo(3))
319 Expect(rangePoints).To(BeEquivalentTo([]redis.TSTimestampValue{
320 {Timestamp: 1000, Value: 1.0},
321 {Timestamp: 1010, Value: 11.0},
322 {Timestamp: 1013, Value: 10.0}}))
323 })
324
325 It("should TSCreateRule and TSDeleteRule", Label("timeseries", "tscreaterule", "tsdeleterule"), func() {
326 result, err := client.TSCreate(ctx, "1").Result()
327 Expect(err).NotTo(HaveOccurred())
328 Expect(result).To(BeEquivalentTo("OK"))
329 result, err = client.TSCreate(ctx, "2").Result()
330 Expect(err).NotTo(HaveOccurred())
331 Expect(result).To(BeEquivalentTo("OK"))
332 result, err = client.TSCreateRule(ctx, "1", "2", redis.Avg, 100).Result()
333 Expect(err).NotTo(HaveOccurred())
334 Expect(result).To(BeEquivalentTo("OK"))
335 for i := 0; i < 50; i++ {
336 resultAdd, err := client.TSAdd(ctx, "1", 100+i*2, 1).Result()
337 Expect(err).NotTo(HaveOccurred())
338 Expect(resultAdd).To(BeEquivalentTo(100 + i*2))
339 resultAdd, err = client.TSAdd(ctx, "1", 100+i*2+1, 2).Result()
340 Expect(err).NotTo(HaveOccurred())
341 Expect(resultAdd).To(BeEquivalentTo(100 + i*2 + 1))
342
343 }
344 resultAdd, err := client.TSAdd(ctx, "1", 100*2, 1.5).Result()
345 Expect(err).NotTo(HaveOccurred())
346 Expect(resultAdd).To(BeEquivalentTo(100 * 2))
347 resultGet, err := client.TSGet(ctx, "2").Result()
348 Expect(err).NotTo(HaveOccurred())
349 Expect(resultGet.Value).To(BeEquivalentTo(1.5))
350 Expect(resultGet.Timestamp).To(BeEquivalentTo(100))
351
352 resultDeleteRule, err := client.TSDeleteRule(ctx, "1", "2").Result()
353 Expect(err).NotTo(HaveOccurred())
354 Expect(resultDeleteRule).To(BeEquivalentTo("OK"))
355 resultInfo, err := client.TSInfo(ctx, "1").Result()
356 Expect(err).NotTo(HaveOccurred())
357 if client.Options().Protocol == 2 {
358 Expect(resultInfo["rules"]).To(BeEquivalentTo([]interface{}{}))
359 } else {
360 Expect(resultInfo["rules"]).To(BeEquivalentTo(map[interface{}]interface{}{}))
361 }
362 })
363
364 It("should TSIncrBy, TSIncrByWithArgs, TSDecrBy and TSDecrByWithArgs", Label("timeseries", "tsincrby", "tsdecrby", "tsincrbyWithArgs", "tsdecrbyWithArgs", "NonRedisEnterprise"), func() {
365 SkipBeforeRedisVersion(7.4, "older redis stack has different results for timeseries module")
366 for i := 0; i < 100; i++ {
367 _, err := client.TSIncrBy(ctx, "1", 1).Result()
368 Expect(err).NotTo(HaveOccurred())
369 }
370 result, err := client.TSGet(ctx, "1").Result()
371 Expect(err).NotTo(HaveOccurred())
372 Expect(result.Value).To(BeEquivalentTo(100))
373
374 for i := 0; i < 100; i++ {
375 _, err := client.TSDecrBy(ctx, "1", 1).Result()
376 Expect(err).NotTo(HaveOccurred())
377 }
378 result, err = client.TSGet(ctx, "1").Result()
379 Expect(err).NotTo(HaveOccurred())
380 Expect(result.Value).To(BeEquivalentTo(0))
381
382 opt := &redis.TSIncrDecrOptions{Timestamp: 5}
383 _, err = client.TSIncrByWithArgs(ctx, "2", 1.5, opt).Result()
384 Expect(err).NotTo(HaveOccurred())
385
386 result, err = client.TSGet(ctx, "2").Result()
387 Expect(err).NotTo(HaveOccurred())
388 Expect(result.Timestamp).To(BeEquivalentTo(5))
389 Expect(result.Value).To(BeEquivalentTo(1.5))
390
391 opt = &redis.TSIncrDecrOptions{Timestamp: 7}
392 _, err = client.TSIncrByWithArgs(ctx, "2", 2.25, opt).Result()
393 Expect(err).NotTo(HaveOccurred())
394
395 result, err = client.TSGet(ctx, "2").Result()
396 Expect(err).NotTo(HaveOccurred())
397 Expect(result.Timestamp).To(BeEquivalentTo(7))
398 Expect(result.Value).To(BeEquivalentTo(3.75))
399
400 opt = &redis.TSIncrDecrOptions{Timestamp: 15}
401 _, err = client.TSDecrByWithArgs(ctx, "2", 1.5, opt).Result()
402 Expect(err).NotTo(HaveOccurred())
403
404 result, err = client.TSGet(ctx, "2").Result()
405 Expect(err).NotTo(HaveOccurred())
406 Expect(result.Timestamp).To(BeEquivalentTo(15))
407 Expect(result.Value).To(BeEquivalentTo(2.25))
408
409
410 opt = &redis.TSIncrDecrOptions{ChunkSize: 128}
411 _, err = client.TSIncrByWithArgs(ctx, "3", 10, opt).Result()
412 Expect(err).NotTo(HaveOccurred())
413
414 resultInfo, err := client.TSInfo(ctx, "3").Result()
415 Expect(err).NotTo(HaveOccurred())
416 Expect(resultInfo["chunkSize"]).To(BeEquivalentTo(128))
417
418
419 opt = &redis.TSIncrDecrOptions{ChunkSize: 128}
420 _, err = client.TSDecrByWithArgs(ctx, "4", 10, opt).Result()
421 Expect(err).NotTo(HaveOccurred())
422
423 resultInfo, err = client.TSInfo(ctx, "4").Result()
424 Expect(err).NotTo(HaveOccurred())
425 Expect(resultInfo["chunkSize"]).To(BeEquivalentTo(128))
426
427
428 opt = &redis.TSIncrDecrOptions{Timestamp: 1000, IgnoreMaxTimeDiff: 5, IgnoreMaxValDiff: 10.0, DuplicatePolicy: "LAST"}
429 res, err := client.TSIncrByWithArgs(ctx, "ts-if-1", 1.0, opt).Result()
430 Expect(err).NotTo(HaveOccurred())
431 Expect(res).To(BeEquivalentTo(1000))
432
433 res, err = client.TSIncrByWithArgs(ctx, "ts-if-1", 3.0, &redis.TSIncrDecrOptions{Timestamp: 1000}).Result()
434 Expect(err).NotTo(HaveOccurred())
435 Expect(res).To(BeEquivalentTo(1000))
436
437 rangePoints, err := client.TSRange(ctx, "ts-if-1", 1000, 1004).Result()
438 Expect(err).NotTo(HaveOccurred())
439 Expect(len(rangePoints)).To(BeEquivalentTo(1))
440 Expect(rangePoints).To(BeEquivalentTo([]redis.TSTimestampValue{{Timestamp: 1000, Value: 1.0}}))
441
442 res, err = client.TSIncrByWithArgs(ctx, "ts-if-1", 10.1, &redis.TSIncrDecrOptions{Timestamp: 1000}).Result()
443 Expect(err).NotTo(HaveOccurred())
444 Expect(res).To(BeEquivalentTo(1000))
445
446 rangePoints, err = client.TSRange(ctx, "ts-if-1", 1000, 1004).Result()
447 Expect(err).NotTo(HaveOccurred())
448 Expect(len(rangePoints)).To(BeEquivalentTo(1))
449 Expect(rangePoints).To(BeEquivalentTo([]redis.TSTimestampValue{{Timestamp: 1000, Value: 11.1}}))
450
451
452 opt = &redis.TSIncrDecrOptions{Timestamp: 1000, IgnoreMaxTimeDiff: 5, IgnoreMaxValDiff: 10.0, DuplicatePolicy: "LAST"}
453 res, err = client.TSDecrByWithArgs(ctx, "ts-if-2", 1.0, opt).Result()
454 Expect(err).NotTo(HaveOccurred())
455 Expect(res).To(BeEquivalentTo(1000))
456
457 res, err = client.TSDecrByWithArgs(ctx, "ts-if-2", 3.0, &redis.TSIncrDecrOptions{Timestamp: 1000}).Result()
458 Expect(err).NotTo(HaveOccurred())
459 Expect(res).To(BeEquivalentTo(1000))
460
461 rangePoints, err = client.TSRange(ctx, "ts-if-2", 1000, 1004).Result()
462 Expect(err).NotTo(HaveOccurred())
463 Expect(len(rangePoints)).To(BeEquivalentTo(1))
464 Expect(rangePoints).To(BeEquivalentTo([]redis.TSTimestampValue{{Timestamp: 1000, Value: -1.0}}))
465
466 res, err = client.TSDecrByWithArgs(ctx, "ts-if-2", 10.1, &redis.TSIncrDecrOptions{Timestamp: 1000}).Result()
467 Expect(err).NotTo(HaveOccurred())
468 Expect(res).To(BeEquivalentTo(1000))
469
470 rangePoints, err = client.TSRange(ctx, "ts-if-2", 1000, 1004).Result()
471 Expect(err).NotTo(HaveOccurred())
472 Expect(len(rangePoints)).To(BeEquivalentTo(1))
473 Expect(rangePoints).To(BeEquivalentTo([]redis.TSTimestampValue{{Timestamp: 1000, Value: -11.1}}))
474 })
475
476 It("should TSGet", Label("timeseries", "tsget"), func() {
477 opt := &redis.TSOptions{DuplicatePolicy: "max"}
478 resultGet, err := client.TSAddWithArgs(ctx, "foo", 2265985, 151, opt).Result()
479 Expect(err).NotTo(HaveOccurred())
480 Expect(resultGet).To(BeEquivalentTo(2265985))
481 result, err := client.TSGet(ctx, "foo").Result()
482 Expect(err).NotTo(HaveOccurred())
483 Expect(result.Timestamp).To(BeEquivalentTo(2265985))
484 Expect(result.Value).To(BeEquivalentTo(151))
485 })
486
487 It("should TSGet Latest", Label("timeseries", "tsgetlatest", "NonRedisEnterprise"), func() {
488 resultGet, err := client.TSCreate(ctx, "tsgl-1").Result()
489 Expect(err).NotTo(HaveOccurred())
490 Expect(resultGet).To(BeEquivalentTo("OK"))
491 resultGet, err = client.TSCreate(ctx, "tsgl-2").Result()
492 Expect(err).NotTo(HaveOccurred())
493 Expect(resultGet).To(BeEquivalentTo("OK"))
494
495 resultGet, err = client.TSCreateRule(ctx, "tsgl-1", "tsgl-2", redis.Sum, 10).Result()
496 Expect(err).NotTo(HaveOccurred())
497
498 Expect(resultGet).To(BeEquivalentTo("OK"))
499 _, err = client.TSAdd(ctx, "tsgl-1", 1, 1).Result()
500 Expect(err).NotTo(HaveOccurred())
501 _, err = client.TSAdd(ctx, "tsgl-1", 2, 3).Result()
502 Expect(err).NotTo(HaveOccurred())
503 _, err = client.TSAdd(ctx, "tsgl-1", 11, 7).Result()
504 Expect(err).NotTo(HaveOccurred())
505 _, err = client.TSAdd(ctx, "tsgl-1", 13, 1).Result()
506 Expect(err).NotTo(HaveOccurred())
507 result, errGet := client.TSGet(ctx, "tsgl-2").Result()
508 Expect(errGet).NotTo(HaveOccurred())
509 Expect(result.Timestamp).To(BeEquivalentTo(0))
510 Expect(result.Value).To(BeEquivalentTo(4))
511 result, errGet = client.TSGetWithArgs(ctx, "tsgl-2", &redis.TSGetOptions{Latest: true}).Result()
512 Expect(errGet).NotTo(HaveOccurred())
513 Expect(result.Timestamp).To(BeEquivalentTo(10))
514 Expect(result.Value).To(BeEquivalentTo(8))
515 })
516
517 It("should TSInfo", Label("timeseries", "tsinfo"), func() {
518 resultGet, err := client.TSAdd(ctx, "foo", 2265985, 151).Result()
519 Expect(err).NotTo(HaveOccurred())
520 Expect(resultGet).To(BeEquivalentTo(2265985))
521 result, err := client.TSInfo(ctx, "foo").Result()
522 Expect(err).NotTo(HaveOccurred())
523 Expect(result["firstTimestamp"]).To(BeEquivalentTo(2265985))
524 })
525
526 It("should TSMAdd", Label("timeseries", "tsmadd"), func() {
527 resultGet, err := client.TSCreate(ctx, "a").Result()
528 Expect(err).NotTo(HaveOccurred())
529 Expect(resultGet).To(BeEquivalentTo("OK"))
530 ktvSlices := make([][]interface{}, 3)
531 for i := 0; i < 3; i++ {
532 ktvSlices[i] = make([]interface{}, 3)
533 ktvSlices[i][0] = "a"
534 for j := 1; j < 3; j++ {
535 ktvSlices[i][j] = (i + j) * j
536 }
537 }
538 result, err := client.TSMAdd(ctx, ktvSlices).Result()
539 Expect(err).NotTo(HaveOccurred())
540 Expect(result).To(BeEquivalentTo([]int64{1, 2, 3}))
541 })
542
543 It("should TSMGet and TSMGetWithArgs", Label("timeseries", "tsmget", "tsmgetWithArgs", "NonRedisEnterprise"), func() {
544 opt := &redis.TSOptions{Labels: map[string]string{"Test": "This"}}
545 resultCreate, err := client.TSCreateWithArgs(ctx, "a", opt).Result()
546 Expect(err).NotTo(HaveOccurred())
547 Expect(resultCreate).To(BeEquivalentTo("OK"))
548 opt = &redis.TSOptions{Labels: map[string]string{"Test": "This", "Taste": "That"}}
549 resultCreate, err = client.TSCreateWithArgs(ctx, "b", opt).Result()
550 Expect(err).NotTo(HaveOccurred())
551 Expect(resultCreate).To(BeEquivalentTo("OK"))
552 _, err = client.TSAdd(ctx, "a", "*", 15).Result()
553 Expect(err).NotTo(HaveOccurred())
554 _, err = client.TSAdd(ctx, "b", "*", 25).Result()
555 Expect(err).NotTo(HaveOccurred())
556
557 result, err := client.TSMGet(ctx, []string{"Test=This"}).Result()
558 Expect(err).NotTo(HaveOccurred())
559 if client.Options().Protocol == 2 {
560 Expect(result["a"][1].([]interface{})[1]).To(BeEquivalentTo("15"))
561 Expect(result["b"][1].([]interface{})[1]).To(BeEquivalentTo("25"))
562 } else {
563 Expect(result["a"][1].([]interface{})[1]).To(BeEquivalentTo(15))
564 Expect(result["b"][1].([]interface{})[1]).To(BeEquivalentTo(25))
565 }
566 mgetOpt := &redis.TSMGetOptions{WithLabels: true}
567 result, err = client.TSMGetWithArgs(ctx, []string{"Test=This"}, mgetOpt).Result()
568 Expect(err).NotTo(HaveOccurred())
569 if client.Options().Protocol == 2 {
570 Expect(result["b"][0]).To(ConsistOf([]interface{}{"Test", "This"}, []interface{}{"Taste", "That"}))
571 } else {
572 Expect(result["b"][0]).To(BeEquivalentTo(map[interface{}]interface{}{"Test": "This", "Taste": "That"}))
573 }
574
575 resultCreate, err = client.TSCreate(ctx, "c").Result()
576 Expect(err).NotTo(HaveOccurred())
577 Expect(resultCreate).To(BeEquivalentTo("OK"))
578 opt = &redis.TSOptions{Labels: map[string]string{"is_compaction": "true"}}
579 resultCreate, err = client.TSCreateWithArgs(ctx, "d", opt).Result()
580 Expect(err).NotTo(HaveOccurred())
581 Expect(resultCreate).To(BeEquivalentTo("OK"))
582 resultCreateRule, err := client.TSCreateRule(ctx, "c", "d", redis.Sum, 10).Result()
583 Expect(err).NotTo(HaveOccurred())
584 Expect(resultCreateRule).To(BeEquivalentTo("OK"))
585 _, err = client.TSAdd(ctx, "c", 1, 1).Result()
586 Expect(err).NotTo(HaveOccurred())
587 _, err = client.TSAdd(ctx, "c", 2, 3).Result()
588 Expect(err).NotTo(HaveOccurred())
589 _, err = client.TSAdd(ctx, "c", 11, 7).Result()
590 Expect(err).NotTo(HaveOccurred())
591 _, err = client.TSAdd(ctx, "c", 13, 1).Result()
592 Expect(err).NotTo(HaveOccurred())
593 result, err = client.TSMGet(ctx, []string{"is_compaction=true"}).Result()
594 Expect(err).NotTo(HaveOccurred())
595 if client.Options().Protocol == 2 {
596 Expect(result["d"][1]).To(BeEquivalentTo([]interface{}{int64(0), "4"}))
597 } else {
598 Expect(result["d"][1]).To(BeEquivalentTo([]interface{}{int64(0), 4.0}))
599 }
600 mgetOpt = &redis.TSMGetOptions{Latest: true}
601 result, err = client.TSMGetWithArgs(ctx, []string{"is_compaction=true"}, mgetOpt).Result()
602 Expect(err).NotTo(HaveOccurred())
603 if client.Options().Protocol == 2 {
604 Expect(result["d"][1]).To(BeEquivalentTo([]interface{}{int64(10), "8"}))
605 } else {
606 Expect(result["d"][1]).To(BeEquivalentTo([]interface{}{int64(10), 8.0}))
607 }
608 })
609
610 It("should TSQueryIndex", Label("timeseries", "tsqueryindex"), func() {
611 opt := &redis.TSOptions{Labels: map[string]string{"Test": "This"}}
612 resultCreate, err := client.TSCreateWithArgs(ctx, "a", opt).Result()
613 Expect(err).NotTo(HaveOccurred())
614 Expect(resultCreate).To(BeEquivalentTo("OK"))
615 opt = &redis.TSOptions{Labels: map[string]string{"Test": "This", "Taste": "That"}}
616 resultCreate, err = client.TSCreateWithArgs(ctx, "b", opt).Result()
617 Expect(err).NotTo(HaveOccurred())
618 Expect(resultCreate).To(BeEquivalentTo("OK"))
619 result, err := client.TSQueryIndex(ctx, []string{"Test=This"}).Result()
620 Expect(err).NotTo(HaveOccurred())
621 Expect(len(result)).To(BeEquivalentTo(2))
622 result, err = client.TSQueryIndex(ctx, []string{"Taste=That"}).Result()
623 Expect(err).NotTo(HaveOccurred())
624 Expect(len(result)).To(BeEquivalentTo(1))
625 })
626
627 It("should TSDel and TSRange", Label("timeseries", "tsdel", "tsrange"), func() {
628 for i := 0; i < 100; i++ {
629 _, err := client.TSAdd(ctx, "a", i, float64(i%7)).Result()
630 Expect(err).NotTo(HaveOccurred())
631 }
632 resultDelete, err := client.TSDel(ctx, "a", 0, 21).Result()
633 Expect(err).NotTo(HaveOccurred())
634 Expect(resultDelete).To(BeEquivalentTo(22))
635
636 resultRange, err := client.TSRange(ctx, "a", 0, 21).Result()
637 Expect(err).NotTo(HaveOccurred())
638 Expect(resultRange).To(BeEquivalentTo([]redis.TSTimestampValue{}))
639
640 resultRange, err = client.TSRange(ctx, "a", 22, 22).Result()
641 Expect(err).NotTo(HaveOccurred())
642 Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 22, Value: 1}))
643 })
644
645 It("should TSRange, TSRangeWithArgs", Label("timeseries", "tsrange", "tsrangeWithArgs", "NonRedisEnterprise"), func() {
646 for i := 0; i < 100; i++ {
647 _, err := client.TSAdd(ctx, "a", i, float64(i%7)).Result()
648 Expect(err).NotTo(HaveOccurred())
649
650 }
651 result, err := client.TSRange(ctx, "a", 0, 200).Result()
652 Expect(err).NotTo(HaveOccurred())
653 Expect(len(result)).To(BeEquivalentTo(100))
654 for i := 0; i < 100; i++ {
655 client.TSAdd(ctx, "a", i+200, float64(i%7))
656 }
657 result, err = client.TSRange(ctx, "a", 0, 500).Result()
658 Expect(err).NotTo(HaveOccurred())
659 Expect(len(result)).To(BeEquivalentTo(200))
660 fts := make([]int, 0)
661 for i := 10; i < 20; i++ {
662 fts = append(fts, i)
663 }
664 opt := &redis.TSRangeOptions{FilterByTS: fts, FilterByValue: []int{1, 2}}
665 result, err = client.TSRangeWithArgs(ctx, "a", 0, 500, opt).Result()
666 Expect(err).NotTo(HaveOccurred())
667 Expect(len(result)).To(BeEquivalentTo(2))
668 opt = &redis.TSRangeOptions{Aggregator: redis.Count, BucketDuration: 10, Align: "+"}
669 result, err = client.TSRangeWithArgs(ctx, "a", 0, 10, opt).Result()
670 Expect(err).NotTo(HaveOccurred())
671 Expect(result).To(BeEquivalentTo([]redis.TSTimestampValue{{Timestamp: 0, Value: 10}, {Timestamp: 10, Value: 1}}))
672 opt = &redis.TSRangeOptions{Aggregator: redis.Count, BucketDuration: 10, Align: "5"}
673 result, err = client.TSRangeWithArgs(ctx, "a", 0, 10, opt).Result()
674 Expect(err).NotTo(HaveOccurred())
675 Expect(result).To(BeEquivalentTo([]redis.TSTimestampValue{{Timestamp: 0, Value: 5}, {Timestamp: 5, Value: 6}}))
676 opt = &redis.TSRangeOptions{Aggregator: redis.Twa, BucketDuration: 10}
677 result, err = client.TSRangeWithArgs(ctx, "a", 0, 10, opt).Result()
678 Expect(err).NotTo(HaveOccurred())
679 Expect(result).To(BeEquivalentTo([]redis.TSTimestampValue{{Timestamp: 0, Value: 2.55}, {Timestamp: 10, Value: 3}}))
680
681 resultCreate, err := client.TSCreate(ctx, "t1").Result()
682 Expect(err).NotTo(HaveOccurred())
683 Expect(resultCreate).To(BeEquivalentTo("OK"))
684 resultCreate, err = client.TSCreate(ctx, "t2").Result()
685 Expect(err).NotTo(HaveOccurred())
686 Expect(resultCreate).To(BeEquivalentTo("OK"))
687 resultRule, err := client.TSCreateRule(ctx, "t1", "t2", redis.Sum, 10).Result()
688 Expect(err).NotTo(HaveOccurred())
689 Expect(resultRule).To(BeEquivalentTo("OK"))
690 _, errAdd := client.TSAdd(ctx, "t1", 1, 1).Result()
691 Expect(errAdd).NotTo(HaveOccurred())
692 _, errAdd = client.TSAdd(ctx, "t1", 2, 3).Result()
693 Expect(errAdd).NotTo(HaveOccurred())
694 _, errAdd = client.TSAdd(ctx, "t1", 11, 7).Result()
695 Expect(errAdd).NotTo(HaveOccurred())
696 _, errAdd = client.TSAdd(ctx, "t1", 13, 1).Result()
697 Expect(errAdd).NotTo(HaveOccurred())
698 resultRange, err := client.TSRange(ctx, "t1", 0, 20).Result()
699 Expect(err).NotTo(HaveOccurred())
700 Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 1, Value: 1}))
701
702 opt = &redis.TSRangeOptions{Latest: true}
703 resultRange, err = client.TSRangeWithArgs(ctx, "t2", 0, 10, opt).Result()
704 Expect(err).NotTo(HaveOccurred())
705 Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 0, Value: 4}))
706
707 resultCreate, err = client.TSCreate(ctx, "t3").Result()
708 Expect(err).NotTo(HaveOccurred())
709 Expect(resultCreate).To(BeEquivalentTo("OK"))
710 _, errAdd = client.TSAdd(ctx, "t3", 15, 1).Result()
711 Expect(errAdd).NotTo(HaveOccurred())
712 _, errAdd = client.TSAdd(ctx, "t3", 17, 4).Result()
713 Expect(errAdd).NotTo(HaveOccurred())
714 _, errAdd = client.TSAdd(ctx, "t3", 51, 3).Result()
715 Expect(errAdd).NotTo(HaveOccurred())
716 _, errAdd = client.TSAdd(ctx, "t3", 73, 5).Result()
717 Expect(errAdd).NotTo(HaveOccurred())
718 _, errAdd = client.TSAdd(ctx, "t3", 75, 3).Result()
719 Expect(errAdd).NotTo(HaveOccurred())
720
721 opt = &redis.TSRangeOptions{Aggregator: redis.Max, Align: 0, BucketDuration: 10}
722 resultRange, err = client.TSRangeWithArgs(ctx, "t3", 0, 100, opt).Result()
723 Expect(err).NotTo(HaveOccurred())
724 Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 10, Value: 4}))
725 Expect(len(resultRange)).To(BeEquivalentTo(3))
726
727 opt = &redis.TSRangeOptions{Aggregator: redis.Max, Align: 0, BucketDuration: 10, BucketTimestamp: "+"}
728 resultRange, err = client.TSRangeWithArgs(ctx, "t3", 0, 100, opt).Result()
729 Expect(err).NotTo(HaveOccurred())
730 Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 20, Value: 4}))
731 Expect(len(resultRange)).To(BeEquivalentTo(3))
732
733 _, errAdd = client.TSAdd(ctx, "t4", 15, 1).Result()
734 Expect(errAdd).NotTo(HaveOccurred())
735 _, errAdd = client.TSAdd(ctx, "t4", 17, 4).Result()
736 Expect(errAdd).NotTo(HaveOccurred())
737 _, errAdd = client.TSAdd(ctx, "t4", 51, 3).Result()
738 Expect(errAdd).NotTo(HaveOccurred())
739 _, errAdd = client.TSAdd(ctx, "t4", 73, 5).Result()
740 Expect(errAdd).NotTo(HaveOccurred())
741 _, errAdd = client.TSAdd(ctx, "t4", 75, 3).Result()
742 Expect(errAdd).NotTo(HaveOccurred())
743
744 opt = &redis.TSRangeOptions{Aggregator: redis.Max, Align: 0, BucketDuration: 10}
745 resultRange, err = client.TSRangeWithArgs(ctx, "t4", 0, 100, opt).Result()
746 Expect(err).NotTo(HaveOccurred())
747 Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 10, Value: 4}))
748 Expect(len(resultRange)).To(BeEquivalentTo(3))
749
750 opt = &redis.TSRangeOptions{Aggregator: redis.Max, Align: 0, BucketDuration: 10, Empty: true}
751 resultRange, err = client.TSRangeWithArgs(ctx, "t4", 0, 100, opt).Result()
752 Expect(err).NotTo(HaveOccurred())
753 Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 10, Value: 4}))
754 Expect(len(resultRange)).To(BeEquivalentTo(7))
755 })
756
757 It("should TSRevRange, TSRevRangeWithArgs", Label("timeseries", "tsrevrange", "tsrevrangeWithArgs", "NonRedisEnterprise"), func() {
758 for i := 0; i < 100; i++ {
759 _, err := client.TSAdd(ctx, "a", i, float64(i%7)).Result()
760 Expect(err).NotTo(HaveOccurred())
761
762 }
763 result, err := client.TSRange(ctx, "a", 0, 200).Result()
764 Expect(err).NotTo(HaveOccurred())
765 Expect(len(result)).To(BeEquivalentTo(100))
766 for i := 0; i < 100; i++ {
767 client.TSAdd(ctx, "a", i+200, float64(i%7))
768 }
769 result, err = client.TSRange(ctx, "a", 0, 500).Result()
770 Expect(err).NotTo(HaveOccurred())
771 Expect(len(result)).To(BeEquivalentTo(200))
772
773 opt := &redis.TSRevRangeOptions{Aggregator: redis.Avg, BucketDuration: 10}
774 result, err = client.TSRevRangeWithArgs(ctx, "a", 0, 500, opt).Result()
775 Expect(err).NotTo(HaveOccurred())
776 Expect(len(result)).To(BeEquivalentTo(20))
777
778 opt = &redis.TSRevRangeOptions{Count: 10}
779 result, err = client.TSRevRangeWithArgs(ctx, "a", 0, 500, opt).Result()
780 Expect(err).NotTo(HaveOccurred())
781 Expect(len(result)).To(BeEquivalentTo(10))
782
783 fts := make([]int, 0)
784 for i := 10; i < 20; i++ {
785 fts = append(fts, i)
786 }
787 opt = &redis.TSRevRangeOptions{FilterByTS: fts, FilterByValue: []int{1, 2}}
788 result, err = client.TSRevRangeWithArgs(ctx, "a", 0, 500, opt).Result()
789 Expect(err).NotTo(HaveOccurred())
790 Expect(len(result)).To(BeEquivalentTo(2))
791
792 opt = &redis.TSRevRangeOptions{Aggregator: redis.Count, BucketDuration: 10, Align: "+"}
793 result, err = client.TSRevRangeWithArgs(ctx, "a", 0, 10, opt).Result()
794 Expect(err).NotTo(HaveOccurred())
795 Expect(result).To(BeEquivalentTo([]redis.TSTimestampValue{{Timestamp: 10, Value: 1}, {Timestamp: 0, Value: 10}}))
796
797 opt = &redis.TSRevRangeOptions{Aggregator: redis.Count, BucketDuration: 10, Align: "1"}
798 result, err = client.TSRevRangeWithArgs(ctx, "a", 0, 10, opt).Result()
799 Expect(err).NotTo(HaveOccurred())
800 Expect(result).To(BeEquivalentTo([]redis.TSTimestampValue{{Timestamp: 1, Value: 10}, {Timestamp: 0, Value: 1}}))
801
802 opt = &redis.TSRevRangeOptions{Aggregator: redis.Twa, BucketDuration: 10}
803 result, err = client.TSRevRangeWithArgs(ctx, "a", 0, 10, opt).Result()
804 Expect(err).NotTo(HaveOccurred())
805 Expect(result).To(BeEquivalentTo([]redis.TSTimestampValue{{Timestamp: 10, Value: 3}, {Timestamp: 0, Value: 2.55}}))
806
807 resultCreate, err := client.TSCreate(ctx, "t1").Result()
808 Expect(err).NotTo(HaveOccurred())
809 Expect(resultCreate).To(BeEquivalentTo("OK"))
810 resultCreate, err = client.TSCreate(ctx, "t2").Result()
811 Expect(err).NotTo(HaveOccurred())
812 Expect(resultCreate).To(BeEquivalentTo("OK"))
813 resultRule, err := client.TSCreateRule(ctx, "t1", "t2", redis.Sum, 10).Result()
814 Expect(err).NotTo(HaveOccurred())
815 Expect(resultRule).To(BeEquivalentTo("OK"))
816 _, errAdd := client.TSAdd(ctx, "t1", 1, 1).Result()
817 Expect(errAdd).NotTo(HaveOccurred())
818 _, errAdd = client.TSAdd(ctx, "t1", 2, 3).Result()
819 Expect(errAdd).NotTo(HaveOccurred())
820 _, errAdd = client.TSAdd(ctx, "t1", 11, 7).Result()
821 Expect(errAdd).NotTo(HaveOccurred())
822 _, errAdd = client.TSAdd(ctx, "t1", 13, 1).Result()
823 Expect(errAdd).NotTo(HaveOccurred())
824 resultRange, err := client.TSRange(ctx, "t2", 0, 10).Result()
825 Expect(err).NotTo(HaveOccurred())
826 Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 0, Value: 4}))
827 opt = &redis.TSRevRangeOptions{Latest: true}
828 resultRange, err = client.TSRevRangeWithArgs(ctx, "t2", 0, 10, opt).Result()
829 Expect(err).NotTo(HaveOccurred())
830 Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 10, Value: 8}))
831 resultRange, err = client.TSRevRangeWithArgs(ctx, "t2", 0, 9, opt).Result()
832 Expect(err).NotTo(HaveOccurred())
833 Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 0, Value: 4}))
834
835 resultCreate, err = client.TSCreate(ctx, "t3").Result()
836 Expect(err).NotTo(HaveOccurred())
837 Expect(resultCreate).To(BeEquivalentTo("OK"))
838 _, errAdd = client.TSAdd(ctx, "t3", 15, 1).Result()
839 Expect(errAdd).NotTo(HaveOccurred())
840 _, errAdd = client.TSAdd(ctx, "t3", 17, 4).Result()
841 Expect(errAdd).NotTo(HaveOccurred())
842 _, errAdd = client.TSAdd(ctx, "t3", 51, 3).Result()
843 Expect(errAdd).NotTo(HaveOccurred())
844 _, errAdd = client.TSAdd(ctx, "t3", 73, 5).Result()
845 Expect(errAdd).NotTo(HaveOccurred())
846 _, errAdd = client.TSAdd(ctx, "t3", 75, 3).Result()
847 Expect(errAdd).NotTo(HaveOccurred())
848
849 opt = &redis.TSRevRangeOptions{Aggregator: redis.Max, Align: 0, BucketDuration: 10}
850 resultRange, err = client.TSRevRangeWithArgs(ctx, "t3", 0, 100, opt).Result()
851 Expect(err).NotTo(HaveOccurred())
852 Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 70, Value: 5}))
853 Expect(len(resultRange)).To(BeEquivalentTo(3))
854
855 opt = &redis.TSRevRangeOptions{Aggregator: redis.Max, Align: 0, BucketDuration: 10, BucketTimestamp: "+"}
856 resultRange, err = client.TSRevRangeWithArgs(ctx, "t3", 0, 100, opt).Result()
857 Expect(err).NotTo(HaveOccurred())
858 Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 80, Value: 5}))
859 Expect(len(resultRange)).To(BeEquivalentTo(3))
860
861 _, errAdd = client.TSAdd(ctx, "t4", 15, 1).Result()
862 Expect(errAdd).NotTo(HaveOccurred())
863 _, errAdd = client.TSAdd(ctx, "t4", 17, 4).Result()
864 Expect(errAdd).NotTo(HaveOccurred())
865 _, errAdd = client.TSAdd(ctx, "t4", 51, 3).Result()
866 Expect(errAdd).NotTo(HaveOccurred())
867 _, errAdd = client.TSAdd(ctx, "t4", 73, 5).Result()
868 Expect(errAdd).NotTo(HaveOccurred())
869 _, errAdd = client.TSAdd(ctx, "t4", 75, 3).Result()
870 Expect(errAdd).NotTo(HaveOccurred())
871
872 opt = &redis.TSRevRangeOptions{Aggregator: redis.Max, Align: 0, BucketDuration: 10}
873 resultRange, err = client.TSRevRangeWithArgs(ctx, "t4", 0, 100, opt).Result()
874 Expect(err).NotTo(HaveOccurred())
875 Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 70, Value: 5}))
876 Expect(len(resultRange)).To(BeEquivalentTo(3))
877
878 opt = &redis.TSRevRangeOptions{Aggregator: redis.Max, Align: 0, BucketDuration: 10, Empty: true}
879 resultRange, err = client.TSRevRangeWithArgs(ctx, "t4", 0, 100, opt).Result()
880 Expect(err).NotTo(HaveOccurred())
881 Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 70, Value: 5}))
882 Expect(len(resultRange)).To(BeEquivalentTo(7))
883 })
884
885 It("should TSMRange and TSMRangeWithArgs", Label("timeseries", "tsmrange", "tsmrangeWithArgs"), func() {
886 createOpt := &redis.TSOptions{Labels: map[string]string{"Test": "This", "team": "ny"}}
887 resultCreate, err := client.TSCreateWithArgs(ctx, "a", createOpt).Result()
888 Expect(err).NotTo(HaveOccurred())
889 Expect(resultCreate).To(BeEquivalentTo("OK"))
890 createOpt = &redis.TSOptions{Labels: map[string]string{"Test": "This", "Taste": "That", "team": "sf"}}
891 resultCreate, err = client.TSCreateWithArgs(ctx, "b", createOpt).Result()
892 Expect(err).NotTo(HaveOccurred())
893 Expect(resultCreate).To(BeEquivalentTo("OK"))
894
895 for i := 0; i < 100; i++ {
896 _, err := client.TSAdd(ctx, "a", i, float64(i%7)).Result()
897 Expect(err).NotTo(HaveOccurred())
898 _, err = client.TSAdd(ctx, "b", i, float64(i%11)).Result()
899 Expect(err).NotTo(HaveOccurred())
900 }
901
902 result, err := client.TSMRange(ctx, 0, 200, []string{"Test=This"}).Result()
903 Expect(err).NotTo(HaveOccurred())
904 Expect(len(result)).To(BeEquivalentTo(2))
905 if client.Options().Protocol == 2 {
906 Expect(len(result["a"][1].([]interface{}))).To(BeEquivalentTo(100))
907 } else {
908 Expect(len(result["a"][2].([]interface{}))).To(BeEquivalentTo(100))
909 }
910
911 mrangeOpt := &redis.TSMRangeOptions{Count: 10}
912 result, err = client.TSMRangeWithArgs(ctx, 0, 200, []string{"Test=This"}, mrangeOpt).Result()
913 Expect(err).NotTo(HaveOccurred())
914 if client.Options().Protocol == 2 {
915 Expect(len(result["a"][1].([]interface{}))).To(BeEquivalentTo(10))
916 } else {
917 Expect(len(result["a"][2].([]interface{}))).To(BeEquivalentTo(10))
918 }
919
920 for i := 0; i < 100; i++ {
921 _, err := client.TSAdd(ctx, "a", i+200, float64(i%7)).Result()
922 Expect(err).NotTo(HaveOccurred())
923 }
924 mrangeOpt = &redis.TSMRangeOptions{Aggregator: redis.Avg, BucketDuration: 10}
925 result, err = client.TSMRangeWithArgs(ctx, 0, 500, []string{"Test=This"}, mrangeOpt).Result()
926 Expect(err).NotTo(HaveOccurred())
927 Expect(len(result)).To(BeEquivalentTo(2))
928 if client.Options().Protocol == 2 {
929 Expect(len(result["a"][1].([]interface{}))).To(BeEquivalentTo(20))
930 } else {
931 Expect(len(result["a"][2].([]interface{}))).To(BeEquivalentTo(20))
932 }
933
934 if client.Options().Protocol == 2 {
935 Expect(result["a"][0]).To(BeEquivalentTo([]interface{}{}))
936 } else {
937 Expect(result["a"][0]).To(BeEquivalentTo(map[interface{}]interface{}{}))
938 }
939 mrangeOpt = &redis.TSMRangeOptions{WithLabels: true}
940 result, err = client.TSMRangeWithArgs(ctx, 0, 200, []string{"Test=This"}, mrangeOpt).Result()
941 Expect(err).NotTo(HaveOccurred())
942 if client.Options().Protocol == 2 {
943 Expect(result["a"][0]).To(ConsistOf([]interface{}{[]interface{}{"Test", "This"}, []interface{}{"team", "ny"}}))
944 } else {
945 Expect(result["a"][0]).To(BeEquivalentTo(map[interface{}]interface{}{"Test": "This", "team": "ny"}))
946 }
947
948 mrangeOpt = &redis.TSMRangeOptions{SelectedLabels: []interface{}{"team"}}
949 result, err = client.TSMRangeWithArgs(ctx, 0, 200, []string{"Test=This"}, mrangeOpt).Result()
950 Expect(err).NotTo(HaveOccurred())
951 if client.Options().Protocol == 2 {
952 Expect(result["a"][0].([]interface{})[0]).To(BeEquivalentTo([]interface{}{"team", "ny"}))
953 Expect(result["b"][0].([]interface{})[0]).To(BeEquivalentTo([]interface{}{"team", "sf"}))
954 } else {
955 Expect(result["a"][0]).To(BeEquivalentTo(map[interface{}]interface{}{"team": "ny"}))
956 Expect(result["b"][0]).To(BeEquivalentTo(map[interface{}]interface{}{"team": "sf"}))
957 }
958
959 fts := make([]int, 0)
960 for i := 10; i < 20; i++ {
961 fts = append(fts, i)
962 }
963 mrangeOpt = &redis.TSMRangeOptions{FilterByTS: fts, FilterByValue: []int{1, 2}}
964 result, err = client.TSMRangeWithArgs(ctx, 0, 200, []string{"Test=This"}, mrangeOpt).Result()
965 Expect(err).NotTo(HaveOccurred())
966 if client.Options().Protocol == 2 {
967 Expect(result["a"][1].([]interface{})).To(BeEquivalentTo([]interface{}{[]interface{}{int64(15), "1"}, []interface{}{int64(16), "2"}}))
968 } else {
969 Expect(result["a"][2]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(15), 1.0}, []interface{}{int64(16), 2.0}}))
970 }
971
972 mrangeOpt = &redis.TSMRangeOptions{GroupByLabel: "Test", Reducer: "sum"}
973 result, err = client.TSMRangeWithArgs(ctx, 0, 3, []string{"Test=This"}, mrangeOpt).Result()
974 Expect(err).NotTo(HaveOccurred())
975 if client.Options().Protocol == 2 {
976 Expect(result["Test=This"][1]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(0), "0"}, []interface{}{int64(1), "2"}, []interface{}{int64(2), "4"}, []interface{}{int64(3), "6"}}))
977 } else {
978 Expect(result["Test=This"][3]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(0), 0.0}, []interface{}{int64(1), 2.0}, []interface{}{int64(2), 4.0}, []interface{}{int64(3), 6.0}}))
979 }
980 mrangeOpt = &redis.TSMRangeOptions{GroupByLabel: "Test", Reducer: "max"}
981 result, err = client.TSMRangeWithArgs(ctx, 0, 3, []string{"Test=This"}, mrangeOpt).Result()
982 Expect(err).NotTo(HaveOccurred())
983 if client.Options().Protocol == 2 {
984 Expect(result["Test=This"][1]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(0), "0"}, []interface{}{int64(1), "1"}, []interface{}{int64(2), "2"}, []interface{}{int64(3), "3"}}))
985 } else {
986 Expect(result["Test=This"][3]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(0), 0.0}, []interface{}{int64(1), 1.0}, []interface{}{int64(2), 2.0}, []interface{}{int64(3), 3.0}}))
987 }
988
989 mrangeOpt = &redis.TSMRangeOptions{GroupByLabel: "team", Reducer: "min"}
990 result, err = client.TSMRangeWithArgs(ctx, 0, 3, []string{"Test=This"}, mrangeOpt).Result()
991 Expect(err).NotTo(HaveOccurred())
992 Expect(len(result)).To(BeEquivalentTo(2))
993 if client.Options().Protocol == 2 {
994 Expect(result["team=ny"][1]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(0), "0"}, []interface{}{int64(1), "1"}, []interface{}{int64(2), "2"}, []interface{}{int64(3), "3"}}))
995 Expect(result["team=sf"][1]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(0), "0"}, []interface{}{int64(1), "1"}, []interface{}{int64(2), "2"}, []interface{}{int64(3), "3"}}))
996 } else {
997 Expect(result["team=ny"][3]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(0), 0.0}, []interface{}{int64(1), 1.0}, []interface{}{int64(2), 2.0}, []interface{}{int64(3), 3.0}}))
998 Expect(result["team=sf"][3]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(0), 0.0}, []interface{}{int64(1), 1.0}, []interface{}{int64(2), 2.0}, []interface{}{int64(3), 3.0}}))
999 }
1000
1001 mrangeOpt = &redis.TSMRangeOptions{Aggregator: redis.Count, BucketDuration: 10, Align: "-"}
1002 result, err = client.TSMRangeWithArgs(ctx, 0, 10, []string{"team=ny"}, mrangeOpt).Result()
1003 Expect(err).NotTo(HaveOccurred())
1004 if client.Options().Protocol == 2 {
1005 Expect(result["a"][1]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(0), "10"}, []interface{}{int64(10), "1"}}))
1006 } else {
1007 Expect(result["a"][2]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(0), 10.0}, []interface{}{int64(10), 1.0}}))
1008 }
1009
1010 mrangeOpt = &redis.TSMRangeOptions{Aggregator: redis.Count, BucketDuration: 10, Align: 5}
1011 result, err = client.TSMRangeWithArgs(ctx, 0, 10, []string{"team=ny"}, mrangeOpt).Result()
1012 Expect(err).NotTo(HaveOccurred())
1013 if client.Options().Protocol == 2 {
1014 Expect(result["a"][1]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(0), "5"}, []interface{}{int64(5), "6"}}))
1015 } else {
1016 Expect(result["a"][2]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(0), 5.0}, []interface{}{int64(5), 6.0}}))
1017 }
1018 })
1019
1020 It("should TSMRangeWithArgs Latest", Label("timeseries", "tsmrangeWithArgs", "tsmrangelatest", "NonRedisEnterprise"), func() {
1021 resultCreate, err := client.TSCreate(ctx, "a").Result()
1022 Expect(err).NotTo(HaveOccurred())
1023 Expect(resultCreate).To(BeEquivalentTo("OK"))
1024 opt := &redis.TSOptions{Labels: map[string]string{"is_compaction": "true"}}
1025 resultCreate, err = client.TSCreateWithArgs(ctx, "b", opt).Result()
1026 Expect(err).NotTo(HaveOccurred())
1027 Expect(resultCreate).To(BeEquivalentTo("OK"))
1028
1029 resultCreate, err = client.TSCreate(ctx, "c").Result()
1030 Expect(err).NotTo(HaveOccurred())
1031 Expect(resultCreate).To(BeEquivalentTo("OK"))
1032 opt = &redis.TSOptions{Labels: map[string]string{"is_compaction": "true"}}
1033 resultCreate, err = client.TSCreateWithArgs(ctx, "d", opt).Result()
1034 Expect(err).NotTo(HaveOccurred())
1035 Expect(resultCreate).To(BeEquivalentTo("OK"))
1036
1037 resultCreateRule, err := client.TSCreateRule(ctx, "a", "b", redis.Sum, 10).Result()
1038 Expect(err).NotTo(HaveOccurred())
1039 Expect(resultCreateRule).To(BeEquivalentTo("OK"))
1040 resultCreateRule, err = client.TSCreateRule(ctx, "c", "d", redis.Sum, 10).Result()
1041 Expect(err).NotTo(HaveOccurred())
1042 Expect(resultCreateRule).To(BeEquivalentTo("OK"))
1043
1044 _, err = client.TSAdd(ctx, "a", 1, 1).Result()
1045 Expect(err).NotTo(HaveOccurred())
1046 _, err = client.TSAdd(ctx, "a", 2, 3).Result()
1047 Expect(err).NotTo(HaveOccurred())
1048 _, err = client.TSAdd(ctx, "a", 11, 7).Result()
1049 Expect(err).NotTo(HaveOccurred())
1050 _, err = client.TSAdd(ctx, "a", 13, 1).Result()
1051 Expect(err).NotTo(HaveOccurred())
1052
1053 _, err = client.TSAdd(ctx, "c", 1, 1).Result()
1054 Expect(err).NotTo(HaveOccurred())
1055 _, err = client.TSAdd(ctx, "c", 2, 3).Result()
1056 Expect(err).NotTo(HaveOccurred())
1057 _, err = client.TSAdd(ctx, "c", 11, 7).Result()
1058 Expect(err).NotTo(HaveOccurred())
1059 _, err = client.TSAdd(ctx, "c", 13, 1).Result()
1060 Expect(err).NotTo(HaveOccurred())
1061 mrangeOpt := &redis.TSMRangeOptions{Latest: true}
1062 result, err := client.TSMRangeWithArgs(ctx, 0, 10, []string{"is_compaction=true"}, mrangeOpt).Result()
1063 Expect(err).NotTo(HaveOccurred())
1064 if client.Options().Protocol == 2 {
1065 Expect(result["b"][1]).To(ConsistOf([]interface{}{int64(0), "4"}, []interface{}{int64(10), "8"}))
1066 Expect(result["d"][1]).To(ConsistOf([]interface{}{int64(0), "4"}, []interface{}{int64(10), "8"}))
1067 } else {
1068 Expect(result["b"][2]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(0), 4.0}, []interface{}{int64(10), 8.0}}))
1069 Expect(result["d"][2]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(0), 4.0}, []interface{}{int64(10), 8.0}}))
1070 }
1071 })
1072 It("should TSMRevRange and TSMRevRangeWithArgs", Label("timeseries", "tsmrevrange", "tsmrevrangeWithArgs"), func() {
1073 createOpt := &redis.TSOptions{Labels: map[string]string{"Test": "This", "team": "ny"}}
1074 resultCreate, err := client.TSCreateWithArgs(ctx, "a", createOpt).Result()
1075 Expect(err).NotTo(HaveOccurred())
1076 Expect(resultCreate).To(BeEquivalentTo("OK"))
1077 createOpt = &redis.TSOptions{Labels: map[string]string{"Test": "This", "Taste": "That", "team": "sf"}}
1078 resultCreate, err = client.TSCreateWithArgs(ctx, "b", createOpt).Result()
1079 Expect(err).NotTo(HaveOccurred())
1080 Expect(resultCreate).To(BeEquivalentTo("OK"))
1081
1082 for i := 0; i < 100; i++ {
1083 _, err := client.TSAdd(ctx, "a", i, float64(i%7)).Result()
1084 Expect(err).NotTo(HaveOccurred())
1085 _, err = client.TSAdd(ctx, "b", i, float64(i%11)).Result()
1086 Expect(err).NotTo(HaveOccurred())
1087 }
1088 result, err := client.TSMRevRange(ctx, 0, 200, []string{"Test=This"}).Result()
1089 Expect(err).NotTo(HaveOccurred())
1090 Expect(len(result)).To(BeEquivalentTo(2))
1091 if client.Options().Protocol == 2 {
1092 Expect(len(result["a"][1].([]interface{}))).To(BeEquivalentTo(100))
1093 } else {
1094 Expect(len(result["a"][2].([]interface{}))).To(BeEquivalentTo(100))
1095 }
1096
1097 mrangeOpt := &redis.TSMRevRangeOptions{Count: 10}
1098 result, err = client.TSMRevRangeWithArgs(ctx, 0, 200, []string{"Test=This"}, mrangeOpt).Result()
1099 Expect(err).NotTo(HaveOccurred())
1100 if client.Options().Protocol == 2 {
1101 Expect(len(result["a"][1].([]interface{}))).To(BeEquivalentTo(10))
1102 } else {
1103 Expect(len(result["a"][2].([]interface{}))).To(BeEquivalentTo(10))
1104 }
1105
1106 for i := 0; i < 100; i++ {
1107 _, err := client.TSAdd(ctx, "a", i+200, float64(i%7)).Result()
1108 Expect(err).NotTo(HaveOccurred())
1109 }
1110 mrangeOpt = &redis.TSMRevRangeOptions{Aggregator: redis.Avg, BucketDuration: 10}
1111 result, err = client.TSMRevRangeWithArgs(ctx, 0, 500, []string{"Test=This"}, mrangeOpt).Result()
1112 Expect(err).NotTo(HaveOccurred())
1113 Expect(len(result)).To(BeEquivalentTo(2))
1114 if client.Options().Protocol == 2 {
1115 Expect(len(result["a"][1].([]interface{}))).To(BeEquivalentTo(20))
1116 Expect(result["a"][0]).To(BeEquivalentTo([]interface{}{}))
1117 } else {
1118 Expect(len(result["a"][2].([]interface{}))).To(BeEquivalentTo(20))
1119 Expect(result["a"][0]).To(BeEquivalentTo(map[interface{}]interface{}{}))
1120 }
1121 mrangeOpt = &redis.TSMRevRangeOptions{WithLabels: true}
1122 result, err = client.TSMRevRangeWithArgs(ctx, 0, 200, []string{"Test=This"}, mrangeOpt).Result()
1123 Expect(err).NotTo(HaveOccurred())
1124 if client.Options().Protocol == 2 {
1125 Expect(result["a"][0]).To(ConsistOf([]interface{}{[]interface{}{"Test", "This"}, []interface{}{"team", "ny"}}))
1126 } else {
1127 Expect(result["a"][0]).To(BeEquivalentTo(map[interface{}]interface{}{"Test": "This", "team": "ny"}))
1128 }
1129
1130 mrangeOpt = &redis.TSMRevRangeOptions{SelectedLabels: []interface{}{"team"}}
1131 result, err = client.TSMRevRangeWithArgs(ctx, 0, 200, []string{"Test=This"}, mrangeOpt).Result()
1132 Expect(err).NotTo(HaveOccurred())
1133 if client.Options().Protocol == 2 {
1134 Expect(result["a"][0].([]interface{})[0]).To(BeEquivalentTo([]interface{}{"team", "ny"}))
1135 Expect(result["b"][0].([]interface{})[0]).To(BeEquivalentTo([]interface{}{"team", "sf"}))
1136 } else {
1137 Expect(result["a"][0]).To(BeEquivalentTo(map[interface{}]interface{}{"team": "ny"}))
1138 Expect(result["b"][0]).To(BeEquivalentTo(map[interface{}]interface{}{"team": "sf"}))
1139 }
1140
1141 fts := make([]int, 0)
1142 for i := 10; i < 20; i++ {
1143 fts = append(fts, i)
1144 }
1145 mrangeOpt = &redis.TSMRevRangeOptions{FilterByTS: fts, FilterByValue: []int{1, 2}}
1146 result, err = client.TSMRevRangeWithArgs(ctx, 0, 200, []string{"Test=This"}, mrangeOpt).Result()
1147 Expect(err).NotTo(HaveOccurred())
1148 if client.Options().Protocol == 2 {
1149 Expect(result["a"][1].([]interface{})).To(ConsistOf([]interface{}{int64(16), "2"}, []interface{}{int64(15), "1"}))
1150 } else {
1151 Expect(result["a"][2]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(16), 2.0}, []interface{}{int64(15), 1.0}}))
1152 }
1153
1154 mrangeOpt = &redis.TSMRevRangeOptions{GroupByLabel: "Test", Reducer: "sum"}
1155 result, err = client.TSMRevRangeWithArgs(ctx, 0, 3, []string{"Test=This"}, mrangeOpt).Result()
1156 Expect(err).NotTo(HaveOccurred())
1157 if client.Options().Protocol == 2 {
1158 Expect(result["Test=This"][1]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(3), "6"}, []interface{}{int64(2), "4"}, []interface{}{int64(1), "2"}, []interface{}{int64(0), "0"}}))
1159 } else {
1160 Expect(result["Test=This"][3]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(3), 6.0}, []interface{}{int64(2), 4.0}, []interface{}{int64(1), 2.0}, []interface{}{int64(0), 0.0}}))
1161 }
1162 mrangeOpt = &redis.TSMRevRangeOptions{GroupByLabel: "Test", Reducer: "max"}
1163 result, err = client.TSMRevRangeWithArgs(ctx, 0, 3, []string{"Test=This"}, mrangeOpt).Result()
1164 Expect(err).NotTo(HaveOccurred())
1165 if client.Options().Protocol == 2 {
1166 Expect(result["Test=This"][1]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(3), "3"}, []interface{}{int64(2), "2"}, []interface{}{int64(1), "1"}, []interface{}{int64(0), "0"}}))
1167 } else {
1168 Expect(result["Test=This"][3]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(3), 3.0}, []interface{}{int64(2), 2.0}, []interface{}{int64(1), 1.0}, []interface{}{int64(0), 0.0}}))
1169 }
1170 mrangeOpt = &redis.TSMRevRangeOptions{GroupByLabel: "team", Reducer: "min"}
1171 result, err = client.TSMRevRangeWithArgs(ctx, 0, 3, []string{"Test=This"}, mrangeOpt).Result()
1172 Expect(err).NotTo(HaveOccurred())
1173 Expect(len(result)).To(BeEquivalentTo(2))
1174 if client.Options().Protocol == 2 {
1175 Expect(result["team=ny"][1]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(3), "3"}, []interface{}{int64(2), "2"}, []interface{}{int64(1), "1"}, []interface{}{int64(0), "0"}}))
1176 Expect(result["team=sf"][1]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(3), "3"}, []interface{}{int64(2), "2"}, []interface{}{int64(1), "1"}, []interface{}{int64(0), "0"}}))
1177 } else {
1178 Expect(result["team=ny"][3]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(3), 3.0}, []interface{}{int64(2), 2.0}, []interface{}{int64(1), 1.0}, []interface{}{int64(0), 0.0}}))
1179 Expect(result["team=sf"][3]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(3), 3.0}, []interface{}{int64(2), 2.0}, []interface{}{int64(1), 1.0}, []interface{}{int64(0), 0.0}}))
1180 }
1181
1182 mrangeOpt = &redis.TSMRevRangeOptions{Aggregator: redis.Count, BucketDuration: 10, Align: "-"}
1183 result, err = client.TSMRevRangeWithArgs(ctx, 0, 10, []string{"team=ny"}, mrangeOpt).Result()
1184 Expect(err).NotTo(HaveOccurred())
1185 if client.Options().Protocol == 2 {
1186 Expect(result["a"][1]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(10), "1"}, []interface{}{int64(0), "10"}}))
1187 } else {
1188 Expect(result["a"][2]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(10), 1.0}, []interface{}{int64(0), 10.0}}))
1189 }
1190 mrangeOpt = &redis.TSMRevRangeOptions{Aggregator: redis.Count, BucketDuration: 10, Align: 1}
1191 result, err = client.TSMRevRangeWithArgs(ctx, 0, 10, []string{"team=ny"}, mrangeOpt).Result()
1192 Expect(err).NotTo(HaveOccurred())
1193 if client.Options().Protocol == 2 {
1194 Expect(result["a"][1]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(1), "10"}, []interface{}{int64(0), "1"}}))
1195 } else {
1196 Expect(result["a"][2]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(1), 10.0}, []interface{}{int64(0), 1.0}}))
1197 }
1198 })
1199
1200 It("should TSMRevRangeWithArgs Latest", Label("timeseries", "tsmrevrangeWithArgs", "tsmrevrangelatest", "NonRedisEnterprise"), func() {
1201 resultCreate, err := client.TSCreate(ctx, "a").Result()
1202 Expect(err).NotTo(HaveOccurred())
1203 Expect(resultCreate).To(BeEquivalentTo("OK"))
1204 opt := &redis.TSOptions{Labels: map[string]string{"is_compaction": "true"}}
1205 resultCreate, err = client.TSCreateWithArgs(ctx, "b", opt).Result()
1206 Expect(err).NotTo(HaveOccurred())
1207 Expect(resultCreate).To(BeEquivalentTo("OK"))
1208
1209 resultCreate, err = client.TSCreate(ctx, "c").Result()
1210 Expect(err).NotTo(HaveOccurred())
1211 Expect(resultCreate).To(BeEquivalentTo("OK"))
1212 opt = &redis.TSOptions{Labels: map[string]string{"is_compaction": "true"}}
1213 resultCreate, err = client.TSCreateWithArgs(ctx, "d", opt).Result()
1214 Expect(err).NotTo(HaveOccurred())
1215 Expect(resultCreate).To(BeEquivalentTo("OK"))
1216
1217 resultCreateRule, err := client.TSCreateRule(ctx, "a", "b", redis.Sum, 10).Result()
1218 Expect(err).NotTo(HaveOccurred())
1219 Expect(resultCreateRule).To(BeEquivalentTo("OK"))
1220 resultCreateRule, err = client.TSCreateRule(ctx, "c", "d", redis.Sum, 10).Result()
1221 Expect(err).NotTo(HaveOccurred())
1222 Expect(resultCreateRule).To(BeEquivalentTo("OK"))
1223
1224 _, err = client.TSAdd(ctx, "a", 1, 1).Result()
1225 Expect(err).NotTo(HaveOccurred())
1226 _, err = client.TSAdd(ctx, "a", 2, 3).Result()
1227 Expect(err).NotTo(HaveOccurred())
1228 _, err = client.TSAdd(ctx, "a", 11, 7).Result()
1229 Expect(err).NotTo(HaveOccurred())
1230 _, err = client.TSAdd(ctx, "a", 13, 1).Result()
1231 Expect(err).NotTo(HaveOccurred())
1232
1233 _, err = client.TSAdd(ctx, "c", 1, 1).Result()
1234 Expect(err).NotTo(HaveOccurred())
1235 _, err = client.TSAdd(ctx, "c", 2, 3).Result()
1236 Expect(err).NotTo(HaveOccurred())
1237 _, err = client.TSAdd(ctx, "c", 11, 7).Result()
1238 Expect(err).NotTo(HaveOccurred())
1239 _, err = client.TSAdd(ctx, "c", 13, 1).Result()
1240 Expect(err).NotTo(HaveOccurred())
1241 mrangeOpt := &redis.TSMRevRangeOptions{Latest: true}
1242 result, err := client.TSMRevRangeWithArgs(ctx, 0, 10, []string{"is_compaction=true"}, mrangeOpt).Result()
1243 Expect(err).NotTo(HaveOccurred())
1244 if client.Options().Protocol == 2 {
1245 Expect(result["b"][1]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(10), "8"}, []interface{}{int64(0), "4"}}))
1246 Expect(result["d"][1]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(10), "8"}, []interface{}{int64(0), "4"}}))
1247 } else {
1248 Expect(result["b"][2]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(10), 8.0}, []interface{}{int64(0), 4.0}}))
1249 Expect(result["d"][2]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(10), 8.0}, []interface{}{int64(0), 4.0}}))
1250 }
1251 })
1252 })
1253 }
1254 })
1255
View as plain text