From 28dca34f4ff257ec74121736ab29a600424d0dce Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gy=C3=B6rgy=20Krajcsovits?= Date: Wed, 14 Jan 2026 09:55:45 +0100 Subject: [PATCH] auto update head sample use in tests MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit find . -name "*.go" -type f -exec sed -E -i \ 's/([^[:alpha:]]sample\{)([^,{:]+,[^,]+,[^,]+,[^,]+\})/\10, \2/g' {} + I've omitted tsdb/ooo_head.go from the commit because I'm also adding todo there. Signed-off-by: György Krajcsovits --- tsdb/block_test.go | 16 +- tsdb/db_append_v2_test.go | 16 +- tsdb/db_test.go | 36 +- tsdb/head_append_v2_test.go | 22 +- tsdb/head_test.go | 22 +- tsdb/querier_test.go | 722 ++++++++++++++++++------------------ 6 files changed, 417 insertions(+), 417 deletions(-) diff --git a/tsdb/block_test.go b/tsdb/block_test.go index 855fa5638a..edd2df7415 100644 --- a/tsdb/block_test.go +++ b/tsdb/block_test.go @@ -176,7 +176,7 @@ func TestCorruptedChunk(t *testing.T) { t.Run(tc.name, func(t *testing.T) { tmpdir := t.TempDir() - series := storage.NewListSeries(labels.FromStrings("a", "b"), []chunks.Sample{sample{1, 1, nil, nil}}) + series := storage.NewListSeries(labels.FromStrings("a", "b"), []chunks.Sample{sample{0, 1, 1, nil, nil}}) blockDir := createBlock(t, tmpdir, []storage.Series{series}) files, err := sequenceFiles(chunkDir(blockDir)) require.NoError(t, err) @@ -236,7 +236,7 @@ func TestLabelValuesWithMatchers(t *testing.T) { seriesEntries = append(seriesEntries, storage.NewListSeries(labels.FromStrings( "tens", fmt.Sprintf("value%d", i/10), "unique", fmt.Sprintf("value%d", i), - ), []chunks.Sample{sample{100, 0, nil, nil}})) + ), []chunks.Sample{sample{0, 100, 0, nil, nil}})) } blockDir := createBlock(t, tmpdir, seriesEntries) @@ -319,7 +319,7 @@ func TestBlockQuerierReturnsSortedLabelValues(t *testing.T) { for i := 100; i > 0; i-- { seriesEntries = append(seriesEntries, storage.NewListSeries(labels.FromStrings( "__name__", fmt.Sprintf("value%d", i), - ), []chunks.Sample{sample{100, 0, nil, nil}})) + ), []chunks.Sample{sample{0, 100, 0, nil, nil}})) } blockDir := createBlock(t, tmpdir, seriesEntries) @@ -436,7 +436,7 @@ func BenchmarkLabelValuesWithMatchers(b *testing.B) { "a_unique", fmt.Sprintf("value%d", i), "b_tens", fmt.Sprintf("value%d", i/(metricCount/10)), "c_ninety", fmt.Sprintf("value%d", i/(metricCount/10)/9), // "0" for the first 90%, then "1" - ), []chunks.Sample{sample{100, 0, nil, nil}})) + ), []chunks.Sample{sample{0, 100, 0, nil, nil}})) } blockDir := createBlock(b, tmpdir, seriesEntries) @@ -472,13 +472,13 @@ func TestLabelNamesWithMatchers(t *testing.T) { for i := range 100 { seriesEntries = append(seriesEntries, storage.NewListSeries(labels.FromStrings( "unique", fmt.Sprintf("value%d", i), - ), []chunks.Sample{sample{100, 0, nil, nil}})) + ), []chunks.Sample{sample{0, 100, 0, nil, nil}})) if i%10 == 0 { seriesEntries = append(seriesEntries, storage.NewListSeries(labels.FromStrings( "tens", fmt.Sprintf("value%d", i/10), "unique", fmt.Sprintf("value%d", i), - ), []chunks.Sample{sample{100, 0, nil, nil}})) + ), []chunks.Sample{sample{0, 100, 0, nil, nil}})) } if i%20 == 0 { @@ -486,7 +486,7 @@ func TestLabelNamesWithMatchers(t *testing.T) { "tens", fmt.Sprintf("value%d", i/10), "twenties", fmt.Sprintf("value%d", i/20), "unique", fmt.Sprintf("value%d", i), - ), []chunks.Sample{sample{100, 0, nil, nil}})) + ), []chunks.Sample{sample{0, 100, 0, nil, nil}})) } } @@ -542,7 +542,7 @@ func TestBlockIndexReader_PostingsForLabelMatching(t *testing.T) { testPostingsForLabelMatching(t, 2, func(t *testing.T, series []labels.Labels) IndexReader { var seriesEntries []storage.Series for _, s := range series { - seriesEntries = append(seriesEntries, storage.NewListSeries(s, []chunks.Sample{sample{100, 0, nil, nil}})) + seriesEntries = append(seriesEntries, storage.NewListSeries(s, []chunks.Sample{sample{0, 100, 0, nil, nil}})) } blockDir := createBlock(t, t.TempDir(), seriesEntries) diff --git a/tsdb/db_append_v2_test.go b/tsdb/db_append_v2_test.go index 344b1d6943..16134e8c93 100644 --- a/tsdb/db_append_v2_test.go +++ b/tsdb/db_append_v2_test.go @@ -372,7 +372,7 @@ func TestDeleteSimple_AppendV2(t *testing.T) { expSamples := make([]chunks.Sample, 0, len(c.remaint)) for _, ts := range c.remaint { - expSamples = append(expSamples, sample{ts, smpls[ts], nil, nil}) + expSamples = append(expSamples, sample{0, ts, smpls[ts], nil, nil}) } expss := newMockSeriesSet([]storage.Series{ @@ -507,7 +507,7 @@ func TestSkippingInvalidValuesInSameTxn_AppendV2(t *testing.T) { ssMap := query(t, q, labels.MustNewMatcher(labels.MatchEqual, "a", "b")) require.Equal(t, map[string][]chunks.Sample{ - labels.New(labels.Label{Name: "a", Value: "b"}).String(): {sample{0, 1, nil, nil}}, + labels.New(labels.Label{Name: "a", Value: "b"}).String(): {sample{0, 0, 1, nil, nil}}, }, ssMap) // Append Out of Order Value. @@ -524,7 +524,7 @@ func TestSkippingInvalidValuesInSameTxn_AppendV2(t *testing.T) { ssMap = query(t, q, labels.MustNewMatcher(labels.MatchEqual, "a", "b")) require.Equal(t, map[string][]chunks.Sample{ - labels.New(labels.Label{Name: "a", Value: "b"}).String(): {sample{0, 1, nil, nil}, sample{10, 3, nil, nil}}, + labels.New(labels.Label{Name: "a", Value: "b"}).String(): {sample{0, 0, 1, nil, nil}, sample{0, 10, 3, nil, nil}}, }, ssMap) } @@ -669,7 +669,7 @@ func TestDB_SnapshotWithDelete_AppendV2(t *testing.T) { expSamples := make([]chunks.Sample, 0, len(c.remaint)) for _, ts := range c.remaint { - expSamples = append(expSamples, sample{ts, smpls[ts], nil, nil}) + expSamples = append(expSamples, sample{0, ts, smpls[ts], nil, nil}) } expss := newMockSeriesSet([]storage.Series{ @@ -772,7 +772,7 @@ func TestDB_e2e_AppendV2(t *testing.T) { for range numDatapoints { v := rand.Float64() - series = append(series, sample{ts, v, nil, nil}) + series = append(series, sample{0, ts, v, nil, nil}) _, err := app.Append(0, lset, 0, ts, v, nil, nil, storage.AOptions{}) require.NoError(t, err) @@ -1094,7 +1094,7 @@ func TestTombstoneClean_AppendV2(t *testing.T) { expSamples := make([]chunks.Sample, 0, len(c.remaint)) for _, ts := range c.remaint { - expSamples = append(expSamples, sample{ts, smpls[ts], nil, nil}) + expSamples = append(expSamples, sample{0, ts, smpls[ts], nil, nil}) } expss := newMockSeriesSet([]storage.Series{ @@ -2310,7 +2310,7 @@ func TestCompactHead_AppendV2(t *testing.T) { val := rand.Float64() _, err := app.Append(0, labels.FromStrings("a", "b"), 0, int64(i), val, nil, nil, storage.AOptions{}) require.NoError(t, err) - expSamples = append(expSamples, sample{int64(i), val, nil, nil}) + expSamples = append(expSamples, sample{0, int64(i), val, nil, nil}) } require.NoError(t, app.Commit()) @@ -2337,7 +2337,7 @@ func TestCompactHead_AppendV2(t *testing.T) { series = seriesSet.At().Iterator(series) for series.Next() == chunkenc.ValFloat { time, val := series.At() - actSamples = append(actSamples, sample{time, val, nil, nil}) + actSamples = append(actSamples, sample{0, time, val, nil, nil}) } require.NoError(t, series.Err()) } diff --git a/tsdb/db_test.go b/tsdb/db_test.go index 299ade8826..5e57982b5d 100644 --- a/tsdb/db_test.go +++ b/tsdb/db_test.go @@ -546,7 +546,7 @@ func TestDeleteSimple(t *testing.T) { expSamples := make([]chunks.Sample, 0, len(c.remaint)) for _, ts := range c.remaint { - expSamples = append(expSamples, sample{ts, smpls[ts], nil, nil}) + expSamples = append(expSamples, sample{0, ts, smpls[ts], nil, nil}) } expss := newMockSeriesSet([]storage.Series{ @@ -691,7 +691,7 @@ func TestSkippingInvalidValuesInSameTxn(t *testing.T) { ssMap := query(t, q, labels.MustNewMatcher(labels.MatchEqual, "a", "b")) require.Equal(t, map[string][]chunks.Sample{ - labels.New(labels.Label{Name: "a", Value: "b"}).String(): {sample{0, 1, nil, nil}}, + labels.New(labels.Label{Name: "a", Value: "b"}).String(): {sample{0, 0, 1, nil, nil}}, }, ssMap) // Append Out of Order Value. @@ -708,7 +708,7 @@ func TestSkippingInvalidValuesInSameTxn(t *testing.T) { ssMap = query(t, q, labels.MustNewMatcher(labels.MatchEqual, "a", "b")) require.Equal(t, map[string][]chunks.Sample{ - labels.New(labels.Label{Name: "a", Value: "b"}).String(): {sample{0, 1, nil, nil}, sample{10, 3, nil, nil}}, + labels.New(labels.Label{Name: "a", Value: "b"}).String(): {sample{0, 0, 1, nil, nil}, sample{0, 10, 3, nil, nil}}, }, ssMap) } @@ -853,7 +853,7 @@ func TestDB_SnapshotWithDelete(t *testing.T) { expSamples := make([]chunks.Sample, 0, len(c.remaint)) for _, ts := range c.remaint { - expSamples = append(expSamples, sample{ts, smpls[ts], nil, nil}) + expSamples = append(expSamples, sample{0, ts, smpls[ts], nil, nil}) } expss := newMockSeriesSet([]storage.Series{ @@ -956,7 +956,7 @@ func TestDB_e2e(t *testing.T) { for range numDatapoints { v := rand.Float64() - series = append(series, sample{ts, v, nil, nil}) + series = append(series, sample{0, ts, v, nil, nil}) _, err := app.Append(0, lset, ts, v) require.NoError(t, err) @@ -1278,7 +1278,7 @@ func TestTombstoneClean(t *testing.T) { expSamples := make([]chunks.Sample, 0, len(c.remaint)) for _, ts := range c.remaint { - expSamples = append(expSamples, sample{ts, smpls[ts], nil, nil}) + expSamples = append(expSamples, sample{0, ts, smpls[ts], nil, nil}) } expss := newMockSeriesSet([]storage.Series{ @@ -2863,11 +2863,11 @@ func assureChunkFromSamples(t *testing.T, samples []chunks.Sample) chunks.Meta { // TestChunkWriter_ReadAfterWrite ensures that chunk segment are cut at the set segment size and // that the resulted segments includes the expected chunks data. func TestChunkWriter_ReadAfterWrite(t *testing.T) { - chk1 := assureChunkFromSamples(t, []chunks.Sample{sample{1, 1, nil, nil}}) - chk2 := assureChunkFromSamples(t, []chunks.Sample{sample{1, 2, nil, nil}}) - chk3 := assureChunkFromSamples(t, []chunks.Sample{sample{1, 3, nil, nil}}) - chk4 := assureChunkFromSamples(t, []chunks.Sample{sample{1, 4, nil, nil}}) - chk5 := assureChunkFromSamples(t, []chunks.Sample{sample{1, 5, nil, nil}}) + chk1 := assureChunkFromSamples(t, []chunks.Sample{sample{0, 1, 1, nil, nil}}) + chk2 := assureChunkFromSamples(t, []chunks.Sample{sample{0, 1, 2, nil, nil}}) + chk3 := assureChunkFromSamples(t, []chunks.Sample{sample{0, 1, 3, nil, nil}}) + chk4 := assureChunkFromSamples(t, []chunks.Sample{sample{0, 1, 4, nil, nil}}) + chk5 := assureChunkFromSamples(t, []chunks.Sample{sample{0, 1, 5, nil, nil}}) chunkSize := len(chk1.Chunk.Bytes()) + chunks.MaxChunkLengthFieldSize + chunks.ChunkEncodingSize + crc32.Size tests := []struct { @@ -3069,11 +3069,11 @@ func TestRangeForTimestamp(t *testing.T) { func TestChunkReader_ConcurrentReads(t *testing.T) { t.Parallel() chks := []chunks.Meta{ - assureChunkFromSamples(t, []chunks.Sample{sample{1, 1, nil, nil}}), - assureChunkFromSamples(t, []chunks.Sample{sample{1, 2, nil, nil}}), - assureChunkFromSamples(t, []chunks.Sample{sample{1, 3, nil, nil}}), - assureChunkFromSamples(t, []chunks.Sample{sample{1, 4, nil, nil}}), - assureChunkFromSamples(t, []chunks.Sample{sample{1, 5, nil, nil}}), + assureChunkFromSamples(t, []chunks.Sample{sample{0, 1, 1, nil, nil}}), + assureChunkFromSamples(t, []chunks.Sample{sample{0, 1, 2, nil, nil}}), + assureChunkFromSamples(t, []chunks.Sample{sample{0, 1, 3, nil, nil}}), + assureChunkFromSamples(t, []chunks.Sample{sample{0, 1, 4, nil, nil}}), + assureChunkFromSamples(t, []chunks.Sample{sample{0, 1, 5, nil, nil}}), } tempDir := t.TempDir() @@ -3133,7 +3133,7 @@ func TestCompactHead(t *testing.T) { val := rand.Float64() _, err := app.Append(0, labels.FromStrings("a", "b"), int64(i), val) require.NoError(t, err) - expSamples = append(expSamples, sample{int64(i), val, nil, nil}) + expSamples = append(expSamples, sample{0, int64(i), val, nil, nil}) } require.NoError(t, app.Commit()) @@ -3160,7 +3160,7 @@ func TestCompactHead(t *testing.T) { series = seriesSet.At().Iterator(series) for series.Next() == chunkenc.ValFloat { time, val := series.At() - actSamples = append(actSamples, sample{time, val, nil, nil}) + actSamples = append(actSamples, sample{0, time, val, nil, nil}) } require.NoError(t, series.Err()) } diff --git a/tsdb/head_append_v2_test.go b/tsdb/head_append_v2_test.go index 33bc3aec38..892a5b3bfe 100644 --- a/tsdb/head_append_v2_test.go +++ b/tsdb/head_append_v2_test.go @@ -312,8 +312,8 @@ func TestHeadAppenderV2_WALMultiRef(t *testing.T) { // The samples before the new ref should be discarded since Head truncation // happens only after compacting the Head. require.Equal(t, map[string][]chunks.Sample{`{foo="bar"}`: { - sample{1700, 3, nil, nil}, - sample{2000, 4, nil, nil}, + sample{0, 1700, 3, nil, nil}, + sample{0, 2000, 4, nil, nil}, }}, series) } @@ -605,7 +605,7 @@ func TestHeadAppenderV2_DeleteUntilCurrMax(t *testing.T) { it = exps.Iterator(nil) resSamples, err := storage.ExpandSamples(it, newSample) require.NoError(t, err) - require.Equal(t, []chunks.Sample{sample{11, 1, nil, nil}}, resSamples) + require.Equal(t, []chunks.Sample{sample{0, 11, 1, nil, nil}}, resSamples) for res.Next() { } require.NoError(t, res.Err()) @@ -722,7 +722,7 @@ func TestHeadAppenderV2_Delete_e2e(t *testing.T) { v := rand.Float64() _, err := app.Append(0, ls, 0, ts, v, nil, nil, storage.AOptions{}) require.NoError(t, err) - series = append(series, sample{ts, v, nil, nil}) + series = append(series, sample{0, ts, v, nil, nil}) ts += rand.Int63n(timeInterval) + 1 } seriesMap[labels.New(l...).String()] = series @@ -1520,7 +1520,7 @@ func TestDataMissingOnQueryDuringCompaction_AppenderV2(t *testing.T) { ref, err = app.Append(ref, labels.FromStrings("a", "b"), 0, ts, float64(i), nil, nil, storage.AOptions{}) require.NoError(t, err) maxt = ts - expSamples = append(expSamples, sample{ts, float64(i), nil, nil}) + expSamples = append(expSamples, sample{0, ts, float64(i), nil, nil}) } require.NoError(t, app.Commit()) @@ -2166,17 +2166,17 @@ func TestChunkSnapshot_AppenderV2(t *testing.T) { aOpts.Exemplars = []exemplar.Exemplar{newExemplar(lbls, ts)} } val := rand.Float64() - expSeries[lblStr] = append(expSeries[lblStr], sample{ts, val, nil, nil}) + expSeries[lblStr] = append(expSeries[lblStr], sample{0, ts, val, nil, nil}) _, err := app.Append(0, lbls, 0, ts, val, nil, nil, aOpts) require.NoError(t, err) hist := histograms[int(ts)] - expHist[lblsHistStr] = append(expHist[lblsHistStr], sample{ts, 0, hist, nil}) + expHist[lblsHistStr] = append(expHist[lblsHistStr], sample{0, ts, 0, hist, nil}) _, err = app.Append(0, lblsHist, 0, ts, 0, hist, nil, storage.AOptions{}) require.NoError(t, err) floatHist := floatHistogram[int(ts)] - expFloatHist[lblsFloatHistStr] = append(expFloatHist[lblsFloatHistStr], sample{ts, 0, nil, floatHist}) + expFloatHist[lblsFloatHistStr] = append(expFloatHist[lblsFloatHistStr], sample{0, ts, 0, nil, floatHist}) _, err = app.Append(0, lblsFloatHist, 0, ts, 0, nil, floatHist, storage.AOptions{}) require.NoError(t, err) @@ -2244,17 +2244,17 @@ func TestChunkSnapshot_AppenderV2(t *testing.T) { aOpts.Exemplars = []exemplar.Exemplar{newExemplar(lbls, ts)} } val := rand.Float64() - expSeries[lblStr] = append(expSeries[lblStr], sample{ts, val, nil, nil}) + expSeries[lblStr] = append(expSeries[lblStr], sample{0, ts, val, nil, nil}) _, err := app.Append(0, lbls, 0, ts, val, nil, nil, aOpts) require.NoError(t, err) hist := histograms[int(ts)] - expHist[lblsHistStr] = append(expHist[lblsHistStr], sample{ts, 0, hist, nil}) + expHist[lblsHistStr] = append(expHist[lblsHistStr], sample{0, ts, 0, hist, nil}) _, err = app.Append(0, lblsHist, 0, ts, 0, hist, nil, storage.AOptions{}) require.NoError(t, err) floatHist := floatHistogram[int(ts)] - expFloatHist[lblsFloatHistStr] = append(expFloatHist[lblsFloatHistStr], sample{ts, 0, nil, floatHist}) + expFloatHist[lblsFloatHistStr] = append(expFloatHist[lblsFloatHistStr], sample{0, ts, 0, nil, floatHist}) _, err = app.Append(0, lblsFloatHist, 0, ts, 0, nil, floatHist, storage.AOptions{}) require.NoError(t, err) diff --git a/tsdb/head_test.go b/tsdb/head_test.go index acdf0ee000..d0928d64bf 100644 --- a/tsdb/head_test.go +++ b/tsdb/head_test.go @@ -841,8 +841,8 @@ func TestHead_WALMultiRef(t *testing.T) { // The samples before the new ref should be discarded since Head truncation // happens only after compacting the Head. require.Equal(t, map[string][]chunks.Sample{`{foo="bar"}`: { - sample{1700, 3, nil, nil}, - sample{2000, 4, nil, nil}, + sample{0, 1700, 3, nil, nil}, + sample{0, 2000, 4, nil, nil}, }}, series) } @@ -1859,7 +1859,7 @@ func TestDeleteUntilCurMax(t *testing.T) { it = exps.Iterator(nil) resSamples, err := storage.ExpandSamples(it, newSample) require.NoError(t, err) - require.Equal(t, []chunks.Sample{sample{11, 1, nil, nil}}, resSamples) + require.Equal(t, []chunks.Sample{sample{0, 11, 1, nil, nil}}, resSamples) for res.Next() { } require.NoError(t, res.Err()) @@ -1976,7 +1976,7 @@ func TestDelete_e2e(t *testing.T) { v := rand.Float64() _, err := app.Append(0, ls, ts, v) require.NoError(t, err) - series = append(series, sample{ts, v, nil, nil}) + series = append(series, sample{0, ts, v, nil, nil}) ts += rand.Int63n(timeInterval) + 1 } seriesMap[labels.New(l...).String()] = series @@ -3838,7 +3838,7 @@ func TestDataMissingOnQueryDuringCompaction(t *testing.T) { ref, err = app.Append(ref, labels.FromStrings("a", "b"), ts, float64(i)) require.NoError(t, err) maxt = ts - expSamples = append(expSamples, sample{ts, float64(i), nil, nil}) + expSamples = append(expSamples, sample{0, ts, float64(i), nil, nil}) } require.NoError(t, app.Commit()) @@ -4503,17 +4503,17 @@ func TestChunkSnapshot(t *testing.T) { // 240 samples should m-map at least 1 chunk. for ts := int64(1); ts <= 240; ts++ { val := rand.Float64() - expSeries[lblStr] = append(expSeries[lblStr], sample{ts, val, nil, nil}) + expSeries[lblStr] = append(expSeries[lblStr], sample{0, ts, val, nil, nil}) ref, err := app.Append(0, lbls, ts, val) require.NoError(t, err) hist := histograms[int(ts)] - expHist[lblsHistStr] = append(expHist[lblsHistStr], sample{ts, 0, hist, nil}) + expHist[lblsHistStr] = append(expHist[lblsHistStr], sample{0, ts, 0, hist, nil}) _, err = app.AppendHistogram(0, lblsHist, ts, hist, nil) require.NoError(t, err) floatHist := floatHistogram[int(ts)] - expFloatHist[lblsFloatHistStr] = append(expFloatHist[lblsFloatHistStr], sample{ts, 0, nil, floatHist}) + expFloatHist[lblsFloatHistStr] = append(expFloatHist[lblsFloatHistStr], sample{0, ts, 0, nil, floatHist}) _, err = app.AppendHistogram(0, lblsFloatHist, ts, nil, floatHist) require.NoError(t, err) @@ -4577,17 +4577,17 @@ func TestChunkSnapshot(t *testing.T) { // 240 samples should m-map at least 1 chunk. for ts := int64(241); ts <= 480; ts++ { val := rand.Float64() - expSeries[lblStr] = append(expSeries[lblStr], sample{ts, val, nil, nil}) + expSeries[lblStr] = append(expSeries[lblStr], sample{0, ts, val, nil, nil}) ref, err := app.Append(0, lbls, ts, val) require.NoError(t, err) hist := histograms[int(ts)] - expHist[lblsHistStr] = append(expHist[lblsHistStr], sample{ts, 0, hist, nil}) + expHist[lblsHistStr] = append(expHist[lblsHistStr], sample{0, ts, 0, hist, nil}) _, err = app.AppendHistogram(0, lblsHist, ts, hist, nil) require.NoError(t, err) floatHist := floatHistogram[int(ts)] - expFloatHist[lblsFloatHistStr] = append(expFloatHist[lblsFloatHistStr], sample{ts, 0, nil, floatHist}) + expFloatHist[lblsFloatHistStr] = append(expFloatHist[lblsFloatHistStr], sample{0, ts, 0, nil, floatHist}) _, err = app.AppendHistogram(0, lblsFloatHist, ts, nil, floatHist) require.NoError(t, err) diff --git a/tsdb/querier_test.go b/tsdb/querier_test.go index 57a53c46fe..9ff5124074 100644 --- a/tsdb/querier_test.go +++ b/tsdb/querier_test.go @@ -318,24 +318,24 @@ func TestBlockQuerier(t *testing.T) { ms: []*labels.Matcher{labels.MustNewMatcher(labels.MatchRegexp, "a", ".*")}, exp: newMockSeriesSet([]storage.Series{ storage.NewListSeries(labels.FromStrings("a", "a"), - []chunks.Sample{sample{1, 2, nil, nil}, sample{2, 3, nil, nil}, sample{3, 4, nil, nil}, sample{5, 2, nil, nil}, sample{6, 3, nil, nil}, sample{7, 4, nil, nil}}, + []chunks.Sample{sample{0, 1, 2, nil, nil}, sample{0, 2, 3, nil, nil}, sample{0, 3, 4, nil, nil}, sample{0, 5, 2, nil, nil}, sample{0, 6, 3, nil, nil}, sample{0, 7, 4, nil, nil}}, ), storage.NewListSeries(labels.FromStrings("a", "a", "b", "b"), - []chunks.Sample{sample{1, 1, nil, nil}, sample{2, 2, nil, nil}, sample{3, 3, nil, nil}, sample{5, 3, nil, nil}, sample{6, 6, nil, nil}}, + []chunks.Sample{sample{0, 1, 1, nil, nil}, sample{0, 2, 2, nil, nil}, sample{0, 3, 3, nil, nil}, sample{0, 5, 3, nil, nil}, sample{0, 6, 6, nil, nil}}, ), storage.NewListSeries(labels.FromStrings("b", "b"), - []chunks.Sample{sample{1, 3, nil, nil}, sample{2, 2, nil, nil}, sample{3, 6, nil, nil}, sample{5, 1, nil, nil}, sample{6, 7, nil, nil}, sample{7, 2, nil, nil}}, + []chunks.Sample{sample{0, 1, 3, nil, nil}, sample{0, 2, 2, nil, nil}, sample{0, 3, 6, nil, nil}, sample{0, 5, 1, nil, nil}, sample{0, 6, 7, nil, nil}, sample{0, 7, 2, nil, nil}}, ), }), expChks: newMockChunkSeriesSet([]storage.ChunkSeries{ storage.NewListChunkSeriesFromSamples(labels.FromStrings("a", "a"), - []chunks.Sample{sample{1, 2, nil, nil}, sample{2, 3, nil, nil}, sample{3, 4, nil, nil}}, []chunks.Sample{sample{5, 2, nil, nil}, sample{6, 3, nil, nil}, sample{7, 4, nil, nil}}, + []chunks.Sample{sample{0, 1, 2, nil, nil}, sample{0, 2, 3, nil, nil}, sample{0, 3, 4, nil, nil}}, []chunks.Sample{sample{0, 5, 2, nil, nil}, sample{0, 6, 3, nil, nil}, sample{0, 7, 4, nil, nil}}, ), storage.NewListChunkSeriesFromSamples(labels.FromStrings("a", "a", "b", "b"), - []chunks.Sample{sample{1, 1, nil, nil}, sample{2, 2, nil, nil}, sample{3, 3, nil, nil}}, []chunks.Sample{sample{5, 3, nil, nil}, sample{6, 6, nil, nil}}, + []chunks.Sample{sample{0, 1, 1, nil, nil}, sample{0, 2, 2, nil, nil}, sample{0, 3, 3, nil, nil}}, []chunks.Sample{sample{0, 5, 3, nil, nil}, sample{0, 6, 6, nil, nil}}, ), storage.NewListChunkSeriesFromSamples(labels.FromStrings("b", "b"), - []chunks.Sample{sample{1, 3, nil, nil}, sample{2, 2, nil, nil}, sample{3, 6, nil, nil}}, []chunks.Sample{sample{5, 1, nil, nil}, sample{6, 7, nil, nil}, sample{7, 2, nil, nil}}, + []chunks.Sample{sample{0, 1, 3, nil, nil}, sample{0, 2, 2, nil, nil}, sample{0, 3, 6, nil, nil}}, []chunks.Sample{sample{0, 5, 1, nil, nil}, sample{0, 6, 7, nil, nil}, sample{0, 7, 2, nil, nil}}, ), }), }, @@ -345,18 +345,18 @@ func TestBlockQuerier(t *testing.T) { ms: []*labels.Matcher{labels.MustNewMatcher(labels.MatchEqual, "a", "a")}, exp: newMockSeriesSet([]storage.Series{ storage.NewListSeries(labels.FromStrings("a", "a"), - []chunks.Sample{sample{2, 3, nil, nil}, sample{3, 4, nil, nil}, sample{5, 2, nil, nil}, sample{6, 3, nil, nil}}, + []chunks.Sample{sample{0, 2, 3, nil, nil}, sample{0, 3, 4, nil, nil}, sample{0, 5, 2, nil, nil}, sample{0, 6, 3, nil, nil}}, ), storage.NewListSeries(labels.FromStrings("a", "a", "b", "b"), - []chunks.Sample{sample{2, 2, nil, nil}, sample{3, 3, nil, nil}, sample{5, 3, nil, nil}, sample{6, 6, nil, nil}}, + []chunks.Sample{sample{0, 2, 2, nil, nil}, sample{0, 3, 3, nil, nil}, sample{0, 5, 3, nil, nil}, sample{0, 6, 6, nil, nil}}, ), }), expChks: newMockChunkSeriesSet([]storage.ChunkSeries{ storage.NewListChunkSeriesFromSamples(labels.FromStrings("a", "a"), - []chunks.Sample{sample{2, 3, nil, nil}, sample{3, 4, nil, nil}}, []chunks.Sample{sample{5, 2, nil, nil}, sample{6, 3, nil, nil}}, + []chunks.Sample{sample{0, 2, 3, nil, nil}, sample{0, 3, 4, nil, nil}}, []chunks.Sample{sample{0, 5, 2, nil, nil}, sample{0, 6, 3, nil, nil}}, ), storage.NewListChunkSeriesFromSamples(labels.FromStrings("a", "a", "b", "b"), - []chunks.Sample{sample{2, 2, nil, nil}, sample{3, 3, nil, nil}}, []chunks.Sample{sample{5, 3, nil, nil}, sample{6, 6, nil, nil}}, + []chunks.Sample{sample{0, 2, 2, nil, nil}, sample{0, 3, 3, nil, nil}}, []chunks.Sample{sample{0, 5, 3, nil, nil}, sample{0, 6, 6, nil, nil}}, ), }), }, @@ -369,20 +369,20 @@ func TestBlockQuerier(t *testing.T) { ms: []*labels.Matcher{labels.MustNewMatcher(labels.MatchEqual, "a", "a")}, exp: newMockSeriesSet([]storage.Series{ storage.NewListSeries(labels.FromStrings("a", "a"), - []chunks.Sample{sample{1, 2, nil, nil}, sample{2, 3, nil, nil}, sample{3, 4, nil, nil}, sample{5, 2, nil, nil}, sample{6, 3, nil, nil}, sample{7, 4, nil, nil}}, + []chunks.Sample{sample{0, 1, 2, nil, nil}, sample{0, 2, 3, nil, nil}, sample{0, 3, 4, nil, nil}, sample{0, 5, 2, nil, nil}, sample{0, 6, 3, nil, nil}, sample{0, 7, 4, nil, nil}}, ), storage.NewListSeries(labels.FromStrings("a", "a", "b", "b"), - []chunks.Sample{sample{1, 1, nil, nil}, sample{2, 2, nil, nil}, sample{3, 3, nil, nil}, sample{5, 3, nil, nil}, sample{6, 6, nil, nil}}, + []chunks.Sample{sample{0, 1, 1, nil, nil}, sample{0, 2, 2, nil, nil}, sample{0, 3, 3, nil, nil}, sample{0, 5, 3, nil, nil}, sample{0, 6, 6, nil, nil}}, ), }), expChks: newMockChunkSeriesSet([]storage.ChunkSeries{ storage.NewListChunkSeriesFromSamples(labels.FromStrings("a", "a"), - []chunks.Sample{sample{1, 2, nil, nil}, sample{2, 3, nil, nil}, sample{3, 4, nil, nil}}, - []chunks.Sample{sample{5, 2, nil, nil}, sample{6, 3, nil, nil}, sample{7, 4, nil, nil}}, + []chunks.Sample{sample{0, 1, 2, nil, nil}, sample{0, 2, 3, nil, nil}, sample{0, 3, 4, nil, nil}}, + []chunks.Sample{sample{0, 5, 2, nil, nil}, sample{0, 6, 3, nil, nil}, sample{0, 7, 4, nil, nil}}, ), storage.NewListChunkSeriesFromSamples(labels.FromStrings("a", "a", "b", "b"), - []chunks.Sample{sample{1, 1, nil, nil}, sample{2, 2, nil, nil}, sample{3, 3, nil, nil}}, - []chunks.Sample{sample{5, 3, nil, nil}, sample{6, 6, nil, nil}}, + []chunks.Sample{sample{0, 1, 1, nil, nil}, sample{0, 2, 2, nil, nil}, sample{0, 3, 3, nil, nil}}, + []chunks.Sample{sample{0, 5, 3, nil, nil}, sample{0, 6, 6, nil, nil}}, ), }), }, @@ -395,18 +395,18 @@ func TestBlockQuerier(t *testing.T) { ms: []*labels.Matcher{labels.MustNewMatcher(labels.MatchEqual, "a", "a")}, exp: newMockSeriesSet([]storage.Series{ storage.NewListSeries(labels.FromStrings("a", "a"), - []chunks.Sample{sample{5, 2, nil, nil}, sample{6, 3, nil, nil}, sample{7, 4, nil, nil}}, + []chunks.Sample{sample{0, 5, 2, nil, nil}, sample{0, 6, 3, nil, nil}, sample{0, 7, 4, nil, nil}}, ), storage.NewListSeries(labels.FromStrings("a", "a", "b", "b"), - []chunks.Sample{sample{5, 3, nil, nil}, sample{6, 6, nil, nil}}, + []chunks.Sample{sample{0, 5, 3, nil, nil}, sample{0, 6, 6, nil, nil}}, ), }), expChks: newMockChunkSeriesSet([]storage.ChunkSeries{ storage.NewListChunkSeriesFromSamples(labels.FromStrings("a", "a"), - []chunks.Sample{sample{5, 2, nil, nil}, sample{6, 3, nil, nil}, sample{7, 4, nil, nil}}, + []chunks.Sample{sample{0, 5, 2, nil, nil}, sample{0, 6, 3, nil, nil}, sample{0, 7, 4, nil, nil}}, ), storage.NewListChunkSeriesFromSamples(labels.FromStrings("a", "a", "b", "b"), - []chunks.Sample{sample{5, 3, nil, nil}, sample{6, 6, nil, nil}}, + []chunks.Sample{sample{0, 5, 3, nil, nil}, sample{0, 6, 6, nil, nil}}, ), }), }, @@ -454,24 +454,24 @@ func TestBlockQuerier_AgainstHeadWithOpenChunks(t *testing.T) { ms: []*labels.Matcher{labels.MustNewMatcher(labels.MatchRegexp, "a", ".*")}, exp: newMockSeriesSet([]storage.Series{ storage.NewListSeries(labels.FromStrings("a", "a"), - []chunks.Sample{sample{1, 2, nil, nil}, sample{2, 3, nil, nil}, sample{3, 4, nil, nil}, sample{5, 2, nil, nil}, sample{6, 3, nil, nil}, sample{7, 4, nil, nil}}, + []chunks.Sample{sample{0, 1, 2, nil, nil}, sample{0, 2, 3, nil, nil}, sample{0, 3, 4, nil, nil}, sample{0, 5, 2, nil, nil}, sample{0, 6, 3, nil, nil}, sample{0, 7, 4, nil, nil}}, ), storage.NewListSeries(labels.FromStrings("a", "a", "b", "b"), - []chunks.Sample{sample{1, 1, nil, nil}, sample{2, 2, nil, nil}, sample{3, 3, nil, nil}, sample{5, 3, nil, nil}, sample{6, 6, nil, nil}}, + []chunks.Sample{sample{0, 1, 1, nil, nil}, sample{0, 2, 2, nil, nil}, sample{0, 3, 3, nil, nil}, sample{0, 5, 3, nil, nil}, sample{0, 6, 6, nil, nil}}, ), storage.NewListSeries(labels.FromStrings("b", "b"), - []chunks.Sample{sample{1, 3, nil, nil}, sample{2, 2, nil, nil}, sample{3, 6, nil, nil}, sample{5, 1, nil, nil}, sample{6, 7, nil, nil}, sample{7, 2, nil, nil}}, + []chunks.Sample{sample{0, 1, 3, nil, nil}, sample{0, 2, 2, nil, nil}, sample{0, 3, 6, nil, nil}, sample{0, 5, 1, nil, nil}, sample{0, 6, 7, nil, nil}, sample{0, 7, 2, nil, nil}}, ), }), expChks: newMockChunkSeriesSet([]storage.ChunkSeries{ storage.NewListChunkSeriesFromSamples(labels.FromStrings("a", "a"), - []chunks.Sample{sample{1, 2, nil, nil}, sample{2, 3, nil, nil}, sample{3, 4, nil, nil}, sample{5, 2, nil, nil}, sample{6, 3, nil, nil}, sample{7, 4, nil, nil}}, + []chunks.Sample{sample{0, 1, 2, nil, nil}, sample{0, 2, 3, nil, nil}, sample{0, 3, 4, nil, nil}, sample{0, 5, 2, nil, nil}, sample{0, 6, 3, nil, nil}, sample{0, 7, 4, nil, nil}}, ), storage.NewListChunkSeriesFromSamples(labels.FromStrings("a", "a", "b", "b"), - []chunks.Sample{sample{1, 1, nil, nil}, sample{2, 2, nil, nil}, sample{3, 3, nil, nil}, sample{5, 3, nil, nil}, sample{6, 6, nil, nil}}, + []chunks.Sample{sample{0, 1, 1, nil, nil}, sample{0, 2, 2, nil, nil}, sample{0, 3, 3, nil, nil}, sample{0, 5, 3, nil, nil}, sample{0, 6, 6, nil, nil}}, ), storage.NewListChunkSeriesFromSamples(labels.FromStrings("b", "b"), - []chunks.Sample{sample{1, 3, nil, nil}, sample{2, 2, nil, nil}, sample{3, 6, nil, nil}, sample{5, 1, nil, nil}, sample{6, 7, nil, nil}, sample{7, 2, nil, nil}}, + []chunks.Sample{sample{0, 1, 3, nil, nil}, sample{0, 2, 2, nil, nil}, sample{0, 3, 6, nil, nil}, sample{0, 5, 1, nil, nil}, sample{0, 6, 7, nil, nil}, sample{0, 7, 2, nil, nil}}, ), }), }, @@ -481,18 +481,18 @@ func TestBlockQuerier_AgainstHeadWithOpenChunks(t *testing.T) { ms: []*labels.Matcher{labels.MustNewMatcher(labels.MatchEqual, "a", "a")}, exp: newMockSeriesSet([]storage.Series{ storage.NewListSeries(labels.FromStrings("a", "a"), - []chunks.Sample{sample{2, 3, nil, nil}, sample{3, 4, nil, nil}, sample{5, 2, nil, nil}, sample{6, 3, nil, nil}}, + []chunks.Sample{sample{0, 2, 3, nil, nil}, sample{0, 3, 4, nil, nil}, sample{0, 5, 2, nil, nil}, sample{0, 6, 3, nil, nil}}, ), storage.NewListSeries(labels.FromStrings("a", "a", "b", "b"), - []chunks.Sample{sample{2, 2, nil, nil}, sample{3, 3, nil, nil}, sample{5, 3, nil, nil}, sample{6, 6, nil, nil}}, + []chunks.Sample{sample{0, 2, 2, nil, nil}, sample{0, 3, 3, nil, nil}, sample{0, 5, 3, nil, nil}, sample{0, 6, 6, nil, nil}}, ), }), expChks: newMockChunkSeriesSet([]storage.ChunkSeries{ storage.NewListChunkSeriesFromSamples(labels.FromStrings("a", "a"), - []chunks.Sample{sample{2, 3, nil, nil}, sample{3, 4, nil, nil}, sample{5, 2, nil, nil}, sample{6, 3, nil, nil}}, + []chunks.Sample{sample{0, 2, 3, nil, nil}, sample{0, 3, 4, nil, nil}, sample{0, 5, 2, nil, nil}, sample{0, 6, 3, nil, nil}}, ), storage.NewListChunkSeriesFromSamples(labels.FromStrings("a", "a", "b", "b"), - []chunks.Sample{sample{2, 2, nil, nil}, sample{3, 3, nil, nil}, sample{5, 3, nil, nil}, sample{6, 6, nil, nil}}, + []chunks.Sample{sample{0, 2, 2, nil, nil}, sample{0, 3, 3, nil, nil}, sample{0, 5, 3, nil, nil}, sample{0, 6, 6, nil, nil}}, ), }), }, @@ -537,18 +537,18 @@ func TestBlockQuerier_TrimmingDoesNotModifyOriginalTombstoneIntervals(t *testing ms: []*labels.Matcher{labels.MustNewMatcher(labels.MatchRegexp, "a", "a")}, exp: newMockSeriesSet([]storage.Series{ storage.NewListSeries(labels.FromStrings("a", "a"), - []chunks.Sample{sample{3, 4, nil, nil}, sample{5, 2, nil, nil}, sample{6, 3, nil, nil}}, + []chunks.Sample{sample{0, 3, 4, nil, nil}, sample{0, 5, 2, nil, nil}, sample{0, 6, 3, nil, nil}}, ), storage.NewListSeries(labels.FromStrings("a", "a", "b", "b"), - []chunks.Sample{sample{3, 3, nil, nil}, sample{5, 3, nil, nil}, sample{6, 6, nil, nil}}, + []chunks.Sample{sample{0, 3, 3, nil, nil}, sample{0, 5, 3, nil, nil}, sample{0, 6, 6, nil, nil}}, ), }), expChks: newMockChunkSeriesSet([]storage.ChunkSeries{ storage.NewListChunkSeriesFromSamples(labels.FromStrings("a", "a"), - []chunks.Sample{sample{3, 4, nil, nil}}, []chunks.Sample{sample{5, 2, nil, nil}, sample{6, 3, nil, nil}}, + []chunks.Sample{sample{0, 3, 4, nil, nil}}, []chunks.Sample{sample{0, 5, 2, nil, nil}, sample{0, 6, 3, nil, nil}}, ), storage.NewListChunkSeriesFromSamples(labels.FromStrings("a", "a", "b", "b"), - []chunks.Sample{sample{3, 3, nil, nil}}, []chunks.Sample{sample{5, 3, nil, nil}, sample{6, 6, nil, nil}}, + []chunks.Sample{sample{0, 3, 3, nil, nil}}, []chunks.Sample{sample{0, 5, 3, nil, nil}, sample{0, 6, 6, nil, nil}}, ), }), } @@ -636,24 +636,24 @@ func TestBlockQuerierDelete(t *testing.T) { ms: []*labels.Matcher{labels.MustNewMatcher(labels.MatchRegexp, "a", ".*")}, exp: newMockSeriesSet([]storage.Series{ storage.NewListSeries(labels.FromStrings("a", "a"), - []chunks.Sample{sample{5, 2, nil, nil}, sample{6, 3, nil, nil}, sample{7, 4, nil, nil}}, + []chunks.Sample{sample{0, 5, 2, nil, nil}, sample{0, 6, 3, nil, nil}, sample{0, 7, 4, nil, nil}}, ), storage.NewListSeries(labels.FromStrings("a", "a", "b", "b"), - []chunks.Sample{sample{5, 3, nil, nil}}, + []chunks.Sample{sample{0, 5, 3, nil, nil}}, ), storage.NewListSeries(labels.FromStrings("b", "b"), - []chunks.Sample{sample{1, 3, nil, nil}, sample{2, 2, nil, nil}, sample{3, 6, nil, nil}, sample{5, 1, nil, nil}}, + []chunks.Sample{sample{0, 1, 3, nil, nil}, sample{0, 2, 2, nil, nil}, sample{0, 3, 6, nil, nil}, sample{0, 5, 1, nil, nil}}, ), }), expChks: newMockChunkSeriesSet([]storage.ChunkSeries{ storage.NewListChunkSeriesFromSamples(labels.FromStrings("a", "a"), - []chunks.Sample{sample{5, 2, nil, nil}, sample{6, 3, nil, nil}, sample{7, 4, nil, nil}}, + []chunks.Sample{sample{0, 5, 2, nil, nil}, sample{0, 6, 3, nil, nil}, sample{0, 7, 4, nil, nil}}, ), storage.NewListChunkSeriesFromSamples(labels.FromStrings("a", "a", "b", "b"), - []chunks.Sample{sample{5, 3, nil, nil}}, + []chunks.Sample{sample{0, 5, 3, nil, nil}}, ), storage.NewListChunkSeriesFromSamples(labels.FromStrings("b", "b"), - []chunks.Sample{sample{1, 3, nil, nil}, sample{2, 2, nil, nil}, sample{3, 6, nil, nil}}, []chunks.Sample{sample{5, 1, nil, nil}}, + []chunks.Sample{sample{0, 1, 3, nil, nil}, sample{0, 2, 2, nil, nil}, sample{0, 3, 6, nil, nil}}, []chunks.Sample{sample{0, 5, 1, nil, nil}}, ), }), }, @@ -663,18 +663,18 @@ func TestBlockQuerierDelete(t *testing.T) { ms: []*labels.Matcher{labels.MustNewMatcher(labels.MatchEqual, "a", "a")}, exp: newMockSeriesSet([]storage.Series{ storage.NewListSeries(labels.FromStrings("a", "a"), - []chunks.Sample{sample{5, 2, nil, nil}, sample{6, 3, nil, nil}}, + []chunks.Sample{sample{0, 5, 2, nil, nil}, sample{0, 6, 3, nil, nil}}, ), storage.NewListSeries(labels.FromStrings("a", "a", "b", "b"), - []chunks.Sample{sample{5, 3, nil, nil}}, + []chunks.Sample{sample{0, 5, 3, nil, nil}}, ), }), expChks: newMockChunkSeriesSet([]storage.ChunkSeries{ storage.NewListChunkSeriesFromSamples(labels.FromStrings("a", "a"), - []chunks.Sample{sample{5, 2, nil, nil}, sample{6, 3, nil, nil}}, + []chunks.Sample{sample{0, 5, 2, nil, nil}, sample{0, 6, 3, nil, nil}}, ), storage.NewListChunkSeriesFromSamples(labels.FromStrings("a", "a", "b", "b"), - []chunks.Sample{sample{5, 3, nil, nil}}, + []chunks.Sample{sample{0, 5, 3, nil, nil}}, ), }), }, @@ -875,15 +875,15 @@ func TestPopulateWithTombSeriesIterators(t *testing.T) { { name: "one chunk", samples: [][]chunks.Sample{ - {sample{1, 2, nil, nil}, sample{2, 3, nil, nil}, sample{3, 5, nil, nil}, sample{6, 1, nil, nil}}, + {sample{0, 1, 2, nil, nil}, sample{0, 2, 3, nil, nil}, sample{0, 3, 5, nil, nil}, sample{0, 6, 1, nil, nil}}, }, expected: []chunks.Sample{ - sample{1, 2, nil, nil}, sample{2, 3, nil, nil}, sample{3, 5, nil, nil}, sample{6, 1, nil, nil}, + sample{0, 1, 2, nil, nil}, sample{0, 2, 3, nil, nil}, sample{0, 3, 5, nil, nil}, sample{0, 6, 1, nil, nil}, }, expectedChks: []chunks.Meta{ assureChunkFromSamples(t, []chunks.Sample{ - sample{1, 2, nil, nil}, sample{2, 3, nil, nil}, sample{3, 5, nil, nil}, sample{6, 1, nil, nil}, + sample{0, 1, 2, nil, nil}, sample{0, 2, 3, nil, nil}, sample{0, 3, 5, nil, nil}, sample{0, 6, 1, nil, nil}, }), }, expectedMinMaxTimes: []minMaxTimes{{1, 6}}, @@ -891,19 +891,19 @@ func TestPopulateWithTombSeriesIterators(t *testing.T) { { name: "two full chunks", samples: [][]chunks.Sample{ - {sample{1, 2, nil, nil}, sample{2, 3, nil, nil}, sample{3, 5, nil, nil}, sample{6, 1, nil, nil}}, - {sample{7, 89, nil, nil}, sample{9, 8, nil, nil}}, + {sample{0, 1, 2, nil, nil}, sample{0, 2, 3, nil, nil}, sample{0, 3, 5, nil, nil}, sample{0, 6, 1, nil, nil}}, + {sample{0, 7, 89, nil, nil}, sample{0, 9, 8, nil, nil}}, }, expected: []chunks.Sample{ - sample{1, 2, nil, nil}, sample{2, 3, nil, nil}, sample{3, 5, nil, nil}, sample{6, 1, nil, nil}, sample{7, 89, nil, nil}, sample{9, 8, nil, nil}, + sample{0, 1, 2, nil, nil}, sample{0, 2, 3, nil, nil}, sample{0, 3, 5, nil, nil}, sample{0, 6, 1, nil, nil}, sample{0, 7, 89, nil, nil}, sample{0, 9, 8, nil, nil}, }, expectedChks: []chunks.Meta{ assureChunkFromSamples(t, []chunks.Sample{ - sample{1, 2, nil, nil}, sample{2, 3, nil, nil}, sample{3, 5, nil, nil}, sample{6, 1, nil, nil}, + sample{0, 1, 2, nil, nil}, sample{0, 2, 3, nil, nil}, sample{0, 3, 5, nil, nil}, sample{0, 6, 1, nil, nil}, }), assureChunkFromSamples(t, []chunks.Sample{ - sample{7, 89, nil, nil}, sample{9, 8, nil, nil}, + sample{0, 7, 89, nil, nil}, sample{0, 9, 8, nil, nil}, }), }, expectedMinMaxTimes: []minMaxTimes{{1, 6}, {7, 9}}, @@ -911,23 +911,23 @@ func TestPopulateWithTombSeriesIterators(t *testing.T) { { name: "three full chunks", samples: [][]chunks.Sample{ - {sample{1, 2, nil, nil}, sample{2, 3, nil, nil}, sample{3, 5, nil, nil}, sample{6, 1, nil, nil}}, - {sample{7, 89, nil, nil}, sample{9, 8, nil, nil}}, - {sample{10, 22, nil, nil}, sample{203, 3493, nil, nil}}, + {sample{0, 1, 2, nil, nil}, sample{0, 2, 3, nil, nil}, sample{0, 3, 5, nil, nil}, sample{0, 6, 1, nil, nil}}, + {sample{0, 7, 89, nil, nil}, sample{0, 9, 8, nil, nil}}, + {sample{0, 10, 22, nil, nil}, sample{0, 203, 3493, nil, nil}}, }, expected: []chunks.Sample{ - sample{1, 2, nil, nil}, sample{2, 3, nil, nil}, sample{3, 5, nil, nil}, sample{6, 1, nil, nil}, sample{7, 89, nil, nil}, sample{9, 8, nil, nil}, sample{10, 22, nil, nil}, sample{203, 3493, nil, nil}, + sample{0, 1, 2, nil, nil}, sample{0, 2, 3, nil, nil}, sample{0, 3, 5, nil, nil}, sample{0, 6, 1, nil, nil}, sample{0, 7, 89, nil, nil}, sample{0, 9, 8, nil, nil}, sample{0, 10, 22, nil, nil}, sample{0, 203, 3493, nil, nil}, }, expectedChks: []chunks.Meta{ assureChunkFromSamples(t, []chunks.Sample{ - sample{1, 2, nil, nil}, sample{2, 3, nil, nil}, sample{3, 5, nil, nil}, sample{6, 1, nil, nil}, + sample{0, 1, 2, nil, nil}, sample{0, 2, 3, nil, nil}, sample{0, 3, 5, nil, nil}, sample{0, 6, 1, nil, nil}, }), assureChunkFromSamples(t, []chunks.Sample{ - sample{7, 89, nil, nil}, sample{9, 8, nil, nil}, + sample{0, 7, 89, nil, nil}, sample{0, 9, 8, nil, nil}, }), assureChunkFromSamples(t, []chunks.Sample{ - sample{10, 22, nil, nil}, sample{203, 3493, nil, nil}, + sample{0, 10, 22, nil, nil}, sample{0, 203, 3493, nil, nil}, }), }, expectedMinMaxTimes: []minMaxTimes{{1, 6}, {7, 9}, {10, 203}}, @@ -943,8 +943,8 @@ func TestPopulateWithTombSeriesIterators(t *testing.T) { { name: "two chunks and seek beyond chunks", samples: [][]chunks.Sample{ - {sample{1, 2, nil, nil}, sample{3, 5, nil, nil}, sample{6, 1, nil, nil}}, - {sample{7, 89, nil, nil}, sample{9, 8, nil, nil}}, + {sample{0, 1, 2, nil, nil}, sample{0, 3, 5, nil, nil}, sample{0, 6, 1, nil, nil}}, + {sample{0, 7, 89, nil, nil}, sample{0, 9, 8, nil, nil}}, }, seek: 10, @@ -953,27 +953,27 @@ func TestPopulateWithTombSeriesIterators(t *testing.T) { { name: "two chunks and seek on middle of first chunk", samples: [][]chunks.Sample{ - {sample{1, 2, nil, nil}, sample{3, 5, nil, nil}, sample{6, 1, nil, nil}}, - {sample{7, 89, nil, nil}, sample{9, 8, nil, nil}}, + {sample{0, 1, 2, nil, nil}, sample{0, 3, 5, nil, nil}, sample{0, 6, 1, nil, nil}}, + {sample{0, 7, 89, nil, nil}, sample{0, 9, 8, nil, nil}}, }, seek: 2, seekSuccess: true, expected: []chunks.Sample{ - sample{3, 5, nil, nil}, sample{6, 1, nil, nil}, sample{7, 89, nil, nil}, sample{9, 8, nil, nil}, + sample{0, 3, 5, nil, nil}, sample{0, 6, 1, nil, nil}, sample{0, 7, 89, nil, nil}, sample{0, 9, 8, nil, nil}, }, }, { name: "two chunks and seek before first chunk", samples: [][]chunks.Sample{ - {sample{1, 2, nil, nil}, sample{3, 5, nil, nil}, sample{6, 1, nil, nil}}, - {sample{7, 89, nil, nil}, sample{9, 8, nil, nil}}, + {sample{0, 1, 2, nil, nil}, sample{0, 3, 5, nil, nil}, sample{0, 6, 1, nil, nil}}, + {sample{0, 7, 89, nil, nil}, sample{0, 9, 8, nil, nil}}, }, seek: -32, seekSuccess: true, expected: []chunks.Sample{ - sample{1, 2, nil, nil}, sample{3, 5, nil, nil}, sample{6, 1, nil, nil}, sample{7, 89, nil, nil}, sample{9, 8, nil, nil}, + sample{0, 1, 2, nil, nil}, sample{0, 3, 5, nil, nil}, sample{0, 6, 1, nil, nil}, sample{0, 7, 89, nil, nil}, sample{0, 9, 8, nil, nil}, }, }, // Deletion / Trim cases. @@ -985,20 +985,20 @@ func TestPopulateWithTombSeriesIterators(t *testing.T) { { name: "two chunks with trimmed first and last samples from edge chunks", samples: [][]chunks.Sample{ - {sample{1, 2, nil, nil}, sample{2, 3, nil, nil}, sample{3, 5, nil, nil}, sample{6, 1, nil, nil}}, - {sample{7, 89, nil, nil}, sample{9, 8, nil, nil}}, + {sample{0, 1, 2, nil, nil}, sample{0, 2, 3, nil, nil}, sample{0, 3, 5, nil, nil}, sample{0, 6, 1, nil, nil}}, + {sample{0, 7, 89, nil, nil}, sample{0, 9, 8, nil, nil}}, }, intervals: tombstones.Intervals{{Mint: math.MinInt64, Maxt: 2}}.Add(tombstones.Interval{Mint: 9, Maxt: math.MaxInt64}), expected: []chunks.Sample{ - sample{3, 5, nil, nil}, sample{6, 1, nil, nil}, sample{7, 89, nil, nil}, + sample{0, 3, 5, nil, nil}, sample{0, 6, 1, nil, nil}, sample{0, 7, 89, nil, nil}, }, expectedChks: []chunks.Meta{ assureChunkFromSamples(t, []chunks.Sample{ - sample{3, 5, nil, nil}, sample{6, 1, nil, nil}, + sample{0, 3, 5, nil, nil}, sample{0, 6, 1, nil, nil}, }), assureChunkFromSamples(t, []chunks.Sample{ - sample{7, 89, nil, nil}, + sample{0, 7, 89, nil, nil}, }), }, expectedMinMaxTimes: []minMaxTimes{{3, 6}, {7, 7}}, @@ -1006,20 +1006,20 @@ func TestPopulateWithTombSeriesIterators(t *testing.T) { { name: "two chunks with trimmed middle sample of first chunk", samples: [][]chunks.Sample{ - {sample{1, 2, nil, nil}, sample{2, 3, nil, nil}, sample{3, 5, nil, nil}, sample{6, 1, nil, nil}}, - {sample{7, 89, nil, nil}, sample{9, 8, nil, nil}}, + {sample{0, 1, 2, nil, nil}, sample{0, 2, 3, nil, nil}, sample{0, 3, 5, nil, nil}, sample{0, 6, 1, nil, nil}}, + {sample{0, 7, 89, nil, nil}, sample{0, 9, 8, nil, nil}}, }, intervals: tombstones.Intervals{{Mint: 2, Maxt: 3}}, expected: []chunks.Sample{ - sample{1, 2, nil, nil}, sample{6, 1, nil, nil}, sample{7, 89, nil, nil}, sample{9, 8, nil, nil}, + sample{0, 1, 2, nil, nil}, sample{0, 6, 1, nil, nil}, sample{0, 7, 89, nil, nil}, sample{0, 9, 8, nil, nil}, }, expectedChks: []chunks.Meta{ assureChunkFromSamples(t, []chunks.Sample{ - sample{1, 2, nil, nil}, sample{6, 1, nil, nil}, + sample{0, 1, 2, nil, nil}, sample{0, 6, 1, nil, nil}, }), assureChunkFromSamples(t, []chunks.Sample{ - sample{7, 89, nil, nil}, sample{9, 8, nil, nil}, + sample{0, 7, 89, nil, nil}, sample{0, 9, 8, nil, nil}, }), }, expectedMinMaxTimes: []minMaxTimes{{1, 6}, {7, 9}}, @@ -1027,20 +1027,20 @@ func TestPopulateWithTombSeriesIterators(t *testing.T) { { name: "two chunks with deletion across two chunks", samples: [][]chunks.Sample{ - {sample{1, 2, nil, nil}, sample{2, 3, nil, nil}, sample{3, 5, nil, nil}, sample{6, 1, nil, nil}}, - {sample{7, 89, nil, nil}, sample{9, 8, nil, nil}}, + {sample{0, 1, 2, nil, nil}, sample{0, 2, 3, nil, nil}, sample{0, 3, 5, nil, nil}, sample{0, 6, 1, nil, nil}}, + {sample{0, 7, 89, nil, nil}, sample{0, 9, 8, nil, nil}}, }, intervals: tombstones.Intervals{{Mint: 6, Maxt: 7}}, expected: []chunks.Sample{ - sample{1, 2, nil, nil}, sample{2, 3, nil, nil}, sample{3, 5, nil, nil}, sample{9, 8, nil, nil}, + sample{0, 1, 2, nil, nil}, sample{0, 2, 3, nil, nil}, sample{0, 3, 5, nil, nil}, sample{0, 9, 8, nil, nil}, }, expectedChks: []chunks.Meta{ assureChunkFromSamples(t, []chunks.Sample{ - sample{1, 2, nil, nil}, sample{2, 3, nil, nil}, sample{3, 5, nil, nil}, + sample{0, 1, 2, nil, nil}, sample{0, 2, 3, nil, nil}, sample{0, 3, 5, nil, nil}, }), assureChunkFromSamples(t, []chunks.Sample{ - sample{9, 8, nil, nil}, + sample{0, 9, 8, nil, nil}, }), }, expectedMinMaxTimes: []minMaxTimes{{1, 3}, {9, 9}}, @@ -1048,17 +1048,17 @@ func TestPopulateWithTombSeriesIterators(t *testing.T) { { name: "two chunks with first chunk deleted", samples: [][]chunks.Sample{ - {sample{1, 2, nil, nil}, sample{2, 3, nil, nil}, sample{3, 5, nil, nil}, sample{6, 1, nil, nil}}, - {sample{7, 89, nil, nil}, sample{9, 8, nil, nil}}, + {sample{0, 1, 2, nil, nil}, sample{0, 2, 3, nil, nil}, sample{0, 3, 5, nil, nil}, sample{0, 6, 1, nil, nil}}, + {sample{0, 7, 89, nil, nil}, sample{0, 9, 8, nil, nil}}, }, intervals: tombstones.Intervals{{Mint: 1, Maxt: 6}}, expected: []chunks.Sample{ - sample{7, 89, nil, nil}, sample{9, 8, nil, nil}, + sample{0, 7, 89, nil, nil}, sample{0, 9, 8, nil, nil}, }, expectedChks: []chunks.Meta{ assureChunkFromSamples(t, []chunks.Sample{ - sample{7, 89, nil, nil}, sample{9, 8, nil, nil}, + sample{0, 7, 89, nil, nil}, sample{0, 9, 8, nil, nil}, }), }, expectedMinMaxTimes: []minMaxTimes{{7, 9}}, @@ -1067,22 +1067,22 @@ func TestPopulateWithTombSeriesIterators(t *testing.T) { { name: "two chunks with trimmed first and last samples from edge chunks, seek from middle of first chunk", samples: [][]chunks.Sample{ - {sample{1, 2, nil, nil}, sample{2, 3, nil, nil}, sample{3, 5, nil, nil}, sample{6, 1, nil, nil}}, - {sample{7, 89, nil, nil}, sample{9, 8, nil, nil}}, + {sample{0, 1, 2, nil, nil}, sample{0, 2, 3, nil, nil}, sample{0, 3, 5, nil, nil}, sample{0, 6, 1, nil, nil}}, + {sample{0, 7, 89, nil, nil}, sample{0, 9, 8, nil, nil}}, }, intervals: tombstones.Intervals{{Mint: math.MinInt64, Maxt: 2}}.Add(tombstones.Interval{Mint: 9, Maxt: math.MaxInt64}), seek: 3, seekSuccess: true, expected: []chunks.Sample{ - sample{3, 5, nil, nil}, sample{6, 1, nil, nil}, sample{7, 89, nil, nil}, + sample{0, 3, 5, nil, nil}, sample{0, 6, 1, nil, nil}, sample{0, 7, 89, nil, nil}, }, }, { name: "one chunk where all samples are trimmed", samples: [][]chunks.Sample{ - {sample{2, 3, nil, nil}, sample{3, 5, nil, nil}, sample{6, 1, nil, nil}}, - {sample{7, 89, nil, nil}, sample{9, 8, nil, nil}}, + {sample{0, 2, 3, nil, nil}, sample{0, 3, 5, nil, nil}, sample{0, 6, 1, nil, nil}}, + {sample{0, 7, 89, nil, nil}, sample{0, 9, 8, nil, nil}}, }, intervals: tombstones.Intervals{{Mint: math.MinInt64, Maxt: 3}}.Add(tombstones.Interval{Mint: 4, Maxt: math.MaxInt64}), @@ -1093,24 +1093,24 @@ func TestPopulateWithTombSeriesIterators(t *testing.T) { name: "one histogram chunk", samples: [][]chunks.Sample{ { - sample{1, 0, tsdbutil.GenerateTestHistogram(1), nil}, - sample{2, 0, tsdbutil.GenerateTestHistogram(2), nil}, - sample{3, 0, tsdbutil.GenerateTestHistogram(3), nil}, - sample{6, 0, tsdbutil.GenerateTestHistogram(6), nil}, + sample{0, 1, 0, tsdbutil.GenerateTestHistogram(1), nil}, + sample{0, 2, 0, tsdbutil.GenerateTestHistogram(2), nil}, + sample{0, 3, 0, tsdbutil.GenerateTestHistogram(3), nil}, + sample{0, 6, 0, tsdbutil.GenerateTestHistogram(6), nil}, }, }, expected: []chunks.Sample{ - sample{1, 0, tsdbutil.GenerateTestHistogram(1), nil}, - sample{2, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(2)), nil}, - sample{3, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(3)), nil}, - sample{6, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(6)), nil}, + sample{0, 1, 0, tsdbutil.GenerateTestHistogram(1), nil}, + sample{0, 2, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(2)), nil}, + sample{0, 3, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(3)), nil}, + sample{0, 6, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(6)), nil}, }, expectedChks: []chunks.Meta{ assureChunkFromSamples(t, []chunks.Sample{ - sample{1, 0, tsdbutil.GenerateTestHistogram(1), nil}, - sample{2, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(2)), nil}, - sample{3, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(3)), nil}, - sample{6, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(6)), nil}, + sample{0, 1, 0, tsdbutil.GenerateTestHistogram(1), nil}, + sample{0, 2, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(2)), nil}, + sample{0, 3, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(3)), nil}, + sample{0, 6, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(6)), nil}, }), }, expectedMinMaxTimes: []minMaxTimes{{1, 6}}, @@ -1119,21 +1119,21 @@ func TestPopulateWithTombSeriesIterators(t *testing.T) { name: "one histogram chunk intersect with earlier deletion interval", samples: [][]chunks.Sample{ { - sample{1, 0, tsdbutil.GenerateTestHistogram(1), nil}, - sample{2, 0, tsdbutil.GenerateTestHistogram(2), nil}, - sample{3, 0, tsdbutil.GenerateTestHistogram(3), nil}, - sample{6, 0, tsdbutil.GenerateTestHistogram(6), nil}, + sample{0, 1, 0, tsdbutil.GenerateTestHistogram(1), nil}, + sample{0, 2, 0, tsdbutil.GenerateTestHistogram(2), nil}, + sample{0, 3, 0, tsdbutil.GenerateTestHistogram(3), nil}, + sample{0, 6, 0, tsdbutil.GenerateTestHistogram(6), nil}, }, }, intervals: tombstones.Intervals{{Mint: 1, Maxt: 2}}, expected: []chunks.Sample{ - sample{3, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(3)), nil}, - sample{6, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(6)), nil}, + sample{0, 3, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(3)), nil}, + sample{0, 6, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(6)), nil}, }, expectedChks: []chunks.Meta{ assureChunkFromSamples(t, []chunks.Sample{ - sample{3, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(3)), nil}, - sample{6, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(6)), nil}, + sample{0, 3, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(3)), nil}, + sample{0, 6, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(6)), nil}, }), }, expectedMinMaxTimes: []minMaxTimes{{3, 6}}, @@ -1142,23 +1142,23 @@ func TestPopulateWithTombSeriesIterators(t *testing.T) { name: "one histogram chunk intersect with later deletion interval", samples: [][]chunks.Sample{ { - sample{1, 0, tsdbutil.GenerateTestHistogram(1), nil}, - sample{2, 0, tsdbutil.GenerateTestHistogram(2), nil}, - sample{3, 0, tsdbutil.GenerateTestHistogram(3), nil}, - sample{6, 0, tsdbutil.GenerateTestHistogram(6), nil}, + sample{0, 1, 0, tsdbutil.GenerateTestHistogram(1), nil}, + sample{0, 2, 0, tsdbutil.GenerateTestHistogram(2), nil}, + sample{0, 3, 0, tsdbutil.GenerateTestHistogram(3), nil}, + sample{0, 6, 0, tsdbutil.GenerateTestHistogram(6), nil}, }, }, intervals: tombstones.Intervals{{Mint: 5, Maxt: 20}}, expected: []chunks.Sample{ - sample{1, 0, tsdbutil.GenerateTestHistogram(1), nil}, - sample{2, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(2)), nil}, - sample{3, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(3)), nil}, + sample{0, 1, 0, tsdbutil.GenerateTestHistogram(1), nil}, + sample{0, 2, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(2)), nil}, + sample{0, 3, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(3)), nil}, }, expectedChks: []chunks.Meta{ assureChunkFromSamples(t, []chunks.Sample{ - sample{1, 0, tsdbutil.GenerateTestHistogram(1), nil}, - sample{2, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(2)), nil}, - sample{3, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(3)), nil}, + sample{0, 1, 0, tsdbutil.GenerateTestHistogram(1), nil}, + sample{0, 2, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(2)), nil}, + sample{0, 3, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(3)), nil}, }), }, expectedMinMaxTimes: []minMaxTimes{{1, 3}}, @@ -1167,24 +1167,24 @@ func TestPopulateWithTombSeriesIterators(t *testing.T) { name: "one float histogram chunk", samples: [][]chunks.Sample{ { - sample{1, 0, nil, tsdbutil.GenerateTestFloatHistogram(1)}, - sample{2, 0, nil, tsdbutil.GenerateTestFloatHistogram(2)}, - sample{3, 0, nil, tsdbutil.GenerateTestFloatHistogram(3)}, - sample{6, 0, nil, tsdbutil.GenerateTestFloatHistogram(6)}, + sample{0, 1, 0, nil, tsdbutil.GenerateTestFloatHistogram(1)}, + sample{0, 2, 0, nil, tsdbutil.GenerateTestFloatHistogram(2)}, + sample{0, 3, 0, nil, tsdbutil.GenerateTestFloatHistogram(3)}, + sample{0, 6, 0, nil, tsdbutil.GenerateTestFloatHistogram(6)}, }, }, expected: []chunks.Sample{ - sample{1, 0, nil, tsdbutil.GenerateTestFloatHistogram(1)}, - sample{2, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(2))}, - sample{3, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(3))}, - sample{6, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(6))}, + sample{0, 1, 0, nil, tsdbutil.GenerateTestFloatHistogram(1)}, + sample{0, 2, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(2))}, + sample{0, 3, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(3))}, + sample{0, 6, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(6))}, }, expectedChks: []chunks.Meta{ assureChunkFromSamples(t, []chunks.Sample{ - sample{1, 0, nil, tsdbutil.GenerateTestFloatHistogram(1)}, - sample{2, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(2))}, - sample{3, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(3))}, - sample{6, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(6))}, + sample{0, 1, 0, nil, tsdbutil.GenerateTestFloatHistogram(1)}, + sample{0, 2, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(2))}, + sample{0, 3, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(3))}, + sample{0, 6, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(6))}, }), }, expectedMinMaxTimes: []minMaxTimes{{1, 6}}, @@ -1193,21 +1193,21 @@ func TestPopulateWithTombSeriesIterators(t *testing.T) { name: "one float histogram chunk intersect with earlier deletion interval", samples: [][]chunks.Sample{ { - sample{1, 0, nil, tsdbutil.GenerateTestFloatHistogram(1)}, - sample{2, 0, nil, tsdbutil.GenerateTestFloatHistogram(2)}, - sample{3, 0, nil, tsdbutil.GenerateTestFloatHistogram(3)}, - sample{6, 0, nil, tsdbutil.GenerateTestFloatHistogram(6)}, + sample{0, 1, 0, nil, tsdbutil.GenerateTestFloatHistogram(1)}, + sample{0, 2, 0, nil, tsdbutil.GenerateTestFloatHistogram(2)}, + sample{0, 3, 0, nil, tsdbutil.GenerateTestFloatHistogram(3)}, + sample{0, 6, 0, nil, tsdbutil.GenerateTestFloatHistogram(6)}, }, }, intervals: tombstones.Intervals{{Mint: 1, Maxt: 2}}, expected: []chunks.Sample{ - sample{3, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(3))}, - sample{6, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(6))}, + sample{0, 3, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(3))}, + sample{0, 6, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(6))}, }, expectedChks: []chunks.Meta{ assureChunkFromSamples(t, []chunks.Sample{ - sample{3, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(3))}, - sample{6, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(6))}, + sample{0, 3, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(3))}, + sample{0, 6, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(6))}, }), }, expectedMinMaxTimes: []minMaxTimes{{3, 6}}, @@ -1216,23 +1216,23 @@ func TestPopulateWithTombSeriesIterators(t *testing.T) { name: "one float histogram chunk intersect with later deletion interval", samples: [][]chunks.Sample{ { - sample{1, 0, nil, tsdbutil.GenerateTestFloatHistogram(1)}, - sample{2, 0, nil, tsdbutil.GenerateTestFloatHistogram(2)}, - sample{3, 0, nil, tsdbutil.GenerateTestFloatHistogram(3)}, - sample{6, 0, nil, tsdbutil.GenerateTestFloatHistogram(6)}, + sample{0, 1, 0, nil, tsdbutil.GenerateTestFloatHistogram(1)}, + sample{0, 2, 0, nil, tsdbutil.GenerateTestFloatHistogram(2)}, + sample{0, 3, 0, nil, tsdbutil.GenerateTestFloatHistogram(3)}, + sample{0, 6, 0, nil, tsdbutil.GenerateTestFloatHistogram(6)}, }, }, intervals: tombstones.Intervals{{Mint: 5, Maxt: 20}}, expected: []chunks.Sample{ - sample{1, 0, nil, tsdbutil.GenerateTestFloatHistogram(1)}, - sample{2, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(2))}, - sample{3, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(3))}, + sample{0, 1, 0, nil, tsdbutil.GenerateTestFloatHistogram(1)}, + sample{0, 2, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(2))}, + sample{0, 3, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(3))}, }, expectedChks: []chunks.Meta{ assureChunkFromSamples(t, []chunks.Sample{ - sample{1, 0, nil, tsdbutil.GenerateTestFloatHistogram(1)}, - sample{2, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(2))}, - sample{3, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(3))}, + sample{0, 1, 0, nil, tsdbutil.GenerateTestFloatHistogram(1)}, + sample{0, 2, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(2))}, + sample{0, 3, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(3))}, }), }, expectedMinMaxTimes: []minMaxTimes{{1, 3}}, @@ -1241,24 +1241,24 @@ func TestPopulateWithTombSeriesIterators(t *testing.T) { name: "one gauge histogram chunk", samples: [][]chunks.Sample{ { - sample{1, 0, tsdbutil.GenerateTestGaugeHistogram(1), nil}, - sample{2, 0, tsdbutil.GenerateTestGaugeHistogram(2), nil}, - sample{3, 0, tsdbutil.GenerateTestGaugeHistogram(3), nil}, - sample{6, 0, tsdbutil.GenerateTestGaugeHistogram(6), nil}, + sample{0, 1, 0, tsdbutil.GenerateTestGaugeHistogram(1), nil}, + sample{0, 2, 0, tsdbutil.GenerateTestGaugeHistogram(2), nil}, + sample{0, 3, 0, tsdbutil.GenerateTestGaugeHistogram(3), nil}, + sample{0, 6, 0, tsdbutil.GenerateTestGaugeHistogram(6), nil}, }, }, expected: []chunks.Sample{ - sample{1, 0, tsdbutil.GenerateTestGaugeHistogram(1), nil}, - sample{2, 0, tsdbutil.GenerateTestGaugeHistogram(2), nil}, - sample{3, 0, tsdbutil.GenerateTestGaugeHistogram(3), nil}, - sample{6, 0, tsdbutil.GenerateTestGaugeHistogram(6), nil}, + sample{0, 1, 0, tsdbutil.GenerateTestGaugeHistogram(1), nil}, + sample{0, 2, 0, tsdbutil.GenerateTestGaugeHistogram(2), nil}, + sample{0, 3, 0, tsdbutil.GenerateTestGaugeHistogram(3), nil}, + sample{0, 6, 0, tsdbutil.GenerateTestGaugeHistogram(6), nil}, }, expectedChks: []chunks.Meta{ assureChunkFromSamples(t, []chunks.Sample{ - sample{1, 0, tsdbutil.GenerateTestGaugeHistogram(1), nil}, - sample{2, 0, tsdbutil.GenerateTestGaugeHistogram(2), nil}, - sample{3, 0, tsdbutil.GenerateTestGaugeHistogram(3), nil}, - sample{6, 0, tsdbutil.GenerateTestGaugeHistogram(6), nil}, + sample{0, 1, 0, tsdbutil.GenerateTestGaugeHistogram(1), nil}, + sample{0, 2, 0, tsdbutil.GenerateTestGaugeHistogram(2), nil}, + sample{0, 3, 0, tsdbutil.GenerateTestGaugeHistogram(3), nil}, + sample{0, 6, 0, tsdbutil.GenerateTestGaugeHistogram(6), nil}, }), }, expectedMinMaxTimes: []minMaxTimes{{1, 6}}, @@ -1267,21 +1267,21 @@ func TestPopulateWithTombSeriesIterators(t *testing.T) { name: "one gauge histogram chunk intersect with earlier deletion interval", samples: [][]chunks.Sample{ { - sample{1, 0, tsdbutil.GenerateTestGaugeHistogram(1), nil}, - sample{2, 0, tsdbutil.GenerateTestGaugeHistogram(2), nil}, - sample{3, 0, tsdbutil.GenerateTestGaugeHistogram(3), nil}, - sample{6, 0, tsdbutil.GenerateTestGaugeHistogram(6), nil}, + sample{0, 1, 0, tsdbutil.GenerateTestGaugeHistogram(1), nil}, + sample{0, 2, 0, tsdbutil.GenerateTestGaugeHistogram(2), nil}, + sample{0, 3, 0, tsdbutil.GenerateTestGaugeHistogram(3), nil}, + sample{0, 6, 0, tsdbutil.GenerateTestGaugeHistogram(6), nil}, }, }, intervals: tombstones.Intervals{{Mint: 1, Maxt: 2}}, expected: []chunks.Sample{ - sample{3, 0, tsdbutil.GenerateTestGaugeHistogram(3), nil}, - sample{6, 0, tsdbutil.GenerateTestGaugeHistogram(6), nil}, + sample{0, 3, 0, tsdbutil.GenerateTestGaugeHistogram(3), nil}, + sample{0, 6, 0, tsdbutil.GenerateTestGaugeHistogram(6), nil}, }, expectedChks: []chunks.Meta{ assureChunkFromSamples(t, []chunks.Sample{ - sample{3, 0, tsdbutil.GenerateTestGaugeHistogram(3), nil}, - sample{6, 0, tsdbutil.GenerateTestGaugeHistogram(6), nil}, + sample{0, 3, 0, tsdbutil.GenerateTestGaugeHistogram(3), nil}, + sample{0, 6, 0, tsdbutil.GenerateTestGaugeHistogram(6), nil}, }), }, expectedMinMaxTimes: []minMaxTimes{{3, 6}}, @@ -1290,23 +1290,23 @@ func TestPopulateWithTombSeriesIterators(t *testing.T) { name: "one gauge histogram chunk intersect with later deletion interval", samples: [][]chunks.Sample{ { - sample{1, 0, tsdbutil.GenerateTestGaugeHistogram(1), nil}, - sample{2, 0, tsdbutil.GenerateTestGaugeHistogram(2), nil}, - sample{3, 0, tsdbutil.GenerateTestGaugeHistogram(3), nil}, - sample{6, 0, tsdbutil.GenerateTestGaugeHistogram(6), nil}, + sample{0, 1, 0, tsdbutil.GenerateTestGaugeHistogram(1), nil}, + sample{0, 2, 0, tsdbutil.GenerateTestGaugeHistogram(2), nil}, + sample{0, 3, 0, tsdbutil.GenerateTestGaugeHistogram(3), nil}, + sample{0, 6, 0, tsdbutil.GenerateTestGaugeHistogram(6), nil}, }, }, intervals: tombstones.Intervals{{Mint: 5, Maxt: 20}}, expected: []chunks.Sample{ - sample{1, 0, tsdbutil.GenerateTestGaugeHistogram(1), nil}, - sample{2, 0, tsdbutil.GenerateTestGaugeHistogram(2), nil}, - sample{3, 0, tsdbutil.GenerateTestGaugeHistogram(3), nil}, + sample{0, 1, 0, tsdbutil.GenerateTestGaugeHistogram(1), nil}, + sample{0, 2, 0, tsdbutil.GenerateTestGaugeHistogram(2), nil}, + sample{0, 3, 0, tsdbutil.GenerateTestGaugeHistogram(3), nil}, }, expectedChks: []chunks.Meta{ assureChunkFromSamples(t, []chunks.Sample{ - sample{1, 0, tsdbutil.GenerateTestGaugeHistogram(1), nil}, - sample{2, 0, tsdbutil.GenerateTestGaugeHistogram(2), nil}, - sample{3, 0, tsdbutil.GenerateTestGaugeHistogram(3), nil}, + sample{0, 1, 0, tsdbutil.GenerateTestGaugeHistogram(1), nil}, + sample{0, 2, 0, tsdbutil.GenerateTestGaugeHistogram(2), nil}, + sample{0, 3, 0, tsdbutil.GenerateTestGaugeHistogram(3), nil}, }), }, expectedMinMaxTimes: []minMaxTimes{{1, 3}}, @@ -1315,24 +1315,24 @@ func TestPopulateWithTombSeriesIterators(t *testing.T) { name: "one gauge float histogram", samples: [][]chunks.Sample{ { - sample{1, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(1)}, - sample{2, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(2)}, - sample{3, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3)}, - sample{6, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(6)}, + sample{0, 1, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(1)}, + sample{0, 2, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(2)}, + sample{0, 3, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3)}, + sample{0, 6, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(6)}, }, }, expected: []chunks.Sample{ - sample{1, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(1)}, - sample{2, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(2)}, - sample{3, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3)}, - sample{6, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(6)}, + sample{0, 1, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(1)}, + sample{0, 2, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(2)}, + sample{0, 3, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3)}, + sample{0, 6, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(6)}, }, expectedChks: []chunks.Meta{ assureChunkFromSamples(t, []chunks.Sample{ - sample{1, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(1)}, - sample{2, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(2)}, - sample{3, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3)}, - sample{6, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(6)}, + sample{0, 1, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(1)}, + sample{0, 2, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(2)}, + sample{0, 3, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3)}, + sample{0, 6, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(6)}, }), }, expectedMinMaxTimes: []minMaxTimes{{1, 6}}, @@ -1341,21 +1341,21 @@ func TestPopulateWithTombSeriesIterators(t *testing.T) { name: "one gauge float histogram chunk intersect with earlier deletion interval", samples: [][]chunks.Sample{ { - sample{1, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(1)}, - sample{2, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(2)}, - sample{3, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3)}, - sample{6, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(6)}, + sample{0, 1, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(1)}, + sample{0, 2, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(2)}, + sample{0, 3, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3)}, + sample{0, 6, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(6)}, }, }, intervals: tombstones.Intervals{{Mint: 1, Maxt: 2}}, expected: []chunks.Sample{ - sample{3, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3)}, - sample{6, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(6)}, + sample{0, 3, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3)}, + sample{0, 6, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(6)}, }, expectedChks: []chunks.Meta{ assureChunkFromSamples(t, []chunks.Sample{ - sample{3, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3)}, - sample{6, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(6)}, + sample{0, 3, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3)}, + sample{0, 6, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(6)}, }), }, expectedMinMaxTimes: []minMaxTimes{{3, 6}}, @@ -1364,23 +1364,23 @@ func TestPopulateWithTombSeriesIterators(t *testing.T) { name: "one gauge float histogram chunk intersect with later deletion interval", samples: [][]chunks.Sample{ { - sample{1, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(1)}, - sample{2, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(2)}, - sample{3, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3)}, - sample{6, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(6)}, + sample{0, 1, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(1)}, + sample{0, 2, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(2)}, + sample{0, 3, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3)}, + sample{0, 6, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(6)}, }, }, intervals: tombstones.Intervals{{Mint: 5, Maxt: 20}}, expected: []chunks.Sample{ - sample{1, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(1)}, - sample{2, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(2)}, - sample{3, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3)}, + sample{0, 1, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(1)}, + sample{0, 2, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(2)}, + sample{0, 3, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3)}, }, expectedChks: []chunks.Meta{ assureChunkFromSamples(t, []chunks.Sample{ - sample{1, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(1)}, - sample{2, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(2)}, - sample{3, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3)}, + sample{0, 1, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(1)}, + sample{0, 2, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(2)}, + sample{0, 3, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3)}, }), }, expectedMinMaxTimes: []minMaxTimes{{1, 3}}, @@ -1388,31 +1388,31 @@ func TestPopulateWithTombSeriesIterators(t *testing.T) { { name: "three full mixed chunks", samples: [][]chunks.Sample{ - {sample{1, 2, nil, nil}, sample{2, 3, nil, nil}, sample{3, 5, nil, nil}, sample{6, 1, nil, nil}}, + {sample{0, 1, 2, nil, nil}, sample{0, 2, 3, nil, nil}, sample{0, 3, 5, nil, nil}, sample{0, 6, 1, nil, nil}}, { - sample{7, 0, tsdbutil.GenerateTestGaugeHistogram(89), nil}, - sample{9, 0, tsdbutil.GenerateTestGaugeHistogram(8), nil}, + sample{0, 7, 0, tsdbutil.GenerateTestGaugeHistogram(89), nil}, + sample{0, 9, 0, tsdbutil.GenerateTestGaugeHistogram(8), nil}, }, { - sample{10, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(22)}, - sample{203, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3493)}, + sample{0, 10, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(22)}, + sample{0, 203, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3493)}, }, }, expected: []chunks.Sample{ - sample{1, 2, nil, nil}, sample{2, 3, nil, nil}, sample{3, 5, nil, nil}, sample{6, 1, nil, nil}, sample{7, 0, tsdbutil.GenerateTestGaugeHistogram(89), nil}, sample{9, 0, tsdbutil.GenerateTestGaugeHistogram(8), nil}, sample{10, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(22)}, sample{203, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3493)}, + sample{0, 1, 2, nil, nil}, sample{0, 2, 3, nil, nil}, sample{0, 3, 5, nil, nil}, sample{0, 6, 1, nil, nil}, sample{0, 7, 0, tsdbutil.GenerateTestGaugeHistogram(89), nil}, sample{0, 9, 0, tsdbutil.GenerateTestGaugeHistogram(8), nil}, sample{0, 10, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(22)}, sample{0, 203, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3493)}, }, expectedChks: []chunks.Meta{ assureChunkFromSamples(t, []chunks.Sample{ - sample{1, 2, nil, nil}, sample{2, 3, nil, nil}, sample{3, 5, nil, nil}, sample{6, 1, nil, nil}, + sample{0, 1, 2, nil, nil}, sample{0, 2, 3, nil, nil}, sample{0, 3, 5, nil, nil}, sample{0, 6, 1, nil, nil}, }), assureChunkFromSamples(t, []chunks.Sample{ - sample{7, 0, tsdbutil.GenerateTestGaugeHistogram(89), nil}, - sample{9, 0, tsdbutil.GenerateTestGaugeHistogram(8), nil}, + sample{0, 7, 0, tsdbutil.GenerateTestGaugeHistogram(89), nil}, + sample{0, 9, 0, tsdbutil.GenerateTestGaugeHistogram(8), nil}, }), assureChunkFromSamples(t, []chunks.Sample{ - sample{10, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(22)}, - sample{203, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3493)}, + sample{0, 10, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(22)}, + sample{0, 203, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3493)}, }), }, expectedMinMaxTimes: []minMaxTimes{{1, 6}, {7, 9}, {10, 203}}, @@ -1421,30 +1421,30 @@ func TestPopulateWithTombSeriesIterators(t *testing.T) { name: "three full mixed chunks in different order", samples: [][]chunks.Sample{ { - sample{7, 0, tsdbutil.GenerateTestGaugeHistogram(89), nil}, - sample{9, 0, tsdbutil.GenerateTestGaugeHistogram(8), nil}, + sample{0, 7, 0, tsdbutil.GenerateTestGaugeHistogram(89), nil}, + sample{0, 9, 0, tsdbutil.GenerateTestGaugeHistogram(8), nil}, }, - {sample{11, 2, nil, nil}, sample{12, 3, nil, nil}, sample{13, 5, nil, nil}, sample{16, 1, nil, nil}}, + {sample{0, 11, 2, nil, nil}, sample{0, 12, 3, nil, nil}, sample{0, 13, 5, nil, nil}, sample{0, 16, 1, nil, nil}}, { - sample{100, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(22)}, - sample{203, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3493)}, + sample{0, 100, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(22)}, + sample{0, 203, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3493)}, }, }, expected: []chunks.Sample{ - sample{7, 0, tsdbutil.GenerateTestGaugeHistogram(89), nil}, sample{9, 0, tsdbutil.GenerateTestGaugeHistogram(8), nil}, sample{11, 2, nil, nil}, sample{12, 3, nil, nil}, sample{13, 5, nil, nil}, sample{16, 1, nil, nil}, sample{100, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(22)}, sample{203, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3493)}, + sample{0, 7, 0, tsdbutil.GenerateTestGaugeHistogram(89), nil}, sample{0, 9, 0, tsdbutil.GenerateTestGaugeHistogram(8), nil}, sample{0, 11, 2, nil, nil}, sample{0, 12, 3, nil, nil}, sample{0, 13, 5, nil, nil}, sample{0, 16, 1, nil, nil}, sample{0, 100, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(22)}, sample{0, 203, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3493)}, }, expectedChks: []chunks.Meta{ assureChunkFromSamples(t, []chunks.Sample{ - sample{7, 0, tsdbutil.GenerateTestGaugeHistogram(89), nil}, - sample{9, 0, tsdbutil.GenerateTestGaugeHistogram(8), nil}, + sample{0, 7, 0, tsdbutil.GenerateTestGaugeHistogram(89), nil}, + sample{0, 9, 0, tsdbutil.GenerateTestGaugeHistogram(8), nil}, }), assureChunkFromSamples(t, []chunks.Sample{ - sample{11, 2, nil, nil}, sample{12, 3, nil, nil}, sample{13, 5, nil, nil}, sample{16, 1, nil, nil}, + sample{0, 11, 2, nil, nil}, sample{0, 12, 3, nil, nil}, sample{0, 13, 5, nil, nil}, sample{0, 16, 1, nil, nil}, }), assureChunkFromSamples(t, []chunks.Sample{ - sample{100, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(22)}, - sample{203, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3493)}, + sample{0, 100, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(22)}, + sample{0, 203, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3493)}, }), }, expectedMinMaxTimes: []minMaxTimes{{7, 9}, {11, 16}, {100, 203}}, @@ -1453,29 +1453,29 @@ func TestPopulateWithTombSeriesIterators(t *testing.T) { name: "three full mixed chunks in different order intersect with deletion interval", samples: [][]chunks.Sample{ { - sample{7, 0, tsdbutil.GenerateTestGaugeHistogram(89), nil}, - sample{9, 0, tsdbutil.GenerateTestGaugeHistogram(8), nil}, + sample{0, 7, 0, tsdbutil.GenerateTestGaugeHistogram(89), nil}, + sample{0, 9, 0, tsdbutil.GenerateTestGaugeHistogram(8), nil}, }, - {sample{11, 2, nil, nil}, sample{12, 3, nil, nil}, sample{13, 5, nil, nil}, sample{16, 1, nil, nil}}, + {sample{0, 11, 2, nil, nil}, sample{0, 12, 3, nil, nil}, sample{0, 13, 5, nil, nil}, sample{0, 16, 1, nil, nil}}, { - sample{100, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(22)}, - sample{203, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3493)}, + sample{0, 100, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(22)}, + sample{0, 203, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3493)}, }, }, intervals: tombstones.Intervals{{Mint: 8, Maxt: 11}, {Mint: 15, Maxt: 150}}, expected: []chunks.Sample{ - sample{7, 0, tsdbutil.GenerateTestGaugeHistogram(89), nil}, sample{12, 3, nil, nil}, sample{13, 5, nil, nil}, sample{203, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3493)}, + sample{0, 7, 0, tsdbutil.GenerateTestGaugeHistogram(89), nil}, sample{0, 12, 3, nil, nil}, sample{0, 13, 5, nil, nil}, sample{0, 203, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3493)}, }, expectedChks: []chunks.Meta{ assureChunkFromSamples(t, []chunks.Sample{ - sample{7, 0, tsdbutil.GenerateTestGaugeHistogram(89), nil}, + sample{0, 7, 0, tsdbutil.GenerateTestGaugeHistogram(89), nil}, }), assureChunkFromSamples(t, []chunks.Sample{ - sample{12, 3, nil, nil}, sample{13, 5, nil, nil}, + sample{0, 12, 3, nil, nil}, sample{0, 13, 5, nil, nil}, }), assureChunkFromSamples(t, []chunks.Sample{ - sample{203, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3493)}, + sample{0, 203, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3493)}, }), }, expectedMinMaxTimes: []minMaxTimes{{7, 7}, {12, 13}, {203, 203}}, @@ -1484,30 +1484,30 @@ func TestPopulateWithTombSeriesIterators(t *testing.T) { name: "three full mixed chunks overlapping", samples: [][]chunks.Sample{ { - sample{7, 0, tsdbutil.GenerateTestGaugeHistogram(89), nil}, - sample{12, 0, tsdbutil.GenerateTestGaugeHistogram(8), nil}, + sample{0, 7, 0, tsdbutil.GenerateTestGaugeHistogram(89), nil}, + sample{0, 12, 0, tsdbutil.GenerateTestGaugeHistogram(8), nil}, }, - {sample{11, 2, nil, nil}, sample{12, 3, nil, nil}, sample{13, 5, nil, nil}, sample{16, 1, nil, nil}}, + {sample{0, 11, 2, nil, nil}, sample{0, 12, 3, nil, nil}, sample{0, 13, 5, nil, nil}, sample{0, 16, 1, nil, nil}}, { - sample{10, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(22)}, - sample{203, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3493)}, + sample{0, 10, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(22)}, + sample{0, 203, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3493)}, }, }, expected: []chunks.Sample{ - sample{7, 0, tsdbutil.GenerateTestGaugeHistogram(89), nil}, sample{12, 0, tsdbutil.GenerateTestGaugeHistogram(8), nil}, sample{11, 2, nil, nil}, sample{12, 3, nil, nil}, sample{13, 5, nil, nil}, sample{16, 1, nil, nil}, sample{10, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(22)}, sample{203, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3493)}, + sample{0, 7, 0, tsdbutil.GenerateTestGaugeHistogram(89), nil}, sample{0, 12, 0, tsdbutil.GenerateTestGaugeHistogram(8), nil}, sample{0, 11, 2, nil, nil}, sample{0, 12, 3, nil, nil}, sample{0, 13, 5, nil, nil}, sample{0, 16, 1, nil, nil}, sample{0, 10, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(22)}, sample{0, 203, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3493)}, }, expectedChks: []chunks.Meta{ assureChunkFromSamples(t, []chunks.Sample{ - sample{7, 0, tsdbutil.GenerateTestGaugeHistogram(89), nil}, - sample{12, 0, tsdbutil.GenerateTestGaugeHistogram(8), nil}, + sample{0, 7, 0, tsdbutil.GenerateTestGaugeHistogram(89), nil}, + sample{0, 12, 0, tsdbutil.GenerateTestGaugeHistogram(8), nil}, }), assureChunkFromSamples(t, []chunks.Sample{ - sample{11, 2, nil, nil}, sample{12, 3, nil, nil}, sample{13, 5, nil, nil}, sample{16, 1, nil, nil}, + sample{0, 11, 2, nil, nil}, sample{0, 12, 3, nil, nil}, sample{0, 13, 5, nil, nil}, sample{0, 16, 1, nil, nil}, }), assureChunkFromSamples(t, []chunks.Sample{ - sample{10, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(22)}, - sample{203, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3493)}, + sample{0, 10, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(22)}, + sample{0, 203, 0, nil, tsdbutil.GenerateTestGaugeFloatHistogram(3493)}, }), }, expectedMinMaxTimes: []minMaxTimes{{7, 12}, {11, 16}, {10, 203}}, @@ -1516,56 +1516,56 @@ func TestPopulateWithTombSeriesIterators(t *testing.T) { name: "int histogram iterables with counter resets", samples: [][]chunks.Sample{ { - sample{7, 0, tsdbutil.GenerateTestHistogram(8), nil}, - sample{8, 0, tsdbutil.GenerateTestHistogram(9), nil}, + sample{0, 7, 0, tsdbutil.GenerateTestHistogram(8), nil}, + sample{0, 8, 0, tsdbutil.GenerateTestHistogram(9), nil}, // Counter reset should be detected when chunks are created from the iterable. - sample{12, 0, tsdbutil.GenerateTestHistogram(5), nil}, - sample{15, 0, tsdbutil.GenerateTestHistogram(6), nil}, - sample{16, 0, tsdbutil.GenerateTestHistogram(7), nil}, + sample{0, 12, 0, tsdbutil.GenerateTestHistogram(5), nil}, + sample{0, 15, 0, tsdbutil.GenerateTestHistogram(6), nil}, + sample{0, 16, 0, tsdbutil.GenerateTestHistogram(7), nil}, // Counter reset should be detected when chunks are created from the iterable. - sample{17, 0, tsdbutil.GenerateTestHistogram(5), nil}, + sample{0, 17, 0, tsdbutil.GenerateTestHistogram(5), nil}, }, { - sample{18, 0, tsdbutil.GenerateTestHistogram(6), nil}, - sample{19, 0, tsdbutil.GenerateTestHistogram(7), nil}, + sample{0, 18, 0, tsdbutil.GenerateTestHistogram(6), nil}, + sample{0, 19, 0, tsdbutil.GenerateTestHistogram(7), nil}, // Counter reset should be detected when chunks are created from the iterable. - sample{20, 0, tsdbutil.GenerateTestHistogram(5), nil}, - sample{21, 0, tsdbutil.GenerateTestHistogram(6), nil}, + sample{0, 20, 0, tsdbutil.GenerateTestHistogram(5), nil}, + sample{0, 21, 0, tsdbutil.GenerateTestHistogram(6), nil}, }, }, expected: []chunks.Sample{ - sample{7, 0, tsdbutil.GenerateTestHistogram(8), nil}, - sample{8, 0, tsdbutil.GenerateTestHistogram(9), nil}, - sample{12, 0, tsdbutil.GenerateTestHistogram(5), nil}, - sample{15, 0, tsdbutil.GenerateTestHistogram(6), nil}, - sample{16, 0, tsdbutil.GenerateTestHistogram(7), nil}, - sample{17, 0, tsdbutil.GenerateTestHistogram(5), nil}, - sample{18, 0, tsdbutil.GenerateTestHistogram(6), nil}, - sample{19, 0, tsdbutil.GenerateTestHistogram(7), nil}, - sample{20, 0, tsdbutil.GenerateTestHistogram(5), nil}, - sample{21, 0, tsdbutil.GenerateTestHistogram(6), nil}, + sample{0, 7, 0, tsdbutil.GenerateTestHistogram(8), nil}, + sample{0, 8, 0, tsdbutil.GenerateTestHistogram(9), nil}, + sample{0, 12, 0, tsdbutil.GenerateTestHistogram(5), nil}, + sample{0, 15, 0, tsdbutil.GenerateTestHistogram(6), nil}, + sample{0, 16, 0, tsdbutil.GenerateTestHistogram(7), nil}, + sample{0, 17, 0, tsdbutil.GenerateTestHistogram(5), nil}, + sample{0, 18, 0, tsdbutil.GenerateTestHistogram(6), nil}, + sample{0, 19, 0, tsdbutil.GenerateTestHistogram(7), nil}, + sample{0, 20, 0, tsdbutil.GenerateTestHistogram(5), nil}, + sample{0, 21, 0, tsdbutil.GenerateTestHistogram(6), nil}, }, expectedChks: []chunks.Meta{ assureChunkFromSamples(t, []chunks.Sample{ - sample{7, 0, tsdbutil.GenerateTestHistogram(8), nil}, - sample{8, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(9)), nil}, + sample{0, 7, 0, tsdbutil.GenerateTestHistogram(8), nil}, + sample{0, 8, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(9)), nil}, }), assureChunkFromSamples(t, []chunks.Sample{ - sample{12, 0, tsdbutil.SetHistogramCounterReset(tsdbutil.GenerateTestHistogram(5)), nil}, - sample{15, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(6)), nil}, - sample{16, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(7)), nil}, + sample{0, 12, 0, tsdbutil.SetHistogramCounterReset(tsdbutil.GenerateTestHistogram(5)), nil}, + sample{0, 15, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(6)), nil}, + sample{0, 16, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(7)), nil}, }), assureChunkFromSamples(t, []chunks.Sample{ - sample{17, 0, tsdbutil.SetHistogramCounterReset(tsdbutil.GenerateTestHistogram(5)), nil}, + sample{0, 17, 0, tsdbutil.SetHistogramCounterReset(tsdbutil.GenerateTestHistogram(5)), nil}, }), assureChunkFromSamples(t, []chunks.Sample{ - sample{18, 0, tsdbutil.GenerateTestHistogram(6), nil}, - sample{19, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(7)), nil}, + sample{0, 18, 0, tsdbutil.GenerateTestHistogram(6), nil}, + sample{0, 19, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(7)), nil}, }), assureChunkFromSamples(t, []chunks.Sample{ - sample{20, 0, tsdbutil.SetHistogramCounterReset(tsdbutil.GenerateTestHistogram(5)), nil}, - sample{21, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(6)), nil}, + sample{0, 20, 0, tsdbutil.SetHistogramCounterReset(tsdbutil.GenerateTestHistogram(5)), nil}, + sample{0, 21, 0, tsdbutil.SetHistogramNotCounterReset(tsdbutil.GenerateTestHistogram(6)), nil}, }), }, expectedMinMaxTimes: []minMaxTimes{ @@ -1585,56 +1585,56 @@ func TestPopulateWithTombSeriesIterators(t *testing.T) { name: "float histogram iterables with counter resets", samples: [][]chunks.Sample{ { - sample{7, 0, nil, tsdbutil.GenerateTestFloatHistogram(8)}, - sample{8, 0, nil, tsdbutil.GenerateTestFloatHistogram(9)}, + sample{0, 7, 0, nil, tsdbutil.GenerateTestFloatHistogram(8)}, + sample{0, 8, 0, nil, tsdbutil.GenerateTestFloatHistogram(9)}, // Counter reset should be detected when chunks are created from the iterable. - sample{12, 0, nil, tsdbutil.GenerateTestFloatHistogram(5)}, - sample{15, 0, nil, tsdbutil.GenerateTestFloatHistogram(6)}, - sample{16, 0, nil, tsdbutil.GenerateTestFloatHistogram(7)}, + sample{0, 12, 0, nil, tsdbutil.GenerateTestFloatHistogram(5)}, + sample{0, 15, 0, nil, tsdbutil.GenerateTestFloatHistogram(6)}, + sample{0, 16, 0, nil, tsdbutil.GenerateTestFloatHistogram(7)}, // Counter reset should be detected when chunks are created from the iterable. - sample{17, 0, nil, tsdbutil.GenerateTestFloatHistogram(5)}, + sample{0, 17, 0, nil, tsdbutil.GenerateTestFloatHistogram(5)}, }, { - sample{18, 0, nil, tsdbutil.GenerateTestFloatHistogram(6)}, - sample{19, 0, nil, tsdbutil.GenerateTestFloatHistogram(7)}, + sample{0, 18, 0, nil, tsdbutil.GenerateTestFloatHistogram(6)}, + sample{0, 19, 0, nil, tsdbutil.GenerateTestFloatHistogram(7)}, // Counter reset should be detected when chunks are created from the iterable. - sample{20, 0, nil, tsdbutil.GenerateTestFloatHistogram(5)}, - sample{21, 0, nil, tsdbutil.GenerateTestFloatHistogram(6)}, + sample{0, 20, 0, nil, tsdbutil.GenerateTestFloatHistogram(5)}, + sample{0, 21, 0, nil, tsdbutil.GenerateTestFloatHistogram(6)}, }, }, expected: []chunks.Sample{ - sample{7, 0, nil, tsdbutil.GenerateTestFloatHistogram(8)}, - sample{8, 0, nil, tsdbutil.GenerateTestFloatHistogram(9)}, - sample{12, 0, nil, tsdbutil.GenerateTestFloatHistogram(5)}, - sample{15, 0, nil, tsdbutil.GenerateTestFloatHistogram(6)}, - sample{16, 0, nil, tsdbutil.GenerateTestFloatHistogram(7)}, - sample{17, 0, nil, tsdbutil.GenerateTestFloatHistogram(5)}, - sample{18, 0, nil, tsdbutil.GenerateTestFloatHistogram(6)}, - sample{19, 0, nil, tsdbutil.GenerateTestFloatHistogram(7)}, - sample{20, 0, nil, tsdbutil.GenerateTestFloatHistogram(5)}, - sample{21, 0, nil, tsdbutil.GenerateTestFloatHistogram(6)}, + sample{0, 7, 0, nil, tsdbutil.GenerateTestFloatHistogram(8)}, + sample{0, 8, 0, nil, tsdbutil.GenerateTestFloatHistogram(9)}, + sample{0, 12, 0, nil, tsdbutil.GenerateTestFloatHistogram(5)}, + sample{0, 15, 0, nil, tsdbutil.GenerateTestFloatHistogram(6)}, + sample{0, 16, 0, nil, tsdbutil.GenerateTestFloatHistogram(7)}, + sample{0, 17, 0, nil, tsdbutil.GenerateTestFloatHistogram(5)}, + sample{0, 18, 0, nil, tsdbutil.GenerateTestFloatHistogram(6)}, + sample{0, 19, 0, nil, tsdbutil.GenerateTestFloatHistogram(7)}, + sample{0, 20, 0, nil, tsdbutil.GenerateTestFloatHistogram(5)}, + sample{0, 21, 0, nil, tsdbutil.GenerateTestFloatHistogram(6)}, }, expectedChks: []chunks.Meta{ assureChunkFromSamples(t, []chunks.Sample{ - sample{7, 0, nil, tsdbutil.GenerateTestFloatHistogram(8)}, - sample{8, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(9))}, + sample{0, 7, 0, nil, tsdbutil.GenerateTestFloatHistogram(8)}, + sample{0, 8, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(9))}, }), assureChunkFromSamples(t, []chunks.Sample{ - sample{12, 0, nil, tsdbutil.SetFloatHistogramCounterReset(tsdbutil.GenerateTestFloatHistogram(5))}, - sample{15, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(6))}, - sample{16, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(7))}, + sample{0, 12, 0, nil, tsdbutil.SetFloatHistogramCounterReset(tsdbutil.GenerateTestFloatHistogram(5))}, + sample{0, 15, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(6))}, + sample{0, 16, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(7))}, }), assureChunkFromSamples(t, []chunks.Sample{ - sample{17, 0, nil, tsdbutil.SetFloatHistogramCounterReset(tsdbutil.GenerateTestFloatHistogram(5))}, + sample{0, 17, 0, nil, tsdbutil.SetFloatHistogramCounterReset(tsdbutil.GenerateTestFloatHistogram(5))}, }), assureChunkFromSamples(t, []chunks.Sample{ - sample{18, 0, nil, tsdbutil.GenerateTestFloatHistogram(6)}, - sample{19, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(7))}, + sample{0, 18, 0, nil, tsdbutil.GenerateTestFloatHistogram(6)}, + sample{0, 19, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(7))}, }), assureChunkFromSamples(t, []chunks.Sample{ - sample{20, 0, nil, tsdbutil.SetFloatHistogramCounterReset(tsdbutil.GenerateTestFloatHistogram(5))}, - sample{21, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(6))}, + sample{0, 20, 0, nil, tsdbutil.SetFloatHistogramCounterReset(tsdbutil.GenerateTestFloatHistogram(5))}, + sample{0, 21, 0, nil, tsdbutil.SetFloatHistogramNotCounterReset(tsdbutil.GenerateTestFloatHistogram(6))}, }), }, expectedMinMaxTimes: []minMaxTimes{ @@ -1654,61 +1654,61 @@ func TestPopulateWithTombSeriesIterators(t *testing.T) { name: "iterables with mixed encodings and counter resets", samples: [][]chunks.Sample{ { - sample{7, 0, tsdbutil.GenerateTestHistogram(8), nil}, - sample{8, 0, tsdbutil.GenerateTestHistogram(9), nil}, - sample{9, 0, nil, tsdbutil.GenerateTestFloatHistogram(10)}, - sample{10, 0, nil, tsdbutil.GenerateTestFloatHistogram(11)}, - sample{11, 0, nil, tsdbutil.GenerateTestFloatHistogram(12)}, - sample{12, 13, nil, nil}, - sample{13, 14, nil, nil}, - sample{14, 0, tsdbutil.GenerateTestHistogram(8), nil}, + sample{0, 7, 0, tsdbutil.GenerateTestHistogram(8), nil}, + sample{0, 8, 0, tsdbutil.GenerateTestHistogram(9), nil}, + sample{0, 9, 0, nil, tsdbutil.GenerateTestFloatHistogram(10)}, + sample{0, 10, 0, nil, tsdbutil.GenerateTestFloatHistogram(11)}, + sample{0, 11, 0, nil, tsdbutil.GenerateTestFloatHistogram(12)}, + sample{0, 12, 13, nil, nil}, + sample{0, 13, 14, nil, nil}, + sample{0, 14, 0, tsdbutil.GenerateTestHistogram(8), nil}, // Counter reset should be detected when chunks are created from the iterable. - sample{15, 0, tsdbutil.GenerateTestHistogram(7), nil}, + sample{0, 15, 0, tsdbutil.GenerateTestHistogram(7), nil}, }, { - sample{18, 0, tsdbutil.GenerateTestHistogram(6), nil}, - sample{19, 45, nil, nil}, + sample{0, 18, 0, tsdbutil.GenerateTestHistogram(6), nil}, + sample{0, 19, 45, nil, nil}, }, }, expected: []chunks.Sample{ - sample{7, 0, tsdbutil.GenerateTestHistogram(8), nil}, - sample{8, 0, tsdbutil.GenerateTestHistogram(9), nil}, - sample{9, 0, nil, tsdbutil.GenerateTestFloatHistogram(10)}, - sample{10, 0, nil, tsdbutil.GenerateTestFloatHistogram(11)}, - sample{11, 0, nil, tsdbutil.GenerateTestFloatHistogram(12)}, - sample{12, 13, nil, nil}, - sample{13, 14, nil, nil}, - sample{14, 0, tsdbutil.GenerateTestHistogram(8), nil}, - sample{15, 0, tsdbutil.GenerateTestHistogram(7), nil}, - sample{18, 0, tsdbutil.GenerateTestHistogram(6), nil}, - sample{19, 45, nil, nil}, + sample{0, 7, 0, tsdbutil.GenerateTestHistogram(8), nil}, + sample{0, 8, 0, tsdbutil.GenerateTestHistogram(9), nil}, + sample{0, 9, 0, nil, tsdbutil.GenerateTestFloatHistogram(10)}, + sample{0, 10, 0, nil, tsdbutil.GenerateTestFloatHistogram(11)}, + sample{0, 11, 0, nil, tsdbutil.GenerateTestFloatHistogram(12)}, + sample{0, 12, 13, nil, nil}, + sample{0, 13, 14, nil, nil}, + sample{0, 14, 0, tsdbutil.GenerateTestHistogram(8), nil}, + sample{0, 15, 0, tsdbutil.GenerateTestHistogram(7), nil}, + sample{0, 18, 0, tsdbutil.GenerateTestHistogram(6), nil}, + sample{0, 19, 45, nil, nil}, }, expectedChks: []chunks.Meta{ assureChunkFromSamples(t, []chunks.Sample{ - sample{7, 0, tsdbutil.GenerateTestHistogram(8), nil}, - sample{8, 0, tsdbutil.GenerateTestHistogram(9), nil}, + sample{0, 7, 0, tsdbutil.GenerateTestHistogram(8), nil}, + sample{0, 8, 0, tsdbutil.GenerateTestHistogram(9), nil}, }), assureChunkFromSamples(t, []chunks.Sample{ - sample{9, 0, nil, tsdbutil.GenerateTestFloatHistogram(10)}, - sample{10, 0, nil, tsdbutil.GenerateTestFloatHistogram(11)}, - sample{11, 0, nil, tsdbutil.GenerateTestFloatHistogram(12)}, + sample{0, 9, 0, nil, tsdbutil.GenerateTestFloatHistogram(10)}, + sample{0, 10, 0, nil, tsdbutil.GenerateTestFloatHistogram(11)}, + sample{0, 11, 0, nil, tsdbutil.GenerateTestFloatHistogram(12)}, }), assureChunkFromSamples(t, []chunks.Sample{ - sample{12, 13, nil, nil}, - sample{13, 14, nil, nil}, + sample{0, 12, 13, nil, nil}, + sample{0, 13, 14, nil, nil}, }), assureChunkFromSamples(t, []chunks.Sample{ - sample{14, 0, tsdbutil.GenerateTestHistogram(8), nil}, + sample{0, 14, 0, tsdbutil.GenerateTestHistogram(8), nil}, }), assureChunkFromSamples(t, []chunks.Sample{ - sample{15, 0, tsdbutil.SetHistogramCounterReset(tsdbutil.GenerateTestHistogram(7)), nil}, + sample{0, 15, 0, tsdbutil.SetHistogramCounterReset(tsdbutil.GenerateTestHistogram(7)), nil}, }), assureChunkFromSamples(t, []chunks.Sample{ - sample{18, 0, tsdbutil.GenerateTestHistogram(6), nil}, + sample{0, 18, 0, tsdbutil.GenerateTestHistogram(6), nil}, }), assureChunkFromSamples(t, []chunks.Sample{ - sample{19, 45, nil, nil}, + sample{0, 19, 45, nil, nil}, }), }, expectedMinMaxTimes: []minMaxTimes{ @@ -1849,8 +1849,8 @@ func TestPopulateWithDelSeriesIterator_DoubleSeek(t *testing.T) { valType: chunkenc.ValFloat, chks: [][]chunks.Sample{ {}, - {sample{1, 1, nil, nil}, sample{2, 2, nil, nil}, sample{3, 3, nil, nil}}, - {sample{4, 4, nil, nil}, sample{5, 5, nil, nil}}, + {sample{0, 1, 1, nil, nil}, sample{0, 2, 2, nil, nil}, sample{0, 3, 3, nil, nil}}, + {sample{0, 4, 4, nil, nil}, sample{0, 5, 5, nil, nil}}, }, }, { @@ -1858,8 +1858,8 @@ func TestPopulateWithDelSeriesIterator_DoubleSeek(t *testing.T) { valType: chunkenc.ValHistogram, chks: [][]chunks.Sample{ {}, - {sample{1, 0, tsdbutil.GenerateTestHistogram(1), nil}, sample{2, 0, tsdbutil.GenerateTestHistogram(2), nil}, sample{3, 0, tsdbutil.GenerateTestHistogram(3), nil}}, - {sample{4, 0, tsdbutil.GenerateTestHistogram(4), nil}, sample{5, 0, tsdbutil.GenerateTestHistogram(5), nil}}, + {sample{0, 1, 0, tsdbutil.GenerateTestHistogram(1), nil}, sample{0, 2, 0, tsdbutil.GenerateTestHistogram(2), nil}, sample{0, 3, 0, tsdbutil.GenerateTestHistogram(3), nil}}, + {sample{0, 4, 0, tsdbutil.GenerateTestHistogram(4), nil}, sample{0, 5, 0, tsdbutil.GenerateTestHistogram(5), nil}}, }, }, { @@ -1867,8 +1867,8 @@ func TestPopulateWithDelSeriesIterator_DoubleSeek(t *testing.T) { valType: chunkenc.ValFloatHistogram, chks: [][]chunks.Sample{ {}, - {sample{1, 0, nil, tsdbutil.GenerateTestFloatHistogram(1)}, sample{2, 0, nil, tsdbutil.GenerateTestFloatHistogram(2)}, sample{3, 0, nil, tsdbutil.GenerateTestFloatHistogram(3)}}, - {sample{4, 0, nil, tsdbutil.GenerateTestFloatHistogram(4)}, sample{5, 0, nil, tsdbutil.GenerateTestFloatHistogram(5)}}, + {sample{0, 1, 0, nil, tsdbutil.GenerateTestFloatHistogram(1)}, sample{0, 2, 0, nil, tsdbutil.GenerateTestFloatHistogram(2)}, sample{0, 3, 0, nil, tsdbutil.GenerateTestFloatHistogram(3)}}, + {sample{0, 4, 0, nil, tsdbutil.GenerateTestFloatHistogram(4)}, sample{0, 5, 0, nil, tsdbutil.GenerateTestFloatHistogram(5)}}, }, }, } @@ -1902,7 +1902,7 @@ func TestPopulateWithDelSeriesIterator_SeekInCurrentChunk(t *testing.T) { valType: chunkenc.ValFloat, chks: [][]chunks.Sample{ {}, - {sample{1, 2, nil, nil}, sample{3, 4, nil, nil}, sample{5, 6, nil, nil}, sample{7, 8, nil, nil}}, + {sample{0, 1, 2, nil, nil}, sample{0, 3, 4, nil, nil}, sample{0, 5, 6, nil, nil}, sample{0, 7, 8, nil, nil}}, {}, }, }, @@ -1911,7 +1911,7 @@ func TestPopulateWithDelSeriesIterator_SeekInCurrentChunk(t *testing.T) { valType: chunkenc.ValHistogram, chks: [][]chunks.Sample{ {}, - {sample{1, 0, tsdbutil.GenerateTestHistogram(2), nil}, sample{3, 0, tsdbutil.GenerateTestHistogram(4), nil}, sample{5, 0, tsdbutil.GenerateTestHistogram(6), nil}, sample{7, 0, tsdbutil.GenerateTestHistogram(8), nil}}, + {sample{0, 1, 0, tsdbutil.GenerateTestHistogram(2), nil}, sample{0, 3, 0, tsdbutil.GenerateTestHistogram(4), nil}, sample{0, 5, 0, tsdbutil.GenerateTestHistogram(6), nil}, sample{0, 7, 0, tsdbutil.GenerateTestHistogram(8), nil}}, {}, }, }, @@ -1920,7 +1920,7 @@ func TestPopulateWithDelSeriesIterator_SeekInCurrentChunk(t *testing.T) { valType: chunkenc.ValFloatHistogram, chks: [][]chunks.Sample{ {}, - {sample{1, 0, nil, tsdbutil.GenerateTestFloatHistogram(2)}, sample{3, 0, nil, tsdbutil.GenerateTestFloatHistogram(4)}, sample{5, 0, nil, tsdbutil.GenerateTestFloatHistogram(6)}, sample{7, 0, nil, tsdbutil.GenerateTestFloatHistogram(8)}}, + {sample{0, 1, 0, nil, tsdbutil.GenerateTestFloatHistogram(2)}, sample{0, 3, 0, nil, tsdbutil.GenerateTestFloatHistogram(4)}, sample{0, 5, 0, nil, tsdbutil.GenerateTestFloatHistogram(6)}, sample{0, 7, 0, nil, tsdbutil.GenerateTestFloatHistogram(8)}}, {}, }, }, @@ -1952,21 +1952,21 @@ func TestPopulateWithDelSeriesIterator_SeekWithMinTime(t *testing.T) { name: "float", valType: chunkenc.ValFloat, chks: [][]chunks.Sample{ - {sample{1, 6, nil, nil}, sample{5, 6, nil, nil}, sample{6, 8, nil, nil}}, + {sample{0, 1, 6, nil, nil}, sample{0, 5, 6, nil, nil}, sample{0, 6, 8, nil, nil}}, }, }, { name: "histogram", valType: chunkenc.ValHistogram, chks: [][]chunks.Sample{ - {sample{1, 0, tsdbutil.GenerateTestHistogram(6), nil}, sample{5, 0, tsdbutil.GenerateTestHistogram(6), nil}, sample{6, 0, tsdbutil.GenerateTestHistogram(8), nil}}, + {sample{0, 1, 0, tsdbutil.GenerateTestHistogram(6), nil}, sample{0, 5, 0, tsdbutil.GenerateTestHistogram(6), nil}, sample{0, 6, 0, tsdbutil.GenerateTestHistogram(8), nil}}, }, }, { name: "float histogram", valType: chunkenc.ValFloatHistogram, chks: [][]chunks.Sample{ - {sample{1, 0, nil, tsdbutil.GenerateTestFloatHistogram(6)}, sample{5, 0, nil, tsdbutil.GenerateTestFloatHistogram(6)}, sample{6, 0, nil, tsdbutil.GenerateTestFloatHistogram(8)}}, + {sample{0, 1, 0, nil, tsdbutil.GenerateTestFloatHistogram(6)}, sample{0, 5, 0, nil, tsdbutil.GenerateTestFloatHistogram(6)}, sample{0, 6, 0, nil, tsdbutil.GenerateTestFloatHistogram(8)}}, }, }, } @@ -1995,21 +1995,21 @@ func TestPopulateWithDelSeriesIterator_NextWithMinTime(t *testing.T) { name: "float", valType: chunkenc.ValFloat, chks: [][]chunks.Sample{ - {sample{1, 6, nil, nil}, sample{5, 6, nil, nil}, sample{7, 8, nil, nil}}, + {sample{0, 1, 6, nil, nil}, sample{0, 5, 6, nil, nil}, sample{0, 7, 8, nil, nil}}, }, }, { name: "histogram", valType: chunkenc.ValHistogram, chks: [][]chunks.Sample{ - {sample{1, 0, tsdbutil.GenerateTestHistogram(6), nil}, sample{5, 0, tsdbutil.GenerateTestHistogram(6), nil}, sample{7, 0, tsdbutil.GenerateTestHistogram(8), nil}}, + {sample{0, 1, 0, tsdbutil.GenerateTestHistogram(6), nil}, sample{0, 5, 0, tsdbutil.GenerateTestHistogram(6), nil}, sample{0, 7, 0, tsdbutil.GenerateTestHistogram(8), nil}}, }, }, { name: "float histogram", valType: chunkenc.ValFloatHistogram, chks: [][]chunks.Sample{ - {sample{1, 0, nil, tsdbutil.GenerateTestFloatHistogram(6)}, sample{5, 0, nil, tsdbutil.GenerateTestFloatHistogram(6)}, sample{7, 0, nil, tsdbutil.GenerateTestFloatHistogram(8)}}, + {sample{0, 1, 0, nil, tsdbutil.GenerateTestFloatHistogram(6)}, sample{0, 5, 0, nil, tsdbutil.GenerateTestFloatHistogram(6)}, sample{0, 7, 0, nil, tsdbutil.GenerateTestFloatHistogram(8)}}, }, }, }