Debian Codegraph @

tsdb/index/tsi1/tag_block_test.go

raw
1 package tsi1_test
2
3 import (
4 "bytes"
5 "fmt"
6 "reflect"
7 "testing"
8
9 "github.com/influxdata/influxdb/tsdb/index/tsi1"
10 )
11
12 // Ensure tag blocks can be written and opened.
13 func TestTagBlockWriter(t *testing.T) {
14 // Write 3 series to writer.
15 var buf bytes.Buffer
16 enc := tsi1.NewTagBlockEncoder(&buf)
17
18 if err := enc.EncodeKey([]byte("host"), false); err != nil {
19 t.Fatal(err)
20 } else if err := enc.EncodeValue([]byte("server0"), false, []uint64{1}); err != nil {
21 t.Fatal(err)
22 } else if err := enc.EncodeValue([]byte("server1"), false, []uint64{2}); err != nil {
23 t.Fatal(err)
24 } else if err := enc.EncodeValue([]byte("server2"), false, []uint64{3}); err != nil {
25 t.Fatal(err)
26 }
27
28 if err := enc.EncodeKey([]byte("region"), false); err != nil {
29 t.Fatal(err)
30 } else if err := enc.EncodeValue([]byte("us-east"), false, []uint64{1, 2}); err != nil {
31 t.Fatal(err)
32 } else if err := enc.EncodeValue([]byte("us-west"), false, []uint64{3}); err != nil {
33 t.Fatal(err)
34 }
35
36 // Flush encoder.
37 if err := enc.Close(); err != nil {
38 t.Fatal(err)
39 } else if int(enc.N()) != buf.Len() {
40 t.Fatalf("bytes written mismatch: %d, expected %d", enc.N(), buf.Len())
41 }
42
43 // Unmarshal into a block.
44 var blk tsi1.TagBlock
45 if err := blk.UnmarshalBinary(buf.Bytes()); err != nil {
46 t.Fatal(err)
47 }
48
49 // Verify data.
50 if e := blk.TagValueElem([]byte("region"), []byte("us-east")); e == nil {
51 t.Fatal("expected element")
52 } else if a, err := e.(*tsi1.TagBlockValueElem).SeriesIDs(); err != nil {
53 t.Fatalf("unexpected error: %v", err)
54 } else if !reflect.DeepEqual(a, []uint64{1, 2}) {
55 t.Fatalf("unexpected series ids: %#v", a)
56 }
57
58 if e := blk.TagValueElem([]byte("region"), []byte("us-west")); e == nil {
59 t.Fatal("expected element")
60 } else if a, err := e.(*tsi1.TagBlockValueElem).SeriesIDs(); err != nil {
61 t.Fatalf("unexpected error: %v", err)
62 } else if !reflect.DeepEqual(a, []uint64{3}) {
63 t.Fatalf("unexpected series ids: %#v", a)
64 }
65 if e := blk.TagValueElem([]byte("host"), []byte("server0")); e == nil {
66 t.Fatal("expected element")
67 } else if a, err := e.(*tsi1.TagBlockValueElem).SeriesIDs(); err != nil {
68 t.Fatalf("unexpected error: %v", err)
69 } else if !reflect.DeepEqual(a, []uint64{1}) {
70 t.Fatalf("unexpected series ids: %#v", a)
71 }
72 if e := blk.TagValueElem([]byte("host"), []byte("server1")); e == nil {
73 t.Fatal("expected element")
74 } else if a, err := e.(*tsi1.TagBlockValueElem).SeriesIDs(); err != nil {
75 t.Fatalf("unexpected error: %v", err)
76 } else if !reflect.DeepEqual(a, []uint64{2}) {
77 t.Fatalf("unexpected series ids: %#v", a)
78 }
79 if e := blk.TagValueElem([]byte("host"), []byte("server2")); e == nil {
80 t.Fatal("expected element")
81 } else if a, err := e.(*tsi1.TagBlockValueElem).SeriesIDs(); err != nil {
82 t.Fatalf("unexpected error: %v", err)
83 } else if !reflect.DeepEqual(a, []uint64{3}) {
84 t.Fatalf("unexpected series ids: %#v", a)
85 }
86 }
87
88 var benchmarkTagBlock10x1000 *tsi1.TagBlock
89 var benchmarkTagBlock100x1000 *tsi1.TagBlock
90 var benchmarkTagBlock1000x1000 *tsi1.TagBlock
91 var benchmarkTagBlock1x1000000 *tsi1.TagBlock
92
93 func BenchmarkTagBlock_SeriesN_10_1000(b *testing.B) {
94 benchmarkTagBlock_SeriesN(b, 10, 1000, &benchmarkTagBlock10x1000)
95 }
96 func BenchmarkTagBlock_SeriesN_100_1000(b *testing.B) {
97 benchmarkTagBlock_SeriesN(b, 100, 1000, &benchmarkTagBlock100x1000)
98 }
99 func BenchmarkTagBlock_SeriesN_1000_1000(b *testing.B) {
100 benchmarkTagBlock_SeriesN(b, 1000, 1000, &benchmarkTagBlock1000x1000)
101 }
102 func BenchmarkTagBlock_SeriesN_1_1000000(b *testing.B) {
103 benchmarkTagBlock_SeriesN(b, 1, 1000000, &benchmarkTagBlock1x1000000)
104 }
105
106 func benchmarkTagBlock_SeriesN(b *testing.B, tagN, valueN int, blk **tsi1.TagBlock) {
107 if (*blk) == nil {
108 var buf bytes.Buffer
109 enc := tsi1.NewTagBlockEncoder(&buf)
110
111 // Write block.
112 for i := 0; i < tagN; i++ {
113 if err := enc.EncodeKey([]byte(fmt.Sprintf("%08d", i)), false); err != nil {
114 b.Fatal(err)
115 }
116
117 for j := 0; j < valueN; j++ {
118 if err := enc.EncodeValue([]byte(fmt.Sprintf("%08d", j)), false, []uint64{1}); err != nil {
119 b.Fatal(err)
120 }
121 }
122 }
123
124 // Flush encoder.
125 if err := enc.Close(); err != nil {
126 b.Fatal(err)
127 }
128 b.Log("size", buf.Len())
129
130 // Unmarshal into a block.
131 *blk = &tsi1.TagBlock{}
132 if err := (*blk).UnmarshalBinary(buf.Bytes()); err != nil {
133 b.Fatal(err)
134 }
135 }
136
137 // Benchmark lookups.
138 b.ReportAllocs()
139 b.ResetTimer()
140
141 key, value := []byte("0"), []byte("0")
142 for i := 0; i < b.N; i++ {
143 if e := (*blk).TagValueElem(key, value); e == nil {
144 b.Fatal("expected element")
145 } else if n := e.(*tsi1.TagBlockValueElem).SeriesN(); n != 1 {
146 b.Fatalf("unexpected series count: %d", n)
147 }
148 }
149 }