You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@skywalking.apache.org by ha...@apache.org on 2026/03/31 11:13:12 UTC

(skywalking-banyandb) 01/01: fix(measure): always enforce query time range in index-mode inverted search

This is an automated email from the ASF dual-hosted git repository.

hanahmily pushed a commit to branch fix/segment-range
in repository https://gitbox.apache.org/repos/asf/skywalking-banyandb.git

commit 9e3332ced0e5715a6b24f3e325e9576b5e8422b9
Author: Hongtao Gao <ha...@gmail.com>
AuthorDate: Mon Mar 30 14:31:42 2026 +0000

    fix(measure): always enforce query time range in index-mode inverted search
    
    BuildQuery silently dropped timeRange when no series matchers were
    provided, causing index-mode queries to return stale documents from
    older segments whose metadata range widened to cover the query window.
    Fix by unifying the no-matchers path in BuildQuery to apply timeRange,
    always passing TimeRange from buildIndexQueryResult instead of omitting
    it for fully-covered segments, and incorporating TimeRange into the
    SeriesSort query path in SearchWithoutSeries.
---
 CHANGES.md                                 |  1 +
 banyand/internal/storage/index.go          | 11 +++-
 banyand/measure/query.go                   |  6 +-
 pkg/index/inverted/inverted_series.go      | 94 +++++++++++++++---------------
 pkg/index/inverted/inverted_series_test.go | 59 +++++++++++++++++++
 5 files changed, 118 insertions(+), 53 deletions(-)

diff --git a/CHANGES.md b/CHANGES.md
index ab476c04a..643deedac 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -14,6 +14,7 @@ Release Notes.
 ### Bug Fixes
 
 - Fix flaky trace query filtering caused by non-deterministic sidx tag ordering and add consistency checks for integration query cases.
+- Fix index-mode measure queries returning documents outside the requested time range when a widened segment overlaps the query window.
 
 ## 0.10.0
 
diff --git a/banyand/internal/storage/index.go b/banyand/internal/storage/index.go
index ad8afc1ca..dff32d742 100644
--- a/banyand/internal/storage/index.go
+++ b/banyand/internal/storage/index.go
@@ -101,7 +101,7 @@ func (s *seriesIndex) Stats() (dataCount int64, dataSizeBytes int64) {
 func (s *seriesIndex) filter(ctx context.Context, series []*pbv1.Series,
 	projection []index.FieldKey, secondaryQuery index.Query, timeRange *timestamp.TimeRange,
 ) (data SeriesData, err error) {
-	if len(series) == 0 && secondaryQuery == nil {
+	if len(series) == 0 && secondaryQuery == nil && timeRange == nil {
 		return data, nil
 	}
 	var seriesMatchers []index.SeriesMatcher
@@ -343,7 +343,14 @@ func (s *seriesIndex) SearchWithoutSeries(ctx context.Context, opts IndexSearchO
 		}()
 	}
 
-	iter, err := s.store.SeriesSort(ctx, opts.Query, opts.Order,
+	sortQuery := opts.Query
+	if opts.TimeRange != nil {
+		sortQuery, err = s.store.BuildQuery(nil, opts.Query, opts.TimeRange)
+		if err != nil {
+			return sd, nil, err
+		}
+	}
+	iter, err := s.store.SeriesSort(ctx, sortQuery, opts.Order,
 		opts.PreloadSize, opts.Projection)
 	if err != nil {
 		return sd, nil, err
diff --git a/banyand/measure/query.go b/banyand/measure/query.go
index 794d6e6c6..35ddb6e09 100644
--- a/banyand/measure/query.go
+++ b/banyand/measure/query.go
@@ -501,14 +501,10 @@ func (m *measure) buildIndexQueryResult(ctx context.Context, mqo model.MeasureQu
 		Order:       mqo.Order,
 		PreloadSize: preloadSize,
 		Projection:  indexProjection,
+		TimeRange:   mqo.TimeRange,
 	}
 	seriesFilter := roaring.NewPostingList()
 	for i := range segments {
-		if mqo.TimeRange.Include(segments[i].GetTimeRange()) {
-			opts.TimeRange = nil
-		} else {
-			opts.TimeRange = mqo.TimeRange
-		}
 		sr := &segResult{}
 		sr.SeriesData, sr.sortedValues, err = segments[i].IndexDB().SearchWithoutSeries(ctx, opts)
 		if err != nil {
diff --git a/pkg/index/inverted/inverted_series.go b/pkg/index/inverted/inverted_series.go
index e14426ae7..5a64a4283 100644
--- a/pkg/index/inverted/inverted_series.go
+++ b/pkg/index/inverted/inverted_series.go
@@ -139,66 +139,68 @@ func toDoc(d index.Document, toParseFieldNames bool) (*bluge.Document, []string)
 
 // BuildQuery implements index.SeriesStore.
 func (s *store) BuildQuery(seriesMatchers []index.SeriesMatcher, secondaryQuery index.Query, timeRange *timestamp.TimeRange) (index.Query, error) {
-	if len(seriesMatchers) == 0 {
+	if len(seriesMatchers) == 0 && timeRange == nil {
 		return secondaryQuery, nil
 	}
 
-	qs := make([]bluge.Query, len(seriesMatchers))
-	nodes := make([]node, len(seriesMatchers))
-	for i := range seriesMatchers {
-		switch seriesMatchers[i].Type {
-		case index.SeriesMatcherTypeExact:
-			match := convert.BytesToString(seriesMatchers[i].Match)
-			q := bluge.NewTermQuery(match)
-			q.SetField(docIDField)
-			qs[i] = q
-			nodes = append(nodes, newTermNode(match, nil))
-		case index.SeriesMatcherTypePrefix:
-			match := convert.BytesToString(seriesMatchers[i].Match)
-			q := bluge.NewPrefixQuery(match)
-			q.SetField(docIDField)
-			qs[i] = q
-			nodes = append(nodes, newPrefixNode(match))
-		case index.SeriesMatcherTypeWildcard:
-			match := convert.BytesToString(seriesMatchers[i].Match)
-			q := bluge.NewWildcardQuery(match)
-			q.SetField(docIDField)
-			qs[i] = q
-			nodes = append(nodes, newWildcardNode(match))
-		default:
-			return nil, errors.Errorf("unsupported series matcher type: %v", seriesMatchers[i].Type)
+	query := bluge.NewBooleanQuery()
+	rootNode := newMustNode()
+	if len(seriesMatchers) > 0 {
+		qs := make([]bluge.Query, len(seriesMatchers))
+		matcherNodes := make([]node, len(seriesMatchers))
+		for i := range seriesMatchers {
+			switch seriesMatchers[i].Type {
+			case index.SeriesMatcherTypeExact:
+				match := convert.BytesToString(seriesMatchers[i].Match)
+				q := bluge.NewTermQuery(match)
+				q.SetField(docIDField)
+				qs[i] = q
+				matcherNodes = append(matcherNodes, newTermNode(match, nil))
+			case index.SeriesMatcherTypePrefix:
+				match := convert.BytesToString(seriesMatchers[i].Match)
+				q := bluge.NewPrefixQuery(match)
+				q.SetField(docIDField)
+				qs[i] = q
+				matcherNodes = append(matcherNodes, newPrefixNode(match))
+			case index.SeriesMatcherTypeWildcard:
+				match := convert.BytesToString(seriesMatchers[i].Match)
+				q := bluge.NewWildcardQuery(match)
+				q.SetField(docIDField)
+				qs[i] = q
+				matcherNodes = append(matcherNodes, newWildcardNode(match))
+			default:
+				return nil, errors.Errorf("unsupported series matcher type: %v", seriesMatchers[i].Type)
+			}
 		}
-	}
-	var primaryQuery bluge.Query
-	var n node
-	if len(qs) > 1 {
-		bq := bluge.NewBooleanQuery()
-		bq.AddShould(qs...)
-		bq.SetMinShould(1)
-		primaryQuery = bq
-		n = newShouldNode()
-		for i := range nodes {
-			n.(*shouldNode).Append(nodes[i])
+		var primaryQuery bluge.Query
+		var primaryNode node
+		if len(qs) > 1 {
+			bq := bluge.NewBooleanQuery()
+			bq.AddShould(qs...)
+			bq.SetMinShould(1)
+			primaryQuery = bq
+			primaryNode = newShouldNode()
+			for i := range matcherNodes {
+				primaryNode.(*shouldNode).Append(matcherNodes[i])
+			}
+		} else {
+			primaryQuery = qs[0]
+			primaryNode = matcherNodes[0]
 		}
-	} else {
-		primaryQuery = qs[0]
-		n = nodes[0]
+		query.AddMust(primaryQuery)
+		rootNode.Append(primaryNode)
 	}
-
-	query := bluge.NewBooleanQuery().AddMust(primaryQuery)
-	node := newMustNode()
-	node.Append(n)
 	if secondaryQuery != nil && secondaryQuery.(*queryNode).query != nil {
 		query.AddMust(secondaryQuery.(*queryNode).query)
-		node.Append(secondaryQuery.(*queryNode).node)
+		rootNode.Append(secondaryQuery.(*queryNode).node)
 	}
 	if timeRange != nil {
 		q := bluge.NewDateRangeInclusiveQuery(timeRange.Start, timeRange.End, timeRange.IncludeStart, timeRange.IncludeEnd)
 		q.SetField(timestampField)
 		query.AddMust(q)
-		node.Append(newTimeRangeNode(timeRange))
+		rootNode.Append(newTimeRangeNode(timeRange))
 	}
-	return &queryNode{query, node}, nil
+	return &queryNode{query, rootNode}, nil
 }
 
 // Search implements index.SeriesStore.
diff --git a/pkg/index/inverted/inverted_series_test.go b/pkg/index/inverted/inverted_series_test.go
index 2621c3900..3814915eb 100644
--- a/pkg/index/inverted/inverted_series_test.go
+++ b/pkg/index/inverted/inverted_series_test.go
@@ -943,6 +943,65 @@ func field(key index.FieldKey, value []byte, indexed bool) index.Field {
 	return f
 }
 
+// TestStore_BuildQueryTimeRangeWithoutSeriesMatchers verifies that BuildQuery applies the time range
+// filter even when no series matchers are provided, both with and without a secondary query.
+func TestStore_BuildQueryTimeRangeWithoutSeriesMatchers(t *testing.T) {
+	tester := require.New(t)
+	path, fn := setUp(tester)
+	s, err := NewStore(StoreOpts{
+		Path:   path,
+		Logger: logger.GetLogger("test"),
+	})
+	tester.NoError(err)
+	defer func() {
+		tester.NoError(s.Close())
+		fn()
+	}()
+
+	insertData(tester, s)
+
+	// series2 has Timestamp=101, series3 has Timestamp=1001, series4 has Timestamp=2001.
+	// A time range [100, 2000) should match series2 and series3 only.
+	tr := timestamp.NewTimeRange(time.Unix(0, 100), time.Unix(0, 2000), true, false)
+
+	t.Run("nil secondary query", func(t *testing.T) {
+		query, buildErr := s.BuildQuery(nil, nil, &tr)
+		require.NoError(t, buildErr)
+		require.NotNil(t, query)
+
+		got, searchErr := s.Search(context.Background(), nil, query, 0)
+		require.NoError(t, searchErr)
+
+		sort.Slice(got, func(i, j int) bool {
+			return string(got[i].Key.EntityValues) < string(got[j].Key.EntityValues)
+		})
+		want := []index.SeriesDocument{
+			{Key: index.Series{EntityValues: []byte("test2")}, Timestamp: int64(101)},
+			{Key: index.Series{EntityValues: []byte("test3")}, Timestamp: int64(1001)},
+		}
+		assert.Equal(t, want, got)
+	})
+
+	t.Run("with secondary query", func(t *testing.T) {
+		// Build a secondary query matching entity "test4" (timestamp=2001).
+		// The time range [100, 2000) excludes its timestamp, so nothing should match.
+		durQuery, buildErr := s.BuildQuery([]index.SeriesMatcher{{
+			Type:  index.SeriesMatcherTypeExact,
+			Match: []byte("test4"),
+		}}, nil, nil)
+		require.NoError(t, buildErr)
+
+		// Now query with no series matchers, that secondary query, and the narrow time range.
+		combined, buildErr := s.BuildQuery(nil, durQuery, &tr)
+		require.NoError(t, buildErr)
+		require.NotNil(t, combined)
+
+		got, searchErr := s.Search(context.Background(), nil, combined, 0)
+		require.NoError(t, searchErr)
+		assert.Empty(t, got, "time range [100,2000) must exclude test4 (timestamp=2001)")
+	})
+}
+
 func updateData(tester *require.Assertions, s index.SeriesStore) {
 	b1, b2 := generateDocs()
 	tester.NoError(s.UpdateSeriesBatch(b1))