5aa9e95468
index id's are now opaque (until finally returned to top-level user) - the TermFieldDoc's returned by TermFieldReader no longer contain doc id - instead they return an opaque IndexInternalID - items returned are still in the "natural index order" - but that is no longer guaranteed to be "doc id order" - correct behavior requires that they all follow the same order - but not any particular order - new API FinalizeDocID which converts index internal ID's to public string ID - APIs used internally which previously took doc id now take IndexInternalID - that is DocumentFieldTerms() and DocumentFieldTermsForFields() - however, APIs that are used externally do not reflect this change - that is Document() - DocumentIDReader follows the same changes, but this is less obvious - behavior clarified, used to iterate doc ids, BUT NOT in doc id order - method STILL available to iterate doc ids in range - but again, you won't get them in any meaningful order - new method to iterate actual doc ids from list of possible ids - this was introduced to make the DocIDSearcher continue working searchers now work with the new opaque index internal doc ids - they return new DocumentMatchInternal (which does not have string ID) scorerers also work with these opaque index internal doc ids - they return DocumentMatchInternal (which does not have string ID) collectors now also perform a final step of converting the final result - they STILL return traditional DocumentMatch (with string ID) - but they now also require an IndexReader (so that they can do the conversion)
198 lines
5.0 KiB
Go
198 lines
5.0 KiB
Go
// 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.
|
|
|
|
package searchers
|
|
|
|
import (
|
|
"math"
|
|
"sort"
|
|
|
|
"github.com/blevesearch/bleve/index"
|
|
"github.com/blevesearch/bleve/search"
|
|
"github.com/blevesearch/bleve/search/scorers"
|
|
)
|
|
|
|
type ConjunctionSearcher struct {
|
|
initialized bool
|
|
indexReader index.IndexReader
|
|
searchers OrderedSearcherList
|
|
explain bool
|
|
queryNorm float64
|
|
currs []*search.DocumentMatchInternal
|
|
currentID index.IndexInternalID
|
|
scorer *scorers.ConjunctionQueryScorer
|
|
}
|
|
|
|
func NewConjunctionSearcher(indexReader index.IndexReader, qsearchers []search.Searcher, explain bool) (*ConjunctionSearcher, error) {
|
|
// build the downstream searchers
|
|
searchers := make(OrderedSearcherList, len(qsearchers))
|
|
for i, searcher := range qsearchers {
|
|
searchers[i] = searcher
|
|
}
|
|
// sort the searchers
|
|
sort.Sort(searchers)
|
|
// build our searcher
|
|
rv := ConjunctionSearcher{
|
|
indexReader: indexReader,
|
|
explain: explain,
|
|
searchers: searchers,
|
|
currs: make([]*search.DocumentMatchInternal, len(searchers)),
|
|
scorer: scorers.NewConjunctionQueryScorer(explain),
|
|
}
|
|
rv.computeQueryNorm()
|
|
return &rv, nil
|
|
}
|
|
|
|
func (s *ConjunctionSearcher) computeQueryNorm() {
|
|
// first calculate sum of squared weights
|
|
sumOfSquaredWeights := 0.0
|
|
for _, termSearcher := range s.searchers {
|
|
sumOfSquaredWeights += termSearcher.Weight()
|
|
}
|
|
// now compute query norm from this
|
|
s.queryNorm = 1.0 / math.Sqrt(sumOfSquaredWeights)
|
|
// finally tell all the downstream searchers the norm
|
|
for _, termSearcher := range s.searchers {
|
|
termSearcher.SetQueryNorm(s.queryNorm)
|
|
}
|
|
}
|
|
|
|
func (s *ConjunctionSearcher) initSearchers() error {
|
|
var err error
|
|
// get all searchers pointing at their first match
|
|
for i, termSearcher := range s.searchers {
|
|
s.currs[i], err = termSearcher.Next(nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if len(s.currs) > 0 {
|
|
if s.currs[0] != nil {
|
|
s.currentID = s.currs[0].ID
|
|
} else {
|
|
s.currentID = nil
|
|
}
|
|
}
|
|
|
|
s.initialized = true
|
|
return nil
|
|
}
|
|
|
|
func (s *ConjunctionSearcher) Weight() float64 {
|
|
var rv float64
|
|
for _, searcher := range s.searchers {
|
|
rv += searcher.Weight()
|
|
}
|
|
return rv
|
|
}
|
|
|
|
func (s *ConjunctionSearcher) SetQueryNorm(qnorm float64) {
|
|
for _, searcher := range s.searchers {
|
|
searcher.SetQueryNorm(qnorm)
|
|
}
|
|
}
|
|
|
|
func (s *ConjunctionSearcher) Next(preAllocated *search.DocumentMatchInternal) (*search.DocumentMatchInternal, error) {
|
|
if !s.initialized {
|
|
err := s.initSearchers()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
var rv *search.DocumentMatchInternal
|
|
var err error
|
|
OUTER:
|
|
for s.currentID != nil {
|
|
for i, termSearcher := range s.searchers {
|
|
if s.currs[i] != nil && !s.currs[i].ID.Equals(s.currentID) {
|
|
if s.currentID.Compare(s.currs[i].ID) < 0 {
|
|
s.currentID = s.currs[i].ID
|
|
continue OUTER
|
|
}
|
|
// this reader doesn't have the currentID, try to advance
|
|
s.currs[i], err = termSearcher.Advance(s.currentID, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if s.currs[i] == nil {
|
|
s.currentID = nil
|
|
continue OUTER
|
|
}
|
|
if !s.currs[i].ID.Equals(s.currentID) {
|
|
// we just advanced, so it doesn't match, it must be greater
|
|
// no need to call next
|
|
s.currentID = s.currs[i].ID
|
|
continue OUTER
|
|
}
|
|
} else if s.currs[i] == nil {
|
|
s.currentID = nil
|
|
continue OUTER
|
|
}
|
|
}
|
|
// if we get here, a doc matched all readers, sum the score and add it
|
|
rv = s.scorer.Score(s.currs)
|
|
|
|
// prepare for next entry
|
|
s.currs[0], err = s.searchers[0].Next(nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if s.currs[0] == nil {
|
|
s.currentID = nil
|
|
} else {
|
|
s.currentID = s.currs[0].ID
|
|
}
|
|
// don't continue now, wait for the next call to Next()
|
|
break
|
|
}
|
|
return rv, nil
|
|
}
|
|
|
|
func (s *ConjunctionSearcher) Advance(ID index.IndexInternalID, preAllocated *search.DocumentMatchInternal) (*search.DocumentMatchInternal, error) {
|
|
if !s.initialized {
|
|
err := s.initSearchers()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
var err error
|
|
for i, searcher := range s.searchers {
|
|
s.currs[i], err = searcher.Advance(ID, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
s.currentID = ID
|
|
return s.Next(preAllocated)
|
|
}
|
|
|
|
func (s *ConjunctionSearcher) Count() uint64 {
|
|
// for now return a worst case
|
|
var sum uint64
|
|
for _, searcher := range s.searchers {
|
|
sum += searcher.Count()
|
|
}
|
|
return sum
|
|
}
|
|
|
|
func (s *ConjunctionSearcher) Close() error {
|
|
for _, searcher := range s.searchers {
|
|
err := searcher.Close()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *ConjunctionSearcher) Min() int {
|
|
return 0
|
|
}
|