Debian Codegraph @

tsdb/index/tsi1/index_file_test.go

raw
1 package tsi1_test
2
3 import (
4 "bytes"
5 "testing"
6
7 "github.com/influxdata/influxdb/models"
8 "github.com/influxdata/influxdb/tsdb"
9 "github.com/influxdata/influxdb/tsdb/index/tsi1"
10 )
11
12 // Ensure a simple index file can be built and opened.
13 func TestCreateIndexFile(t *testing.T) {
14 sfile := MustOpenSeriesFile()
15 defer sfile.Close()
16
17 f, err := CreateIndexFile(sfile.SeriesFile, []Series{
18 {Name: []byte("cpu"), Tags: models.NewTags(map[string]string{"region": "east"})},
19 {Name: []byte("cpu"), Tags: models.NewTags(map[string]string{"region": "west"})},
20 {Name: []byte("mem"), Tags: models.NewTags(map[string]string{"region": "east"})},
21 })
22 if err != nil {
23 t.Fatal(err)
24 }
25
26 if e := f.TagValueElem([]byte("cpu"), []byte("region"), []byte("west")); e == nil {
27 t.Fatal("expected element")
28 } else if n := e.(*tsi1.TagBlockValueElem).SeriesN(); n != 1 {
29 t.Fatalf("unexpected series count: %d", n)
30 }
31 }
32
33 // Ensure index file generation can be successfully built.
34 func TestGenerateIndexFile(t *testing.T) {
35 sfile := MustOpenSeriesFile()
36 defer sfile.Close()
37
38 // Build generated index file.
39 f, err := GenerateIndexFile(sfile.SeriesFile, 10, 3, 4)
40 if err != nil {
41 t.Fatal(err)
42 }
43
44 // Verify that tag/value series can be fetched.
45 if e := f.TagValueElem([]byte("measurement0"), []byte("key0"), []byte("value0")); e == nil {
46 t.Fatal("expected element")
47 } else if n := e.(*tsi1.TagBlockValueElem).SeriesN(); n == 0 {
48 t.Fatal("expected series")
49 }
50 }
51
52 // Ensure a MeasurementHashSeries returns false when all series are tombstoned.
53 func TestIndexFile_MeasurementHasSeries_Tombstoned(t *testing.T) {
54 sfile := MustOpenSeriesFile()
55 defer sfile.Close()
56
57 f, err := CreateIndexFile(sfile.SeriesFile, []Series{
58 {Name: []byte("cpu"), Tags: models.NewTags(map[string]string{"region": "east"})},
59 })
60 if err != nil {
61 t.Fatal(err)
62 }
63
64 // Simulate all series are tombstoned
65 ss := tsdb.NewSeriesIDSet()
66
67 if f.MeasurementHasSeries(ss, []byte("cpu")) {
68 t.Fatalf("MeasurementHasSeries got true, exp false")
69 }
70 }
71
72 func BenchmarkIndexFile_TagValueSeries(b *testing.B) {
73 b.Run("M=1,K=2,V=3", func(b *testing.B) {
74 sfile := MustOpenSeriesFile()
75 defer sfile.Close()
76 benchmarkIndexFile_TagValueSeries(b, MustFindOrGenerateIndexFile(sfile.SeriesFile, 1, 2, 3))
77 })
78 b.Run("M=10,K=5,V=5", func(b *testing.B) {
79 sfile := MustOpenSeriesFile()
80 defer sfile.Close()
81 benchmarkIndexFile_TagValueSeries(b, MustFindOrGenerateIndexFile(sfile.SeriesFile, 10, 5, 5))
82 })
83 b.Run("M=10,K=7,V=5", func(b *testing.B) {
84 sfile := MustOpenSeriesFile()
85 defer sfile.Close()
86 benchmarkIndexFile_TagValueSeries(b, MustFindOrGenerateIndexFile(sfile.SeriesFile, 10, 7, 7))
87 })
88 }
89
90 func benchmarkIndexFile_TagValueSeries(b *testing.B, idx *tsi1.IndexFile) {
91 b.ResetTimer()
92 b.ReportAllocs()
93
94 for i := 0; i < b.N; i++ {
95 if e := idx.TagValueElem([]byte("measurement0"), []byte("key0"), []byte("value0")); e == nil {
96 b.Fatal("expected element")
97 } else if e.(*tsi1.TagBlockValueElem).SeriesN() == 0 {
98 b.Fatal("expected series")
99 }
100 }
101 }
102
103 // CreateIndexFile creates an index file with a given set of series.
104 func CreateIndexFile(sfile *tsdb.SeriesFile, series []Series) (*tsi1.IndexFile, error) {
105 lf, err := CreateLogFile(sfile, series)
106 if err != nil {
107 return nil, err
108 }
109
110 // Write index file to buffer.
111 var buf bytes.Buffer
112 if _, err := lf.CompactTo(&buf, M, K, nil); err != nil {
113 return nil, err
114 }
115
116 // Load index file from buffer.
117 f := tsi1.NewIndexFile(sfile)
118 if err := f.UnmarshalBinary(buf.Bytes()); err != nil {
119 return nil, err
120 }
121 return f, nil
122 }
123
124 // GenerateIndexFile generates an index file from a set of series based on the count arguments.
125 // Total series returned will equal measurementN * tagN * valueN.
126 func GenerateIndexFile(sfile *tsdb.SeriesFile, measurementN, tagN, valueN int) (*tsi1.IndexFile, error) {
127 // Generate a new log file first.
128 lf, err := GenerateLogFile(sfile, measurementN, tagN, valueN)
129 if err != nil {
130 return nil, err
131 }
132
133 // Compact log file to buffer.
134 var buf bytes.Buffer
135 if _, err := lf.CompactTo(&buf, M, K, nil); err != nil {
136 return nil, err
137 }
138
139 // Load index file from buffer.
140 f := tsi1.NewIndexFile(sfile)
141 if err := f.UnmarshalBinary(buf.Bytes()); err != nil {
142 return nil, err
143 }
144 return f, nil
145 }
146
147 func MustGenerateIndexFile(sfile *tsdb.SeriesFile, measurementN, tagN, valueN int) *tsi1.IndexFile {
148 f, err := GenerateIndexFile(sfile, measurementN, tagN, valueN)
149 if err != nil {
150 panic(err)
151 }
152 return f
153 }
154
155 var indexFileCache struct {
156 MeasurementN int
157 TagN int
158 ValueN int
159
160 IndexFile *tsi1.IndexFile
161 }
162
163 // MustFindOrGenerateIndexFile returns a cached index file or generates one if it doesn't exist.
164 func MustFindOrGenerateIndexFile(sfile *tsdb.SeriesFile, measurementN, tagN, valueN int) *tsi1.IndexFile {
165 // Use cache if fields match and the index file has been generated.
166 if indexFileCache.MeasurementN == measurementN &&
167 indexFileCache.TagN == tagN &&
168 indexFileCache.ValueN == valueN &&
169 indexFileCache.IndexFile != nil {
170 return indexFileCache.IndexFile
171 }
172
173 // Generate and cache.
174 indexFileCache.MeasurementN = measurementN
175 indexFileCache.TagN = tagN
176 indexFileCache.ValueN = valueN
177 indexFileCache.IndexFile = MustGenerateIndexFile(sfile, measurementN, tagN, valueN)
178 return indexFileCache.IndexFile
179 }
180
181 func pow(x, y int) int {
182 r := 1
183 for i := 0; i < y; i++ {
184 r *= x
185 }
186 return r
187 }