public ConstantBulkScorer(ConstantScoreQuery outerInstance, BulkScorer bulkScorer, Weight weight, float theScore) { this.outerInstance = outerInstance; this.bulkScorer = bulkScorer; this.weight = weight; this.theScore = theScore; }
/// <summary> /// Lower-level search API. /// /// <para/> /// <seealso cref="ICollector.Collect(int)"/> is called for every document. /// /// <para/> /// NOTE: this method executes the searches on all given leaves exclusively. /// To search across all the searchers leaves use <see cref="m_leafContexts"/>. /// </summary> /// <param name="leaves"> /// The searchers leaves to execute the searches on </param> /// <param name="weight"> /// To match documents </param> /// <param name="collector"> /// To receive hits </param> /// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed /// <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception> protected virtual void Search(IList <AtomicReaderContext> leaves, Weight weight, ICollector collector) { // TODO: should we make this // threaded...? the Collector could be sync'd? // always use single thread: foreach (AtomicReaderContext ctx in leaves) // search each subreader { try { collector.SetNextReader(ctx); } catch (CollectionTerminatedException) { // there is no doc of interest in this reader context // continue with the following leaf continue; } BulkScorer scorer = weight.GetBulkScorer(ctx, !collector.AcceptsDocsOutOfOrder, ctx.AtomicReader.LiveDocs); if (scorer != null) { try { scorer.Score(collector); } catch (CollectionTerminatedException) { // collection was terminated prematurely // continue with the following leaf } } } }
public override BulkScorer GetBulkScorer(AtomicReaderContext context, bool scoreDocsInOrder, IBits acceptDocs) { //DocIdSetIterator disi; if (outerInstance.m_filter != null) { if (Debugging.AssertsEnabled) { Debugging.Assert(outerInstance.m_query == null); } return(base.GetBulkScorer(context, scoreDocsInOrder, acceptDocs)); } else { if (Debugging.AssertsEnabled) { Debugging.Assert(outerInstance.m_query != null && innerWeight != null); } BulkScorer bulkScorer = innerWeight.GetBulkScorer(context, scoreDocsInOrder, acceptDocs); if (bulkScorer == null) { return(null); } return(new ConstantBulkScorer(outerInstance, bulkScorer, this, queryWeight)); } }
public SubScorer(BulkScorer scorer, bool required, bool prohibited, ICollector collector, SubScorer next) { if (required) { throw new System.ArgumentException("this scorer cannot handle required=true"); } this.Scorer = scorer; this.More = true; // TODO: re-enable this if BQ ever sends us required clauses //this.required = required; this.Prohibited = prohibited; this.Collector = collector; this.Next = next; }
public override BulkScorer GetBulkScorer(AtomicReaderContext context, bool scoreDocsInOrder, IBits acceptDocs) { if (scoreDocsInOrder || outerInstance.m_minNrShouldMatch > 1) { // TODO: (LUCENE-4872) in some cases BooleanScorer may be faster for minNrShouldMatch // but the same is even true of pure conjunctions... return(base.GetBulkScorer(context, scoreDocsInOrder, acceptDocs)); } IList <BulkScorer> prohibited = new List <BulkScorer>(); IList <BulkScorer> optional = new List <BulkScorer>(); using (IEnumerator <BooleanClause> cIter = outerInstance.clauses.GetEnumerator()) { foreach (Weight w in m_weights) { cIter.MoveNext(); BooleanClause c = cIter.Current; BulkScorer subScorer = w.GetBulkScorer(context, false, acceptDocs); if (subScorer == null) { if (c.IsRequired) { return(null); } } else if (c.IsRequired) { // TODO: there are some cases where BooleanScorer // would handle conjunctions faster than // BooleanScorer2... return(base.GetBulkScorer(context, scoreDocsInOrder, acceptDocs)); } else if (c.IsProhibited) { prohibited.Add(subScorer); } else { optional.Add(subScorer); } } } // Check if we can and should return a BooleanScorer return(new BooleanScorer(this, disableCoord, outerInstance.m_minNrShouldMatch, optional, prohibited, m_maxCoord)); }