query: chain deduplication on chunk level

Author: lachruzam

pkg/dedup/iter.go

@@ -21,9 +21,8 @@ const (
 )
 
 type dedupSeriesSet struct {
-	set               storage.SeriesSet
-	isCounter         bool
-	deduplicationFunc string
+	set       storage.SeriesSet
+	isCounter bool
 
 	replicas []storage.Series
 
@@ -110,7 +109,7 @@ func (o *overlapSplitSet) Err() error {
 // The series in series set are expected be sorted by all labels.
 func NewSeriesSet(set storage.SeriesSet, f string, deduplicationFunc string) storage.SeriesSet {
 	// TODO: remove dependency on knowing whether it is a counter.
-	s := &dedupSeriesSet{set: set, isCounter: isCounter(f), f: f, deduplicationFunc: deduplicationFunc}
+	s := &dedupSeriesSet{set: set, isCounter: isCounter(f), f: f}
 	s.ok = s.set.Next()
 	if s.ok {
 		s.peek = s.set.At()
@@ -160,11 +159,7 @@ func (s *dedupSeriesSet) At() storage.Series {
 	repl := make([]storage.Series, len(s.replicas))
 	copy(repl, s.replicas)
 
-	if s.deduplicationFunc == AlgorithmChain {
-		return seriesWithLabels{Series: storage.ChainedSeriesMerge(repl...), lset: s.lset}
-	} else {
-		return newDedupSeries(s.lset, repl, s.f)
-	}
+	return newDedupSeries(s.lset, repl, s.f)
 }
 
 func (s *dedupSeriesSet) Err() error {

pkg/dedup/iter_test.go

@@ -561,150 +561,6 @@ func TestDedupSeriesSet(t *testing.T) {
 	}
 }
 
-func TestDedupSeriesSet_Chain(t *testing.T) {
-	for _, tcase := range []struct {
-		name  string
-		input []series
-		exp   []series
-	}{
-		{
-			name: "Single dedup label - exact match",
-			input: []series{
-				{
-					lset:    labels.FromStrings("a", "1", "c", "3"),
-					samples: []sample{{10000, 1}, {20000, 2}, {30000, 3}},
-				},
-				{
-					lset:    labels.FromStrings("a", "1", "c", "3"),
-					samples: []sample{{10000, 1}, {20000, 2}, {30000, 3}},
-				},
-			},
-			exp: []series{
-				{
-					lset:    labels.FromStrings("a", "1", "c", "3"),
-					samples: []sample{{10000, 1}, {20000, 2}, {30000, 3}},
-				},
-			},
-		},
-		{
-			name: "Single dedup label - gap in one series",
-			input: []series{
-				{
-					lset:    labels.FromStrings("a", "1", "c", "3"),
-					samples: []sample{{10000, 1}, {30000, 3}},
-				},
-				{
-					lset:    labels.FromStrings("a", "1", "c", "3"),
-					samples: []sample{{10000, 1}, {20000, 2}, {30000, 3}},
-				},
-			},
-			exp: []series{
-				{
-					lset:    labels.FromStrings("a", "1", "c", "3"),
-					samples: []sample{{10000, 1}, {20000, 2}, {30000, 3}},
-				},
-			},
-		},
-		{
-			name: "Single dedup label - gaps in two series",
-			input: []series{
-				{
-					lset:    labels.FromStrings("a", "1", "c", "3"),
-					samples: []sample{{10000, 1}, {30000, 3}},
-				},
-				{
-					lset:    labels.FromStrings("a", "1", "c", "3"),
-					samples: []sample{{10000, 1}, {20000, 2}},
-				},
-			},
-			exp: []series{
-				{
-					lset:    labels.FromStrings("a", "1", "c", "3"),
-					samples: []sample{{10000, 1}, {20000, 2}, {30000, 3}},
-				},
-			},
-		},
-		{
-			name: "Multi dedup label - exact match",
-			input: []series{
-				{
-					lset:    labels.FromStrings("a", "1", "c", "3"),
-					samples: []sample{{10000, 1}, {20000, 2}, {30000, 3}},
-				},
-				{
-					lset:    labels.FromStrings("a", "1", "c", "3"),
-					samples: []sample{{10000, 1}, {20000, 2}, {30000, 3}},
-				},
-				{
-					lset:    labels.FromStrings("a", "2", "c", "3"),
-					samples: []sample{{10000, 101}, {20000, 102}, {30000, 103}},
-				},
-				{
-					lset:    labels.FromStrings("a", "2", "c", "3"),
-					samples: []sample{{10000, 101}, {20000, 102}, {30000, 103}},
-				},
-			},
-			exp: []series{
-				{
-					lset:    labels.FromStrings("a", "1", "c", "3"),
-					samples: []sample{{10000, 1}, {20000, 2}, {30000, 3}},
-				},
-				{
-					lset:    labels.FromStrings("a", "2", "c", "3"),
-					samples: []sample{{10000, 101}, {20000, 102}, {30000, 103}},
-				},
-			},
-		},
-		{
-			name: "Multi dedup label - gaps in two series",
-			input: []series{
-				{
-					lset:    labels.FromStrings("a", "1", "c", "3"),
-					samples: []sample{{20000, 2}, {30000, 3}},
-				},
-				{
-					lset:    labels.FromStrings("a", "1", "c", "3"),
-					samples: []sample{{10000, 1}, {20000, 2}},
-				},
-				{
-					lset:    labels.FromStrings("a", "2", "c", "3"),
-					samples: []sample{{10000, 101}, {20000, 102}},
-				},
-				{
-					lset:    labels.FromStrings("a", "2", "c", "3"),
-					samples: []sample{{10000, 101}, {30000, 103}},
-				},
-			},
-			exp: []series{
-				{
-					lset:    labels.FromStrings("a", "1", "c", "3"),
-					samples: []sample{{10000, 1}, {20000, 2}, {30000, 3}},
-				},
-				{
-					lset:    labels.FromStrings("a", "2", "c", "3"),
-					samples: []sample{{10000, 101}, {20000, 102}, {30000, 103}},
-				},
-			},
-		},
-	} {
-		t.Run(tcase.name, func(t *testing.T) {
-			dedupSet := NewSeriesSet(&mockedSeriesSet{series: tcase.input}, "", AlgorithmChain)
-			var ats []storage.Series
-			for dedupSet.Next() {
-				ats = append(ats, dedupSet.At())
-			}
-			testutil.Ok(t, dedupSet.Err())
-			testutil.Equals(t, len(tcase.exp), len(ats))
-
-			for i, s := range ats {
-				testutil.Equals(t, tcase.exp[i].lset, s.Labels(), "labels mismatch for series %v", i)
-				res := expandSeries(t, s.Iterator(nil))
-				testutil.Equals(t, tcase.exp[i].samples, res, "values mismatch for series :%v", i)
-			}
-		})
-	}
-}
-
 func TestDedupSeriesIterator(t *testing.T) {
 	// The deltas between timestamps should be at least 10000 to not be affected
 	// by the initial penalty of 5000, that will cause the second iterator to seek