go mod and vendor/ update

vendor/github.com/blevesearch/bleve/index_alias_impl.go

@@ -1,11 +1,16 @@
 //  Copyright (c) 2014 Couchbase, Inc.
-//  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
-//  except in compliance with the License. You may obtain a copy of the License at
-//    http://www.apache.org/licenses/LICENSE-2.0
-//  Unless required by applicable law or agreed to in writing, software distributed under the
-//  License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
-//  either express or implied. See the License for the specific language governing permissions
-//  and limitations under the License.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 		http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 package bleve
 
@@ -19,6 +24,7 @@ import (
 	"github.com/blevesearch/bleve/document"
 	"github.com/blevesearch/bleve/index"
 	"github.com/blevesearch/bleve/index/store"
+	"github.com/blevesearch/bleve/mapping"
 	"github.com/blevesearch/bleve/search"
 )
 
@@ -259,7 +265,7 @@ func (i *indexAliasImpl) Close() error {
 	return nil
 }
 
-func (i *indexAliasImpl) Mapping() *IndexMapping {
+func (i *indexAliasImpl) Mapping() mapping.IndexMapping {
 	i.mutex.RLock()
 	defer i.mutex.RUnlock()
 
@@ -419,14 +425,15 @@ func (i *indexAliasImpl) Swap(in, out []Index) {
 // could be slower in remote usages.
 func createChildSearchRequest(req *SearchRequest) *SearchRequest {
 	rv := SearchRequest{
-		Query:     req.Query,
-		Size:      req.Size + req.From,
-		From:      0,
-		Highlight: req.Highlight,
-		Fields:    req.Fields,
-		Facets:    req.Facets,
-		Explain:   req.Explain,
-		Sort:      req.Sort,
+		Query:            req.Query,
+		Size:             req.Size + req.From,
+		From:             0,
+		Highlight:        req.Highlight,
+		Fields:           req.Fields,
+		Facets:           req.Facets,
+		Explain:          req.Explain,
+		Sort:             req.Sort.Copy(),
+		IncludeLocations: req.IncludeLocations,
 	}
 	return &rv
 }
@@ -437,53 +444,26 @@ type asyncSearchResult struct {
 	Err    error
 }
 
-func wrapSearch(ctx context.Context, in Index, req *SearchRequest) *asyncSearchResult {
-	rv := asyncSearchResult{Name: in.Name()}
-	rv.Result, rv.Err = in.SearchInContext(ctx, req)
-	return &rv
-}
-
-func wrapSearchTimeout(ctx context.Context, in Index, req *SearchRequest) *asyncSearchResult {
-	reschan := make(chan *asyncSearchResult)
-	go func() { reschan <- wrapSearch(ctx, in, req) }()
-	select {
-	case res := <-reschan:
-		return res
-	case <-ctx.Done():
-		return &asyncSearchResult{Name: in.Name(), Err: ctx.Err()}
-	}
-}
-
-// MultiSearch executes a SearchRequest across multiple
-// Index objects, then merges the results.
+// MultiSearch executes a SearchRequest across multiple Index objects,
+// then merges the results.  The indexes must honor any ctx deadline.
 func MultiSearch(ctx context.Context, req *SearchRequest, indexes ...Index) (*SearchResult, error) {
 
 	searchStart := time.Now()
-	asyncResults := make(chan *asyncSearchResult)
+	asyncResults := make(chan *asyncSearchResult, len(indexes))
 
 	// run search on each index in separate go routine
 	var waitGroup sync.WaitGroup
 
-	var searchChildIndex = func(waitGroup *sync.WaitGroup, in Index, asyncResults chan *asyncSearchResult) {
-		childReq := createChildSearchRequest(req)
-		if ia, ok := in.(IndexAlias); ok {
-			// if the child index is another alias, trust it returns promptly on timeout/cancel
-			go func() {
-				defer waitGroup.Done()
-				asyncResults <- wrapSearch(ctx, ia, childReq)
-			}()
-		} else {
-			// if the child index is not an alias, enforce timeout here
-			go func() {
-				defer waitGroup.Done()
-				asyncResults <- wrapSearchTimeout(ctx, in, childReq)
-			}()
-		}
+	var searchChildIndex = func(in Index, childReq *SearchRequest) {
+		rv := asyncSearchResult{Name: in.Name()}
+		rv.Result, rv.Err = in.SearchInContext(ctx, childReq)
+		asyncResults <- &rv
+		waitGroup.Done()
 	}
 
+	waitGroup.Add(len(indexes))
 	for _, in := range indexes {
-		waitGroup.Add(1)
-		searchChildIndex(&waitGroup, in, asyncResults)
+		go searchChildIndex(in, createChildSearchRequest(req))
 	}
 
 	// on another go routine, close after finished