version2

Author: CascadingRadium

index/scorch/snapshot_index.go

@@ -622,10 +622,10 @@ func (is *IndexSnapshot) TermFieldReader(ctx context.Context, term []byte, field
 	rv.includeTermVectors = includeTermVectors
 	rv.currPosting = nil
 	rv.currID = rv.currID[:0]
-	rv.nestInfo = nil
+	rv.nestedState = nil
 	if ctx != nil {
-		if nInfo, ok := ctx.Value(search.NestedInfoCallbackKey).(*search.NestedInfo); ok {
-			rv.nestInfo = nInfo
+		if nestedState, ok := ctx.Value(search.NestedStateKey).(index.NestedState); ok {
+			rv.nestedState = nestedState
 		}
 	}
 
@@ -643,8 +643,8 @@ func (is *IndexSnapshot) TermFieldReader(ctx context.Context, term []byte, field
 			}
 			var dict segment.TermDictionary
 			var err error
-			if nestedSegment, ok := s.segment.(segment.NestedSegment); ok && rv.nestInfo != nil {
-				dict, err = nestedSegment.NestedDictionary(field, rv.nestInfo.Path, rv.nestInfo.ArrayPosition)
+			if ns, ok := s.segment.(segment.NestedSegment); ok && rv.nestedState != nil {
+				dict, err = ns.NestedDictionary(rv.nestedState, field)
 			} else {
 				dict, err = s.segment.Dictionary(field)
 			}

index/scorch/snapshot_index_tfr.go

@@ -51,7 +51,7 @@ type IndexSnapshotTermFieldReader struct {
 	bytesRead          uint64
 	ctx                context.Context
 	unadorned          bool
-	nestInfo           *search.NestedInfo
+	nestedState        index.NestedState
 }
 
 func (i *IndexSnapshotTermFieldReader) incrementBytesRead(val uint64) {

search/query/nested.go

@@ -43,16 +43,23 @@ func (q *NestedQuery) Searcher(ctx context.Context, i index.IndexReader, m mappi
 	if !ok {
 		return nil, fmt.Errorf("nested searcher requires an index reader that supports nested documents")
 	}
-	childCount := nr.ChildCount(q.Path)
+	if q.Path == "" || q.InnerQuery == nil {
+		return nil, fmt.Errorf("nested searcher requires a valid path and inner query")
+	}
+	var baseState index.NestedState
+	if existing, ok := ctx.Value(search.NestedStateKey).(index.NestedState); ok {
+		baseState = existing
+	} else {
+		baseState = search.NewNestedState()
+	}
+	childCount := nr.ChildCount(baseState, q.Path)
 	if childCount == 0 {
 		return nil, fmt.Errorf("nested searcher: path %q has no child documents", q.Path)
 	}
 	innerSearchers := make([]search.Searcher, 0, childCount)
-	for arrayPos := range childCount {
-		nctx := context.WithValue(ctx, search.NestedInfoCallbackKey, &search.NestedInfo{
-			Path:          q.Path,
-			ArrayPosition: arrayPos,
-		})
+	for arrayPos := 0; arrayPos < childCount; arrayPos++ {
+		newState := baseState.Append(q.Path, arrayPos)
+		nctx := context.WithValue(ctx, search.NestedStateKey, newState)
 		innerSearcher, err := q.InnerQuery.Searcher(nctx, i, m, options)
 		if err != nil {
 			return nil, fmt.Errorf("nested searcher: failed to create inner searcher at pos %d: %w", arrayPos, err)

search/util.go

@@ -16,7 +16,9 @@ package search
 
 import (
 	"context"
+	"slices"
 
+	index "github.com/blevesearch/bleve_index_api"
 	"github.com/blevesearch/geo/s2"
 )
 
@@ -153,7 +155,7 @@ const (
 	// to the actual search phase which would use it to perform the search.
 	BM25StatsKey ContextKey = "_bm25_stats_key"
 
-	NestedInfoCallbackKey ContextKey = "_nested_info_callback_key"
+	NestedStateKey ContextKey = "_nested_state_key"
 )
 
 func RecordSearchCost(ctx context.Context,
@@ -236,7 +238,75 @@ type BM25Stats struct {
 	FieldCardinality map[string]int `json:"field_cardinality"`
 }
 
-type NestedInfo struct {
-	Path          string `json:"path"`
-	ArrayPosition int    `json:"array_position"`
+type nestedState struct {
+	paths          []string
+	arrayPositions []int
+}
+
+func NewNestedState() index.NestedState {
+	return &nestedState{
+		paths:          make([]string, 0),
+		arrayPositions: make([]int, 0),
+	}
+}
+
+// Append returns a new NestedState with the given path and array position added.
+// It does NOT modify the original NestedState.
+func (s *nestedState) Append(path string, pos int) index.NestedState {
+	return &nestedState{
+		paths:          append(slices.Clone(s.paths), path),
+		arrayPositions: append(slices.Clone(s.arrayPositions), pos),
+	}
+}
+
+func (s *nestedState) Empty() bool {
+	return len(s.paths) == 0 && len(s.arrayPositions) == 0
+}
+
+func (s *nestedState) Clear() {
+	s.paths = s.paths[:0]
+	s.arrayPositions = s.arrayPositions[:0]
+}
+
+func (s *nestedState) Root() string {
+	if len(s.paths) == 0 {
+		return ""
+	}
+	return s.paths[0]
+}
+
+func (s *nestedState) Iterator() index.NestedIterator {
+	return &nestedIterator{
+		paths:         s.paths,
+		arrayPosition: s.arrayPositions,
+		index:         0,
+	}
+}
+
+type nestedIterator struct {
+	paths         []string
+	arrayPosition []int
+	index         int
+}
+
+func (ni *nestedIterator) HasNext() bool {
+	return ni.index < len(ni.paths)
+}
+
+func (ni *nestedIterator) Next() (string, int, bool) {
+	if ni.index >= len(ni.paths) {
+		return "", 0, false
+	}
+	path := ni.paths[ni.index]
+	arrayPos := ni.arrayPosition[ni.index]
+	ni.index++
+	return path, arrayPos, true
+}
+
+func (ni *nestedIterator) Reset() {
+	ni.index = 0
+}
+
+func (ni *nestedIterator) Size() int {
+	return len(ni.paths)
 }