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));
}
}
/// <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 virtual void Test()
{
Term allTerm = new Term(FIELD, "all");
TermQuery termQuery = new TermQuery(allTerm);
Weight weight = IndexSearcher.CreateNormalizedWeight(termQuery);
Assert.IsTrue(IndexSearcher.TopReaderContext is AtomicReaderContext);
AtomicReaderContext context = (AtomicReaderContext)IndexSearcher.TopReaderContext;
BulkScorer ts = weight.GetBulkScorer(context, true, (context.AtomicReader).LiveDocs);
// we have 2 documents with the term all in them, one document for all the
// other values
IList <TestHit> docs = new List <TestHit>();
// must call next first
ts.Score(new CollectorAnonymousInnerClassHelper(this, context, docs));
Assert.IsTrue(docs.Count == 2, "docs Size: " + docs.Count + " is not: " + 2);
TestHit doc0 = docs[0];
TestHit doc5 = docs[1];
// The scores should be the same
Assert.IsTrue(doc0.Score == doc5.Score, doc0.Score + " does not equal: " + doc5.Score);
/*
* Score should be (based on Default Sim.: All floats are approximate tf = 1
* numDocs = 6 docFreq(all) = 2 idf = ln(6/3) + 1 = 1.693147 idf ^ 2 =
* 2.8667 boost = 1 lengthNorm = 1 //there is 1 term in every document coord
* = 1 sumOfSquaredWeights = (idf * boost) ^ 2 = 1.693147 ^ 2 = 2.8667
* queryNorm = 1 / (sumOfSquaredWeights)^0.5 = 1 /(1.693147) = 0.590
*
* score = 1 * 2.8667 * 1 * 1 * 0.590 = 1.69
*/
Assert.IsTrue(doc0.Score == 1.6931472f, doc0.Score + " does not equal: " + 1.6931472f);
}
public override BulkScorer GetBulkScorer(AtomicReaderContext context, bool scoreDocsInOrder, IBits acceptDocs)
{
// if the caller asks for in-order scoring or if the weight does not support
// out-of order scoring then collection will have to happen in-order.
BulkScorer inScorer = @in.GetBulkScorer(context, scoreDocsInOrder, acceptDocs);
if (inScorer == null)
{
return(null);
}
if (AssertingBulkScorer.ShouldWrap(inScorer))
{
// The incoming scorer already has a specialized
// implementation for BulkScorer, so we should use it:
inScorer = AssertingBulkScorer.Wrap(new Random(Random.Next()), inScorer);
}
else if (Random.NextBoolean())
{
// Let super wrap this.scorer instead, so we use
// AssertingScorer:
inScorer = base.GetBulkScorer(context, scoreDocsInOrder, acceptDocs);
}
if (scoreDocsInOrder == false && Random.NextBoolean())
{
// The caller claims it can handle out-of-order
// docs; let's confirm that by pulling docs and
// randomly shuffling them before collection:
inScorer = new AssertingBulkOutOfOrderScorer(new Random(Random.Next()), inScorer);
}
return(inScorer);
}
public virtual void TestBooleanScorerMax()
{
Directory dir = NewDirectory();
RandomIndexWriter riw = new RandomIndexWriter(Random, dir, NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random)));
int docCount = AtLeast(10000);
for (int i = 0; i < docCount; i++)
{
Document doc = new Document();
doc.Add(NewField("field", "a", TextField.TYPE_NOT_STORED));
riw.AddDocument(doc);
}
riw.ForceMerge(1);
IndexReader r = riw.GetReader();
riw.Dispose();
IndexSearcher s = NewSearcher(r);
BooleanQuery bq = new BooleanQuery();
bq.Add(new TermQuery(new Term("field", "a")), Occur.SHOULD);
bq.Add(new TermQuery(new Term("field", "a")), Occur.SHOULD);
Weight w = s.CreateNormalizedWeight(bq);
Assert.AreEqual(1, s.IndexReader.Leaves.Count);
BulkScorer scorer = w.GetBulkScorer(s.IndexReader.Leaves[0], false, null);
FixedBitSet hits = new FixedBitSet(docCount);
AtomicInt32 end = new AtomicInt32();
ICollector c = new CollectorAnonymousClass(this, scorer, hits, end);
while (end < docCount)
{
int inc = TestUtil.NextInt32(Random, 1, 1000);
end.AddAndGet(inc);
scorer.Score(c, end);
}
Assert.AreEqual(docCount, hits.Cardinality);
r.Dispose();
dir.Dispose();
}