/
timeseries_commands_test.go
940 lines (858 loc) · 44.6 KB
/
timeseries_commands_test.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
package redis_test
import (
"context"
"strings"
. "github.com/bsm/ginkgo/v2"
. "github.com/bsm/gomega"
"github.com/redis/go-redis/v9"
)
var _ = Describe("RedisTimeseries commands", Label("timeseries"), func() {
ctx := context.TODO()
var client *redis.Client
BeforeEach(func() {
client = redis.NewClient(&redis.Options{Addr: rediStackAddr})
Expect(client.FlushDB(ctx).Err()).NotTo(HaveOccurred())
})
AfterEach(func() {
Expect(client.Close()).NotTo(HaveOccurred())
})
It("should TSCreate and TSCreateWithArgs", Label("timeseries", "tscreate", "tscreateWithArgs"), func() {
result, err := client.TSCreate(ctx, "1").Result()
Expect(err).NotTo(HaveOccurred())
Expect(result).To(BeEquivalentTo("OK"))
// Test TSCreateWithArgs
opt := &redis.TSOptions{Retention: 5}
result, err = client.TSCreateWithArgs(ctx, "2", opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result).To(BeEquivalentTo("OK"))
opt = &redis.TSOptions{Labels: map[string]string{"Redis": "Labs"}}
result, err = client.TSCreateWithArgs(ctx, "3", opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result).To(BeEquivalentTo("OK"))
opt = &redis.TSOptions{Labels: map[string]string{"Time": "Series"}, Retention: 20}
result, err = client.TSCreateWithArgs(ctx, "4", opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result).To(BeEquivalentTo("OK"))
resultInfo, err := client.TSInfo(ctx, "4").Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultInfo["labels"].(map[interface{}]interface{})["Time"]).To(BeEquivalentTo("Series"))
// Test chunk size
opt = &redis.TSOptions{ChunkSize: 128}
result, err = client.TSCreateWithArgs(ctx, "ts-cs-1", opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result).To(BeEquivalentTo("OK"))
resultInfo, err = client.TSInfo(ctx, "ts-cs-1").Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultInfo["chunkSize"]).To(BeEquivalentTo(128))
// Test duplicate policy
duplicate_policies := []string{"BLOCK", "LAST", "FIRST", "MIN", "MAX"}
for _, dup := range duplicate_policies {
keyName := "ts-dup-" + dup
opt = &redis.TSOptions{DuplicatePolicy: dup}
result, err = client.TSCreateWithArgs(ctx, keyName, opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result).To(BeEquivalentTo("OK"))
resultInfo, err = client.TSInfo(ctx, keyName).Result()
Expect(err).NotTo(HaveOccurred())
Expect(strings.ToUpper(resultInfo["duplicatePolicy"].(string))).To(BeEquivalentTo(dup))
}
})
It("should TSAdd and TSAddWithArgs", Label("timeseries", "tsadd", "tsaddWithArgs"), func() {
result, err := client.TSAdd(ctx, "1", 1, 1).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result).To(BeEquivalentTo(1))
// Test TSAddWithArgs
opt := &redis.TSOptions{Retention: 10}
result, err = client.TSAddWithArgs(ctx, "2", 2, 3, opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result).To(BeEquivalentTo(2))
opt = &redis.TSOptions{Labels: map[string]string{"Redis": "Labs"}}
result, err = client.TSAddWithArgs(ctx, "3", 3, 2, opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result).To(BeEquivalentTo(3))
opt = &redis.TSOptions{Labels: map[string]string{"Redis": "Labs", "Time": "Series"}, Retention: 10}
result, err = client.TSAddWithArgs(ctx, "4", 4, 2, opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result).To(BeEquivalentTo(4))
resultInfo, err := client.TSInfo(ctx, "4").Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultInfo["labels"].(map[interface{}]interface{})["Time"]).To(BeEquivalentTo("Series"))
// Test chunk size
opt = &redis.TSOptions{ChunkSize: 128}
result, err = client.TSAddWithArgs(ctx, "ts-cs-1", 1, 10, opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result).To(BeEquivalentTo(1))
resultInfo, err = client.TSInfo(ctx, "ts-cs-1").Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultInfo["chunkSize"]).To(BeEquivalentTo(128))
// Test duplicate policy
// LAST
opt = &redis.TSOptions{DuplicatePolicy: "LAST"}
result, err = client.TSAddWithArgs(ctx, "tsal-1", 1, 5, opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result).To(BeEquivalentTo(1))
result, err = client.TSAddWithArgs(ctx, "tsal-1", 1, 10, opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result).To(BeEquivalentTo(1))
resultGet, err := client.TSGet(ctx, "tsal-1").Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultGet.Value).To(BeEquivalentTo(10))
// FIRST
opt = &redis.TSOptions{DuplicatePolicy: "FIRST"}
result, err = client.TSAddWithArgs(ctx, "tsaf-1", 1, 5, opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result).To(BeEquivalentTo(1))
result, err = client.TSAddWithArgs(ctx, "tsaf-1", 1, 10, opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result).To(BeEquivalentTo(1))
resultGet, err = client.TSGet(ctx, "tsaf-1").Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultGet.Value).To(BeEquivalentTo(5))
// MAX
opt = &redis.TSOptions{DuplicatePolicy: "MAX"}
result, err = client.TSAddWithArgs(ctx, "tsam-1", 1, 5, opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result).To(BeEquivalentTo(1))
result, err = client.TSAddWithArgs(ctx, "tsam-1", 1, 10, opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result).To(BeEquivalentTo(1))
resultGet, err = client.TSGet(ctx, "tsam-1").Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultGet.Value).To(BeEquivalentTo(10))
// MIN
opt = &redis.TSOptions{DuplicatePolicy: "MIN"}
result, err = client.TSAddWithArgs(ctx, "tsami-1", 1, 5, opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result).To(BeEquivalentTo(1))
result, err = client.TSAddWithArgs(ctx, "tsami-1", 1, 10, opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result).To(BeEquivalentTo(1))
resultGet, err = client.TSGet(ctx, "tsami-1").Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultGet.Value).To(BeEquivalentTo(5))
})
It("should TSAlter", Label("timeseries", "tsalter"), func() {
result, err := client.TSCreate(ctx, "1").Result()
Expect(err).NotTo(HaveOccurred())
Expect(result).To(BeEquivalentTo("OK"))
resultInfo, err := client.TSInfo(ctx, "1").Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultInfo["retentionTime"]).To(BeEquivalentTo(0))
opt := &redis.TSAlterOptions{Retention: 10}
resultAlter, err := client.TSAlter(ctx, "1", opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultAlter).To(BeEquivalentTo("OK"))
resultInfo, err = client.TSInfo(ctx, "1").Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultInfo["retentionTime"]).To(BeEquivalentTo(10))
resultInfo, err = client.TSInfo(ctx, "1").Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultInfo["labels"]).To(BeEquivalentTo(map[interface{}]interface{}{}))
opt = &redis.TSAlterOptions{Labels: map[string]string{"Time": "Series"}}
resultAlter, err = client.TSAlter(ctx, "1", opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultAlter).To(BeEquivalentTo("OK"))
resultInfo, err = client.TSInfo(ctx, "1").Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultInfo["labels"].(map[interface{}]interface{})["Time"]).To(BeEquivalentTo("Series"))
Expect(resultInfo["retentionTime"]).To(BeEquivalentTo(10))
Expect(resultInfo["duplicatePolicy"]).To(BeEquivalentTo(redis.Nil))
opt = &redis.TSAlterOptions{DuplicatePolicy: "min"}
resultAlter, err = client.TSAlter(ctx, "1", opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultAlter).To(BeEquivalentTo("OK"))
resultInfo, err = client.TSInfo(ctx, "1").Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultInfo["duplicatePolicy"]).To(BeEquivalentTo("min"))
})
It("should TSCreateRule and TSDeleteRule", Label("timeseries", "tscreaterule", "tsdeleterule"), func() {
result, err := client.TSCreate(ctx, "1").Result()
Expect(err).NotTo(HaveOccurred())
Expect(result).To(BeEquivalentTo("OK"))
result, err = client.TSCreate(ctx, "2").Result()
Expect(err).NotTo(HaveOccurred())
Expect(result).To(BeEquivalentTo("OK"))
result, err = client.TSCreateRule(ctx, "1", "2", redis.Avg, 100).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result).To(BeEquivalentTo("OK"))
for i := 0; i < 50; i++ {
resultAdd, err := client.TSAdd(ctx, "1", 100+i*2, 1).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultAdd).To(BeEquivalentTo(100 + i*2))
resultAdd, err = client.TSAdd(ctx, "1", 100+i*2+1, 2).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultAdd).To(BeEquivalentTo(100 + i*2 + 1))
}
resultAdd, err := client.TSAdd(ctx, "1", 100*2, 1.5).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultAdd).To(BeEquivalentTo(100 * 2))
resultGet, err := client.TSGet(ctx, "2").Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultGet.Value).To(BeEquivalentTo(1.5))
Expect(resultGet.Timestamp).To(BeEquivalentTo(100))
resultDeleteRule, err := client.TSDeleteRule(ctx, "1", "2").Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultDeleteRule).To(BeEquivalentTo("OK"))
resultInfo, err := client.TSInfo(ctx, "1").Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultInfo["rules"]).To(BeEquivalentTo(map[interface{}]interface{}{}))
})
It("should TSIncrBy, TSIncrByWithArgs, TSDecrBy and TSDecrByWithArgs", Label("timeseries", "tsincrby", "tsdecrby", "tsincrbyWithArgs", "tsdecrbyWithArgs"), func() {
for i := 0; i < 100; i++ {
_, err := client.TSIncrBy(ctx, "1", 1).Result()
Expect(err).NotTo(HaveOccurred())
}
result, err := client.TSGet(ctx, "1").Result()
Expect(err).NotTo(HaveOccurred())
Expect(result.Value).To(BeEquivalentTo(100))
for i := 0; i < 100; i++ {
_, err := client.TSDecrBy(ctx, "1", 1).Result()
Expect(err).NotTo(HaveOccurred())
}
result, err = client.TSGet(ctx, "1").Result()
Expect(err).NotTo(HaveOccurred())
Expect(result.Value).To(BeEquivalentTo(0))
opt := &redis.TSIncrDecrOptions{Timestamp: 5}
_, err = client.TSIncrByWithArgs(ctx, "2", 1.5, opt).Result()
Expect(err).NotTo(HaveOccurred())
result, err = client.TSGet(ctx, "2").Result()
Expect(err).NotTo(HaveOccurred())
Expect(result.Timestamp).To(BeEquivalentTo(5))
Expect(result.Value).To(BeEquivalentTo(1.5))
opt = &redis.TSIncrDecrOptions{Timestamp: 7}
_, err = client.TSIncrByWithArgs(ctx, "2", 2.25, opt).Result()
Expect(err).NotTo(HaveOccurred())
result, err = client.TSGet(ctx, "2").Result()
Expect(err).NotTo(HaveOccurred())
Expect(result.Timestamp).To(BeEquivalentTo(7))
Expect(result.Value).To(BeEquivalentTo(3.75))
opt = &redis.TSIncrDecrOptions{Timestamp: 15}
_, err = client.TSDecrByWithArgs(ctx, "2", 1.5, opt).Result()
Expect(err).NotTo(HaveOccurred())
result, err = client.TSGet(ctx, "2").Result()
Expect(err).NotTo(HaveOccurred())
Expect(result.Timestamp).To(BeEquivalentTo(15))
Expect(result.Value).To(BeEquivalentTo(2.25))
// Test chunk size INCRBY
opt = &redis.TSIncrDecrOptions{ChunkSize: 128}
_, err = client.TSIncrByWithArgs(ctx, "3", 10, opt).Result()
Expect(err).NotTo(HaveOccurred())
resultInfo, err := client.TSInfo(ctx, "3").Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultInfo["chunkSize"]).To(BeEquivalentTo(128))
// Test chunk size DECRBY
opt = &redis.TSIncrDecrOptions{ChunkSize: 128}
_, err = client.TSDecrByWithArgs(ctx, "4", 10, opt).Result()
Expect(err).NotTo(HaveOccurred())
resultInfo, err = client.TSInfo(ctx, "4").Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultInfo["chunkSize"]).To(BeEquivalentTo(128))
})
It("should TSGet", Label("timeseries", "tsget"), func() {
opt := &redis.TSOptions{DuplicatePolicy: "max"}
resultGet, err := client.TSAddWithArgs(ctx, "foo", 2265985, 151, opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultGet).To(BeEquivalentTo(2265985))
result, err := client.TSGet(ctx, "foo").Result()
Expect(err).NotTo(HaveOccurred())
Expect(result.Timestamp).To(BeEquivalentTo(2265985))
Expect(result.Value).To(BeEquivalentTo(151))
})
It("should TSGet Latest", Label("timeseries", "tsgetlatest", "NonRedisEnterprise"), func() {
resultGet, err := client.TSCreate(ctx, "tsgl-1").Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultGet).To(BeEquivalentTo("OK"))
resultGet, err = client.TSCreate(ctx, "tsgl-2").Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultGet).To(BeEquivalentTo("OK"))
resultGet, err = client.TSCreateRule(ctx, "tsgl-1", "tsgl-2", redis.Sum, 10).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultGet).To(BeEquivalentTo("OK"))
_, err = client.TSAdd(ctx, "tsgl-1", 1, 1).Result()
Expect(err).NotTo(HaveOccurred())
_, err = client.TSAdd(ctx, "tsgl-1", 2, 3).Result()
Expect(err).NotTo(HaveOccurred())
_, err = client.TSAdd(ctx, "tsgl-1", 11, 7).Result()
Expect(err).NotTo(HaveOccurred())
_, err = client.TSAdd(ctx, "tsgl-1", 13, 1).Result()
Expect(err).NotTo(HaveOccurred())
result, errGet := client.TSGet(ctx, "tsgl-2").Result()
Expect(errGet).NotTo(HaveOccurred())
Expect(result.Timestamp).To(BeEquivalentTo(0))
Expect(result.Value).To(BeEquivalentTo(4))
result, errGet = client.TSGetWithArgs(ctx, "tsgl-2", &redis.TSGetOptions{Latest: true}).Result()
Expect(errGet).NotTo(HaveOccurred())
Expect(result.Timestamp).To(BeEquivalentTo(10))
Expect(result.Value).To(BeEquivalentTo(8))
})
It("should TSInfo", Label("timeseries", "tsinfo"), func() {
resultGet, err := client.TSAdd(ctx, "foo", 2265985, 151).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultGet).To(BeEquivalentTo(2265985))
result, err := client.TSInfo(ctx, "foo").Result()
Expect(err).NotTo(HaveOccurred())
Expect(result["firstTimestamp"]).To(BeEquivalentTo(2265985))
})
It("should TSMAdd", Label("timeseries", "tsmadd"), func() {
resultGet, err := client.TSCreate(ctx, "a").Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultGet).To(BeEquivalentTo("OK"))
ktvSlices := make([][]interface{}, 3)
for i := 0; i < 3; i++ {
ktvSlices[i] = make([]interface{}, 3)
ktvSlices[i][0] = "a"
for j := 1; j < 3; j++ {
ktvSlices[i][j] = (i + j) * j
}
}
result, err := client.TSMAdd(ctx, ktvSlices).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result).To(BeEquivalentTo([]int64{1, 2, 3}))
})
It("should TSMGet and TSMGetWithArgs", Label("timeseries", "tsmget", "tsmgetWithArgs", "NonRedisEnterprise"), func() {
opt := &redis.TSOptions{Labels: map[string]string{"Test": "This"}}
resultCreate, err := client.TSCreateWithArgs(ctx, "a", opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultCreate).To(BeEquivalentTo("OK"))
opt = &redis.TSOptions{Labels: map[string]string{"Test": "This", "Taste": "That"}}
resultCreate, err = client.TSCreateWithArgs(ctx, "b", opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultCreate).To(BeEquivalentTo("OK"))
_, err = client.TSAdd(ctx, "a", "*", 15).Result()
Expect(err).NotTo(HaveOccurred())
_, err = client.TSAdd(ctx, "b", "*", 25).Result()
Expect(err).NotTo(HaveOccurred())
result, err := client.TSMGet(ctx, []string{"Test=This"}).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result["a"][1].([]interface{})[1]).To(BeEquivalentTo(15))
Expect(result["b"][1].([]interface{})[1]).To(BeEquivalentTo(25))
mgetOpt := &redis.TSMGetOptions{WithLabels: true}
result, err = client.TSMGetWithArgs(ctx, []string{"Test=This"}, mgetOpt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result["b"][0]).To(BeEquivalentTo(map[interface{}]interface{}{"Test": "This", "Taste": "That"}))
resultCreate, err = client.TSCreate(ctx, "c").Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultCreate).To(BeEquivalentTo("OK"))
opt = &redis.TSOptions{Labels: map[string]string{"is_compaction": "true"}}
resultCreate, err = client.TSCreateWithArgs(ctx, "d", opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultCreate).To(BeEquivalentTo("OK"))
resultCreateRule, err := client.TSCreateRule(ctx, "c", "d", redis.Sum, 10).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultCreateRule).To(BeEquivalentTo("OK"))
_, err = client.TSAdd(ctx, "c", 1, 1).Result()
Expect(err).NotTo(HaveOccurred())
_, err = client.TSAdd(ctx, "c", 2, 3).Result()
Expect(err).NotTo(HaveOccurred())
_, err = client.TSAdd(ctx, "c", 11, 7).Result()
Expect(err).NotTo(HaveOccurred())
_, err = client.TSAdd(ctx, "c", 13, 1).Result()
Expect(err).NotTo(HaveOccurred())
result, err = client.TSMGet(ctx, []string{"is_compaction=true"}).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result["d"][1]).To(BeEquivalentTo([]interface{}{int64(0), 4.0}))
mgetOpt = &redis.TSMGetOptions{Latest: true}
result, err = client.TSMGetWithArgs(ctx, []string{"is_compaction=true"}, mgetOpt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result["d"][1]).To(BeEquivalentTo([]interface{}{int64(10), 8.0}))
})
It("should TSQueryIndex", Label("timeseries", "tsqueryindex"), func() {
opt := &redis.TSOptions{Labels: map[string]string{"Test": "This"}}
resultCreate, err := client.TSCreateWithArgs(ctx, "a", opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultCreate).To(BeEquivalentTo("OK"))
opt = &redis.TSOptions{Labels: map[string]string{"Test": "This", "Taste": "That"}}
resultCreate, err = client.TSCreateWithArgs(ctx, "b", opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultCreate).To(BeEquivalentTo("OK"))
result, err := client.TSQueryIndex(ctx, []string{"Test=This"}).Result()
Expect(err).NotTo(HaveOccurred())
Expect(len(result)).To(BeEquivalentTo(2))
result, err = client.TSQueryIndex(ctx, []string{"Taste=That"}).Result()
Expect(err).NotTo(HaveOccurred())
Expect(len(result)).To(BeEquivalentTo(1))
})
It("should TSDel and TSRange", Label("timeseries", "tsdel", "tsrange"), func() {
for i := 0; i < 100; i++ {
_, err := client.TSAdd(ctx, "a", i, float64(i%7)).Result()
Expect(err).NotTo(HaveOccurred())
}
resultDelete, err := client.TSDel(ctx, "a", 0, 21).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultDelete).To(BeEquivalentTo(22))
resultRange, err := client.TSRange(ctx, "a", 0, 21).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultRange).To(BeEquivalentTo([]redis.TSTimestampValue{}))
resultRange, err = client.TSRange(ctx, "a", 22, 22).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 22, Value: 1}))
})
It("should TSRange, TSRangeWithArgs", Label("timeseries", "tsrange", "tsrangeWithArgs", "NonRedisEnterprise"), func() {
for i := 0; i < 100; i++ {
_, err := client.TSAdd(ctx, "a", i, float64(i%7)).Result()
Expect(err).NotTo(HaveOccurred())
}
result, err := client.TSRange(ctx, "a", 0, 200).Result()
Expect(err).NotTo(HaveOccurred())
Expect(len(result)).To(BeEquivalentTo(100))
for i := 0; i < 100; i++ {
client.TSAdd(ctx, "a", i+200, float64(i%7))
}
result, err = client.TSRange(ctx, "a", 0, 500).Result()
Expect(err).NotTo(HaveOccurred())
Expect(len(result)).To(BeEquivalentTo(200))
fts := make([]int, 0)
for i := 10; i < 20; i++ {
fts = append(fts, i)
}
opt := &redis.TSRangeOptions{FilterByTS: fts, FilterByValue: []int{1, 2}}
result, err = client.TSRangeWithArgs(ctx, "a", 0, 500, opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(len(result)).To(BeEquivalentTo(2))
opt = &redis.TSRangeOptions{Aggregator: redis.Count, BucketDuration: 10, Align: "+"}
result, err = client.TSRangeWithArgs(ctx, "a", 0, 10, opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result).To(BeEquivalentTo([]redis.TSTimestampValue{{Timestamp: 0, Value: 10}, {Timestamp: 10, Value: 1}}))
opt = &redis.TSRangeOptions{Aggregator: redis.Count, BucketDuration: 10, Align: "5"}
result, err = client.TSRangeWithArgs(ctx, "a", 0, 10, opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result).To(BeEquivalentTo([]redis.TSTimestampValue{{Timestamp: 0, Value: 5}, {Timestamp: 5, Value: 6}}))
opt = &redis.TSRangeOptions{Aggregator: redis.Twa, BucketDuration: 10}
result, err = client.TSRangeWithArgs(ctx, "a", 0, 10, opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result).To(BeEquivalentTo([]redis.TSTimestampValue{{Timestamp: 0, Value: 2.55}, {Timestamp: 10, Value: 3}}))
// Test Range Latest
resultCreate, err := client.TSCreate(ctx, "t1").Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultCreate).To(BeEquivalentTo("OK"))
resultCreate, err = client.TSCreate(ctx, "t2").Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultCreate).To(BeEquivalentTo("OK"))
resultRule, err := client.TSCreateRule(ctx, "t1", "t2", redis.Sum, 10).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultRule).To(BeEquivalentTo("OK"))
_, errAdd := client.TSAdd(ctx, "t1", 1, 1).Result()
Expect(errAdd).NotTo(HaveOccurred())
_, errAdd = client.TSAdd(ctx, "t1", 2, 3).Result()
Expect(errAdd).NotTo(HaveOccurred())
_, errAdd = client.TSAdd(ctx, "t1", 11, 7).Result()
Expect(errAdd).NotTo(HaveOccurred())
_, errAdd = client.TSAdd(ctx, "t1", 13, 1).Result()
Expect(errAdd).NotTo(HaveOccurred())
resultRange, err := client.TSRange(ctx, "t1", 0, 20).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 1, Value: 1}))
opt = &redis.TSRangeOptions{Latest: true}
resultRange, err = client.TSRangeWithArgs(ctx, "t2", 0, 10, opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 0, Value: 4}))
// Test Bucket Timestamp
resultCreate, err = client.TSCreate(ctx, "t3").Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultCreate).To(BeEquivalentTo("OK"))
_, errAdd = client.TSAdd(ctx, "t3", 15, 1).Result()
Expect(errAdd).NotTo(HaveOccurred())
_, errAdd = client.TSAdd(ctx, "t3", 17, 4).Result()
Expect(errAdd).NotTo(HaveOccurred())
_, errAdd = client.TSAdd(ctx, "t3", 51, 3).Result()
Expect(errAdd).NotTo(HaveOccurred())
_, errAdd = client.TSAdd(ctx, "t3", 73, 5).Result()
Expect(errAdd).NotTo(HaveOccurred())
_, errAdd = client.TSAdd(ctx, "t3", 75, 3).Result()
Expect(errAdd).NotTo(HaveOccurred())
opt = &redis.TSRangeOptions{Aggregator: redis.Max, Align: 0, BucketDuration: 10}
resultRange, err = client.TSRangeWithArgs(ctx, "t3", 0, 100, opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 10, Value: 4}))
Expect(len(resultRange)).To(BeEquivalentTo(3))
opt = &redis.TSRangeOptions{Aggregator: redis.Max, Align: 0, BucketDuration: 10, BucketTimestamp: "+"}
resultRange, err = client.TSRangeWithArgs(ctx, "t3", 0, 100, opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 20, Value: 4}))
Expect(len(resultRange)).To(BeEquivalentTo(3))
// Test Empty
_, errAdd = client.TSAdd(ctx, "t4", 15, 1).Result()
Expect(errAdd).NotTo(HaveOccurred())
_, errAdd = client.TSAdd(ctx, "t4", 17, 4).Result()
Expect(errAdd).NotTo(HaveOccurred())
_, errAdd = client.TSAdd(ctx, "t4", 51, 3).Result()
Expect(errAdd).NotTo(HaveOccurred())
_, errAdd = client.TSAdd(ctx, "t4", 73, 5).Result()
Expect(errAdd).NotTo(HaveOccurred())
_, errAdd = client.TSAdd(ctx, "t4", 75, 3).Result()
Expect(errAdd).NotTo(HaveOccurred())
opt = &redis.TSRangeOptions{Aggregator: redis.Max, Align: 0, BucketDuration: 10}
resultRange, err = client.TSRangeWithArgs(ctx, "t4", 0, 100, opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 10, Value: 4}))
Expect(len(resultRange)).To(BeEquivalentTo(3))
opt = &redis.TSRangeOptions{Aggregator: redis.Max, Align: 0, BucketDuration: 10, Empty: true}
resultRange, err = client.TSRangeWithArgs(ctx, "t4", 0, 100, opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 10, Value: 4}))
Expect(len(resultRange)).To(BeEquivalentTo(7))
})
It("should TSRevRange, TSRevRangeWithArgs", Label("timeseries", "tsrevrange", "tsrevrangeWithArgs", "NonRedisEnterprise"), func() {
for i := 0; i < 100; i++ {
_, err := client.TSAdd(ctx, "a", i, float64(i%7)).Result()
Expect(err).NotTo(HaveOccurred())
}
result, err := client.TSRange(ctx, "a", 0, 200).Result()
Expect(err).NotTo(HaveOccurred())
Expect(len(result)).To(BeEquivalentTo(100))
for i := 0; i < 100; i++ {
client.TSAdd(ctx, "a", i+200, float64(i%7))
}
result, err = client.TSRange(ctx, "a", 0, 500).Result()
Expect(err).NotTo(HaveOccurred())
Expect(len(result)).To(BeEquivalentTo(200))
opt := &redis.TSRevRangeOptions{Aggregator: redis.Avg, BucketDuration: 10}
result, err = client.TSRevRangeWithArgs(ctx, "a", 0, 500, opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(len(result)).To(BeEquivalentTo(20))
opt = &redis.TSRevRangeOptions{Count: 10}
result, err = client.TSRevRangeWithArgs(ctx, "a", 0, 500, opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(len(result)).To(BeEquivalentTo(10))
fts := make([]int, 0)
for i := 10; i < 20; i++ {
fts = append(fts, i)
}
opt = &redis.TSRevRangeOptions{FilterByTS: fts, FilterByValue: []int{1, 2}}
result, err = client.TSRevRangeWithArgs(ctx, "a", 0, 500, opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(len(result)).To(BeEquivalentTo(2))
opt = &redis.TSRevRangeOptions{Aggregator: redis.Count, BucketDuration: 10, Align: "+"}
result, err = client.TSRevRangeWithArgs(ctx, "a", 0, 10, opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result).To(BeEquivalentTo([]redis.TSTimestampValue{{Timestamp: 10, Value: 1}, {Timestamp: 0, Value: 10}}))
opt = &redis.TSRevRangeOptions{Aggregator: redis.Count, BucketDuration: 10, Align: "1"}
result, err = client.TSRevRangeWithArgs(ctx, "a", 0, 10, opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result).To(BeEquivalentTo([]redis.TSTimestampValue{{Timestamp: 1, Value: 10}, {Timestamp: 0, Value: 1}}))
opt = &redis.TSRevRangeOptions{Aggregator: redis.Twa, BucketDuration: 10}
result, err = client.TSRevRangeWithArgs(ctx, "a", 0, 10, opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result).To(BeEquivalentTo([]redis.TSTimestampValue{{Timestamp: 10, Value: 3}, {Timestamp: 0, Value: 2.55}}))
// Test Range Latest
resultCreate, err := client.TSCreate(ctx, "t1").Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultCreate).To(BeEquivalentTo("OK"))
resultCreate, err = client.TSCreate(ctx, "t2").Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultCreate).To(BeEquivalentTo("OK"))
resultRule, err := client.TSCreateRule(ctx, "t1", "t2", redis.Sum, 10).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultRule).To(BeEquivalentTo("OK"))
_, errAdd := client.TSAdd(ctx, "t1", 1, 1).Result()
Expect(errAdd).NotTo(HaveOccurred())
_, errAdd = client.TSAdd(ctx, "t1", 2, 3).Result()
Expect(errAdd).NotTo(HaveOccurred())
_, errAdd = client.TSAdd(ctx, "t1", 11, 7).Result()
Expect(errAdd).NotTo(HaveOccurred())
_, errAdd = client.TSAdd(ctx, "t1", 13, 1).Result()
Expect(errAdd).NotTo(HaveOccurred())
resultRange, err := client.TSRange(ctx, "t2", 0, 10).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 0, Value: 4}))
opt = &redis.TSRevRangeOptions{Latest: true}
resultRange, err = client.TSRevRangeWithArgs(ctx, "t2", 0, 10, opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 10, Value: 8}))
resultRange, err = client.TSRevRangeWithArgs(ctx, "t2", 0, 9, opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 0, Value: 4}))
// Test Bucket Timestamp
resultCreate, err = client.TSCreate(ctx, "t3").Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultCreate).To(BeEquivalentTo("OK"))
_, errAdd = client.TSAdd(ctx, "t3", 15, 1).Result()
Expect(errAdd).NotTo(HaveOccurred())
_, errAdd = client.TSAdd(ctx, "t3", 17, 4).Result()
Expect(errAdd).NotTo(HaveOccurred())
_, errAdd = client.TSAdd(ctx, "t3", 51, 3).Result()
Expect(errAdd).NotTo(HaveOccurred())
_, errAdd = client.TSAdd(ctx, "t3", 73, 5).Result()
Expect(errAdd).NotTo(HaveOccurred())
_, errAdd = client.TSAdd(ctx, "t3", 75, 3).Result()
Expect(errAdd).NotTo(HaveOccurred())
opt = &redis.TSRevRangeOptions{Aggregator: redis.Max, Align: 0, BucketDuration: 10}
resultRange, err = client.TSRevRangeWithArgs(ctx, "t3", 0, 100, opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 70, Value: 5}))
Expect(len(resultRange)).To(BeEquivalentTo(3))
opt = &redis.TSRevRangeOptions{Aggregator: redis.Max, Align: 0, BucketDuration: 10, BucketTimestamp: "+"}
resultRange, err = client.TSRevRangeWithArgs(ctx, "t3", 0, 100, opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 80, Value: 5}))
Expect(len(resultRange)).To(BeEquivalentTo(3))
// Test Empty
_, errAdd = client.TSAdd(ctx, "t4", 15, 1).Result()
Expect(errAdd).NotTo(HaveOccurred())
_, errAdd = client.TSAdd(ctx, "t4", 17, 4).Result()
Expect(errAdd).NotTo(HaveOccurred())
_, errAdd = client.TSAdd(ctx, "t4", 51, 3).Result()
Expect(errAdd).NotTo(HaveOccurred())
_, errAdd = client.TSAdd(ctx, "t4", 73, 5).Result()
Expect(errAdd).NotTo(HaveOccurred())
_, errAdd = client.TSAdd(ctx, "t4", 75, 3).Result()
Expect(errAdd).NotTo(HaveOccurred())
opt = &redis.TSRevRangeOptions{Aggregator: redis.Max, Align: 0, BucketDuration: 10}
resultRange, err = client.TSRevRangeWithArgs(ctx, "t4", 0, 100, opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 70, Value: 5}))
Expect(len(resultRange)).To(BeEquivalentTo(3))
opt = &redis.TSRevRangeOptions{Aggregator: redis.Max, Align: 0, BucketDuration: 10, Empty: true}
resultRange, err = client.TSRevRangeWithArgs(ctx, "t4", 0, 100, opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 70, Value: 5}))
Expect(len(resultRange)).To(BeEquivalentTo(7))
})
It("should TSMRange and TSMRangeWithArgs", Label("timeseries", "tsmrange", "tsmrangeWithArgs"), func() {
createOpt := &redis.TSOptions{Labels: map[string]string{"Test": "This", "team": "ny"}}
resultCreate, err := client.TSCreateWithArgs(ctx, "a", createOpt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultCreate).To(BeEquivalentTo("OK"))
createOpt = &redis.TSOptions{Labels: map[string]string{"Test": "This", "Taste": "That", "team": "sf"}}
resultCreate, err = client.TSCreateWithArgs(ctx, "b", createOpt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultCreate).To(BeEquivalentTo("OK"))
for i := 0; i < 100; i++ {
_, err := client.TSAdd(ctx, "a", i, float64(i%7)).Result()
Expect(err).NotTo(HaveOccurred())
_, err = client.TSAdd(ctx, "b", i, float64(i%11)).Result()
Expect(err).NotTo(HaveOccurred())
}
result, err := client.TSMRange(ctx, 0, 200, []string{"Test=This"}).Result()
Expect(err).NotTo(HaveOccurred())
Expect(len(result)).To(BeEquivalentTo(2))
Expect(len(result["a"][2].([]interface{}))).To(BeEquivalentTo(100))
// Test Count
mrangeOpt := &redis.TSMRangeOptions{Count: 10}
result, err = client.TSMRangeWithArgs(ctx, 0, 200, []string{"Test=This"}, mrangeOpt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(len(result["a"][2].([]interface{}))).To(BeEquivalentTo(10))
// Test Aggregation and BucketDuration
for i := 0; i < 100; i++ {
_, err := client.TSAdd(ctx, "a", i+200, float64(i%7)).Result()
Expect(err).NotTo(HaveOccurred())
}
mrangeOpt = &redis.TSMRangeOptions{Aggregator: redis.Avg, BucketDuration: 10}
result, err = client.TSMRangeWithArgs(ctx, 0, 500, []string{"Test=This"}, mrangeOpt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(len(result)).To(BeEquivalentTo(2))
Expect(len(result["a"][2].([]interface{}))).To(BeEquivalentTo(20))
// Test WithLabels
Expect(result["a"][0]).To(BeEquivalentTo(map[interface{}]interface{}{}))
mrangeOpt = &redis.TSMRangeOptions{WithLabels: true}
result, err = client.TSMRangeWithArgs(ctx, 0, 200, []string{"Test=This"}, mrangeOpt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result["a"][0]).To(BeEquivalentTo(map[interface{}]interface{}{"Test": "This", "team": "ny"}))
// Test SelectedLabels
mrangeOpt = &redis.TSMRangeOptions{SelectedLabels: []interface{}{"team"}}
result, err = client.TSMRangeWithArgs(ctx, 0, 200, []string{"Test=This"}, mrangeOpt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result["a"][0]).To(BeEquivalentTo(map[interface{}]interface{}{"team": "ny"}))
Expect(result["b"][0]).To(BeEquivalentTo(map[interface{}]interface{}{"team": "sf"}))
// Test FilterBy
fts := make([]int, 0)
for i := 10; i < 20; i++ {
fts = append(fts, i)
}
mrangeOpt = &redis.TSMRangeOptions{FilterByTS: fts, FilterByValue: []int{1, 2}}
result, err = client.TSMRangeWithArgs(ctx, 0, 200, []string{"Test=This"}, mrangeOpt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result["a"][2]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(15), 1.0}, []interface{}{int64(16), 2.0}}))
// Test GroupBy
mrangeOpt = &redis.TSMRangeOptions{GroupByLabel: "Test", Reducer: "sum"}
result, err = client.TSMRangeWithArgs(ctx, 0, 3, []string{"Test=This"}, mrangeOpt).Result()
Expect(err).NotTo(HaveOccurred())
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}}))
mrangeOpt = &redis.TSMRangeOptions{GroupByLabel: "Test", Reducer: "max"}
result, err = client.TSMRangeWithArgs(ctx, 0, 3, []string{"Test=This"}, mrangeOpt).Result()
Expect(err).NotTo(HaveOccurred())
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}}))
mrangeOpt = &redis.TSMRangeOptions{GroupByLabel: "team", Reducer: "min"}
result, err = client.TSMRangeWithArgs(ctx, 0, 3, []string{"Test=This"}, mrangeOpt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(len(result)).To(BeEquivalentTo(2))
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}}))
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}}))
// Test Align
mrangeOpt = &redis.TSMRangeOptions{Aggregator: redis.Count, BucketDuration: 10, Align: "-"}
result, err = client.TSMRangeWithArgs(ctx, 0, 10, []string{"team=ny"}, mrangeOpt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result["a"][2]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(0), 10.0}, []interface{}{int64(10), 1.0}}))
mrangeOpt = &redis.TSMRangeOptions{Aggregator: redis.Count, BucketDuration: 10, Align: 5}
result, err = client.TSMRangeWithArgs(ctx, 0, 10, []string{"team=ny"}, mrangeOpt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result["a"][2]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(0), 5.0}, []interface{}{int64(5), 6.0}}))
})
It("should TSMRangeWithArgs Latest", Label("timeseries", "tsmrangeWithArgs", "tsmrangelatest", "NonRedisEnterprise"), func() {
resultCreate, err := client.TSCreate(ctx, "a").Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultCreate).To(BeEquivalentTo("OK"))
opt := &redis.TSOptions{Labels: map[string]string{"is_compaction": "true"}}
resultCreate, err = client.TSCreateWithArgs(ctx, "b", opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultCreate).To(BeEquivalentTo("OK"))
resultCreate, err = client.TSCreate(ctx, "c").Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultCreate).To(BeEquivalentTo("OK"))
opt = &redis.TSOptions{Labels: map[string]string{"is_compaction": "true"}}
resultCreate, err = client.TSCreateWithArgs(ctx, "d", opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultCreate).To(BeEquivalentTo("OK"))
resultCreateRule, err := client.TSCreateRule(ctx, "a", "b", redis.Sum, 10).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultCreateRule).To(BeEquivalentTo("OK"))
resultCreateRule, err = client.TSCreateRule(ctx, "c", "d", redis.Sum, 10).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultCreateRule).To(BeEquivalentTo("OK"))
_, err = client.TSAdd(ctx, "a", 1, 1).Result()
Expect(err).NotTo(HaveOccurred())
_, err = client.TSAdd(ctx, "a", 2, 3).Result()
Expect(err).NotTo(HaveOccurred())
_, err = client.TSAdd(ctx, "a", 11, 7).Result()
Expect(err).NotTo(HaveOccurred())
_, err = client.TSAdd(ctx, "a", 13, 1).Result()
Expect(err).NotTo(HaveOccurred())
_, err = client.TSAdd(ctx, "c", 1, 1).Result()
Expect(err).NotTo(HaveOccurred())
_, err = client.TSAdd(ctx, "c", 2, 3).Result()
Expect(err).NotTo(HaveOccurred())
_, err = client.TSAdd(ctx, "c", 11, 7).Result()
Expect(err).NotTo(HaveOccurred())
_, err = client.TSAdd(ctx, "c", 13, 1).Result()
Expect(err).NotTo(HaveOccurred())
mrangeOpt := &redis.TSMRangeOptions{Latest: true}
result, err := client.TSMRangeWithArgs(ctx, 0, 10, []string{"is_compaction=true"}, mrangeOpt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result["b"][2]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(0), 4.0}, []interface{}{int64(10), 8.0}}))
Expect(result["d"][2]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(0), 4.0}, []interface{}{int64(10), 8.0}}))
})
It("should TSMRevRange and TSMRevRangeWithArgs", Label("timeseries", "tsmrevrange", "tsmrevrangeWithArgs"), func() {
createOpt := &redis.TSOptions{Labels: map[string]string{"Test": "This", "team": "ny"}}
resultCreate, err := client.TSCreateWithArgs(ctx, "a", createOpt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultCreate).To(BeEquivalentTo("OK"))
createOpt = &redis.TSOptions{Labels: map[string]string{"Test": "This", "Taste": "That", "team": "sf"}}
resultCreate, err = client.TSCreateWithArgs(ctx, "b", createOpt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultCreate).To(BeEquivalentTo("OK"))
for i := 0; i < 100; i++ {
_, err := client.TSAdd(ctx, "a", i, float64(i%7)).Result()
Expect(err).NotTo(HaveOccurred())
_, err = client.TSAdd(ctx, "b", i, float64(i%11)).Result()
Expect(err).NotTo(HaveOccurred())
}
result, err := client.TSMRevRange(ctx, 0, 200, []string{"Test=This"}).Result()
Expect(err).NotTo(HaveOccurred())
Expect(len(result)).To(BeEquivalentTo(2))
Expect(len(result["a"][2].([]interface{}))).To(BeEquivalentTo(100))
// Test Count
mrangeOpt := &redis.TSMRevRangeOptions{Count: 10}
result, err = client.TSMRevRangeWithArgs(ctx, 0, 200, []string{"Test=This"}, mrangeOpt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(len(result["a"][2].([]interface{}))).To(BeEquivalentTo(10))
// Test Aggregation and BucketDuration
for i := 0; i < 100; i++ {
_, err := client.TSAdd(ctx, "a", i+200, float64(i%7)).Result()
Expect(err).NotTo(HaveOccurred())
}
mrangeOpt = &redis.TSMRevRangeOptions{Aggregator: redis.Avg, BucketDuration: 10}
result, err = client.TSMRevRangeWithArgs(ctx, 0, 500, []string{"Test=This"}, mrangeOpt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(len(result)).To(BeEquivalentTo(2))
Expect(len(result["a"][2].([]interface{}))).To(BeEquivalentTo(20))
Expect(result["a"][0]).To(BeEquivalentTo(map[interface{}]interface{}{}))
// Test WithLabels
Expect(result["a"][0]).To(BeEquivalentTo(map[interface{}]interface{}{}))
mrangeOpt = &redis.TSMRevRangeOptions{WithLabels: true}
result, err = client.TSMRevRangeWithArgs(ctx, 0, 200, []string{"Test=This"}, mrangeOpt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result["a"][0]).To(BeEquivalentTo(map[interface{}]interface{}{"Test": "This", "team": "ny"}))
// Test SelectedLabels
mrangeOpt = &redis.TSMRevRangeOptions{SelectedLabels: []interface{}{"team"}}
result, err = client.TSMRevRangeWithArgs(ctx, 0, 200, []string{"Test=This"}, mrangeOpt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result["a"][0]).To(BeEquivalentTo(map[interface{}]interface{}{"team": "ny"}))
Expect(result["b"][0]).To(BeEquivalentTo(map[interface{}]interface{}{"team": "sf"}))
// Test FilterBy
fts := make([]int, 0)
for i := 10; i < 20; i++ {
fts = append(fts, i)
}
mrangeOpt = &redis.TSMRevRangeOptions{FilterByTS: fts, FilterByValue: []int{1, 2}}
result, err = client.TSMRevRangeWithArgs(ctx, 0, 200, []string{"Test=This"}, mrangeOpt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result["a"][2]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(16), 2.0}, []interface{}{int64(15), 1.0}}))
// Test GroupBy
mrangeOpt = &redis.TSMRevRangeOptions{GroupByLabel: "Test", Reducer: "sum"}
result, err = client.TSMRevRangeWithArgs(ctx, 0, 3, []string{"Test=This"}, mrangeOpt).Result()
Expect(err).NotTo(HaveOccurred())
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}}))
mrangeOpt = &redis.TSMRevRangeOptions{GroupByLabel: "Test", Reducer: "max"}
result, err = client.TSMRevRangeWithArgs(ctx, 0, 3, []string{"Test=This"}, mrangeOpt).Result()
Expect(err).NotTo(HaveOccurred())
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}}))
mrangeOpt = &redis.TSMRevRangeOptions{GroupByLabel: "team", Reducer: "min"}
result, err = client.TSMRevRangeWithArgs(ctx, 0, 3, []string{"Test=This"}, mrangeOpt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(len(result)).To(BeEquivalentTo(2))
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}}))
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}}))
// Test Align
mrangeOpt = &redis.TSMRevRangeOptions{Aggregator: redis.Count, BucketDuration: 10, Align: "-"}
result, err = client.TSMRevRangeWithArgs(ctx, 0, 10, []string{"team=ny"}, mrangeOpt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result["a"][2]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(10), 1.0}, []interface{}{int64(0), 10.0}}))
mrangeOpt = &redis.TSMRevRangeOptions{Aggregator: redis.Count, BucketDuration: 10, Align: 1}
result, err = client.TSMRevRangeWithArgs(ctx, 0, 10, []string{"team=ny"}, mrangeOpt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result["a"][2]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(1), 10.0}, []interface{}{int64(0), 1.0}}))
})
It("should TSMRevRangeWithArgs Latest", Label("timeseries", "tsmrevrangeWithArgs", "tsmrevrangelatest", "NonRedisEnterprise"), func() {
resultCreate, err := client.TSCreate(ctx, "a").Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultCreate).To(BeEquivalentTo("OK"))
opt := &redis.TSOptions{Labels: map[string]string{"is_compaction": "true"}}
resultCreate, err = client.TSCreateWithArgs(ctx, "b", opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultCreate).To(BeEquivalentTo("OK"))
resultCreate, err = client.TSCreate(ctx, "c").Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultCreate).To(BeEquivalentTo("OK"))
opt = &redis.TSOptions{Labels: map[string]string{"is_compaction": "true"}}
resultCreate, err = client.TSCreateWithArgs(ctx, "d", opt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultCreate).To(BeEquivalentTo("OK"))
resultCreateRule, err := client.TSCreateRule(ctx, "a", "b", redis.Sum, 10).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultCreateRule).To(BeEquivalentTo("OK"))
resultCreateRule, err = client.TSCreateRule(ctx, "c", "d", redis.Sum, 10).Result()
Expect(err).NotTo(HaveOccurred())
Expect(resultCreateRule).To(BeEquivalentTo("OK"))
_, err = client.TSAdd(ctx, "a", 1, 1).Result()
Expect(err).NotTo(HaveOccurred())
_, err = client.TSAdd(ctx, "a", 2, 3).Result()
Expect(err).NotTo(HaveOccurred())
_, err = client.TSAdd(ctx, "a", 11, 7).Result()
Expect(err).NotTo(HaveOccurred())
_, err = client.TSAdd(ctx, "a", 13, 1).Result()
Expect(err).NotTo(HaveOccurred())
_, err = client.TSAdd(ctx, "c", 1, 1).Result()
Expect(err).NotTo(HaveOccurred())
_, err = client.TSAdd(ctx, "c", 2, 3).Result()
Expect(err).NotTo(HaveOccurred())
_, err = client.TSAdd(ctx, "c", 11, 7).Result()
Expect(err).NotTo(HaveOccurred())
_, err = client.TSAdd(ctx, "c", 13, 1).Result()
Expect(err).NotTo(HaveOccurred())
mrangeOpt := &redis.TSMRevRangeOptions{Latest: true}
result, err := client.TSMRevRangeWithArgs(ctx, 0, 10, []string{"is_compaction=true"}, mrangeOpt).Result()
Expect(err).NotTo(HaveOccurred())
Expect(result["b"][2]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(10), 8.0}, []interface{}{int64(0), 4.0}}))
Expect(result["d"][2]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(10), 8.0}, []interface{}{int64(0), 4.0}}))
})
})