public override void Replay(ICollector other) { ReplayInit(other); int curUpto = 0; int curbase = 0; int chunkUpto = 0; m_curDocs = EMPTY_INT32_ARRAY; foreach (SegStart seg in m_cachedSegs) { other.SetNextReader(seg.ReaderContext); while (curbase + curUpto < seg.End) { if (curUpto == m_curDocs.Length) { curbase += m_curDocs.Length; m_curDocs = m_cachedDocs[chunkUpto]; chunkUpto++; curUpto = 0; } other.Collect(m_curDocs[curUpto++]); } } }
public virtual void SetNextReader(AtomicReaderContext context) { m_in.SetNextReader(context); m_segmentSorted = SortingMergePolicy.IsSorted(context.AtomicReader, m_sort); m_segmentTotalCollect = m_segmentSorted ? m_numDocsToCollect : int.MaxValue; numCollected = 0; }
/// <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 SetNextReader(AtomicReaderContext context) { m_other.SetNextReader(context); if (lastReaderContext != null) { m_cachedSegs.Add(new SegStart(lastReaderContext, m_base + m_upto)); } lastReaderContext = context; }
public virtual void TestCollector() { // Tests that the collector delegates calls to input collectors properly. // Tests that the collector handles some null collectors well. If it // doesn't, an NPE would be thrown. DummyCollector[] dcs = new DummyCollector[] { new DummyCollector(), new DummyCollector() }; ICollector c = MultiCollector.Wrap(dcs); Assert.IsTrue(c.AcceptsDocsOutOfOrder); c.Collect(1); c.SetNextReader(null); c.SetScorer(null); foreach (DummyCollector dc in dcs) { Assert.IsTrue(dc.AcceptsDocsOutOfOrderCalled); Assert.IsTrue(dc.CollectCalled); Assert.IsTrue(dc.SetNextReaderCalled); Assert.IsTrue(dc.SetScorerCalled); } }
public virtual void TestNullCollectors() { // Tests that the collector rejects all null collectors. try { MultiCollector.Wrap(null, null); Assert.Fail("only null collectors should not be supported"); } catch (Exception e) when(e.IsIllegalArgumentException()) { // expected } // Tests that the collector handles some null collectors well. If it // doesn't, an NPE would be thrown. ICollector c = MultiCollector.Wrap(new DummyCollector(), null, new DummyCollector()); Assert.IsTrue(c is MultiCollector); Assert.IsTrue(c.AcceptsDocsOutOfOrder); c.Collect(1); c.SetNextReader(null); c.SetScorer(null); }
public virtual void SetNextReader(AtomicReaderContext context) { collector.SetNextReader(context); }
public virtual void SetNextReader(AtomicReaderContext context) { DocBase = context.DocBase; Other.SetNextReader(context); }
public virtual void Search(Weight weight, Filter filter, ICollector collector, int start, IBoboMapFunctionWrapper mapReduceWrapper) { FacetValidator validator = CreateFacetValidator(); int target = 0; IndexReader reader = this.IndexReader; IndexReaderContext indexReaderContext = reader.Context; if (filter == null) { for (int i = 0; i < m_subReaders.Length; i++) { AtomicReaderContext atomicContext = indexReaderContext.Children == null ? (AtomicReaderContext)indexReaderContext : (AtomicReaderContext)(indexReaderContext.Children.Get(i)); int docStart = start; // NOTE: This code calls an internal constructor. Apparently, this was in the same namespace as Lucene, // but was added to this project, which presumably allows you to call internal constructors in Java. // In .NET, we can just use Activator.CreateInstance. Not great, but this code will be removed // when applying commit https://github.com/senseidb/bobo/commit/924c8579d90dbb5d56103976d39b47daa2242ef3 // which includes several major changes after the 4.0.2 release. // atomicContext = AtomicReaderContextUtil.UpdateDocBase(atomicContext, docStart); object[] args = new object[] { (CompositeReaderContext)null, atomicContext.AtomicReader, 0, 0, 0, docStart }; Type[] constructorSignature = { typeof(CompositeReaderContext), typeof(AtomicReader), typeof(int), typeof(int), typeof(int), typeof(int) }; var constr = typeof(AtomicReaderContext).GetTypeInfo().DeclaredConstructors .Single(constructor => constructor.GetParameters() .Select(parameter => parameter.ParameterType) .SequenceEqual(constructorSignature)); atomicContext = (AtomicReaderContext)constr.Invoke(args); if (reader is BoboMultiReader) { docStart = start + ((BoboMultiReader)reader).SubReaderBase(i); } collector.SetNextReader(atomicContext); validator.SetNextReader(m_subReaders[i], docStart); // NOTE: The Weight.Scorer method lost the scoreDocsInOrder and topScorer parameters between // Lucene 4.3.0 and 4.8.0. They are not used by BoboBrowse anyway, so the code here diverges // from the original Java source to remove these two parameters. // Scorer scorer = weight.Scorer(atomicContext, true, true, _subReaders[i].LiveDocs); Scorer scorer = weight.GetScorer(atomicContext, m_subReaders[i].LiveDocs); if (scorer != null) { collector.SetScorer(scorer); target = scorer.NextDoc(); while (target != DocIdSetIterator.NO_MORE_DOCS) { if (validator.Validate(target)) { collector.Collect(target); target = scorer.NextDoc(); } else { target = validator.m_nextTarget; target = scorer.Advance(target); } } } if (mapReduceWrapper != null) { mapReduceWrapper.MapFullIndexReader(m_subReaders[i], validator.GetCountCollectors()); } } return; } for (int i = 0; i < m_subReaders.Length; i++) { AtomicReaderContext atomicContext = indexReaderContext.Children == null ? (AtomicReaderContext)indexReaderContext : (AtomicReaderContext)(indexReaderContext.Children.Get(i)); DocIdSet filterDocIdSet = filter.GetDocIdSet(atomicContext, m_subReaders[i].LiveDocs); if (filterDocIdSet == null) { return; //shall we use return or continue here ?? } int docStart = start; if (reader is BoboMultiReader) { docStart = start + ((BoboMultiReader)reader).SubReaderBase(i); } collector.SetNextReader(atomicContext); validator.SetNextReader(m_subReaders[i], docStart); // NOTE: The Weight.Scorer method lost the scoreDocsInOrder and topScorer parameters between // Lucene 4.3.0 and 4.8.0. They are not used by BoboBrowse anyway, so the code here diverges // from the original Java source to remove these two parameters. // Scorer scorer = weight.Scorer(atomicContext, true, false, _subReaders[i].LiveDocs); Scorer scorer = weight.GetScorer(atomicContext, m_subReaders[i].LiveDocs); if (scorer != null) { collector.SetScorer(scorer); DocIdSetIterator filterDocIdIterator = filterDocIdSet.GetIterator(); // CHECKME: use ConjunctionScorer here? if (filterDocIdIterator == null) { continue; } int doc = -1; target = filterDocIdIterator.NextDoc(); if (mapReduceWrapper == null) { while (target < DocIdSetIterator.NO_MORE_DOCS) { if (doc < target) { doc = scorer.Advance(target); } if (doc == target) // permitted by filter { if (validator.Validate(doc)) { collector.Collect(doc); target = filterDocIdIterator.NextDoc(); } else { // skip to the next possible docid target = filterDocIdIterator.Advance(validator.m_nextTarget); } } else // doc > target { if (doc == DocIdSetIterator.NO_MORE_DOCS) { break; } target = filterDocIdIterator.Advance(doc); } } } else { //MapReduce wrapper is not null while (target < DocIdSetIterator.NO_MORE_DOCS) { if (doc < target) { doc = scorer.Advance(target); } if (doc == target) // permitted by filter { if (validator.Validate(doc)) { mapReduceWrapper.MapSingleDocument(doc, m_subReaders[i]); collector.Collect(doc); target = filterDocIdIterator.NextDoc(); } else { // skip to the next possible docid target = filterDocIdIterator.Advance(validator.m_nextTarget); } } else // doc > target { if (doc == DocIdSetIterator.NO_MORE_DOCS) { break; } target = filterDocIdIterator.Advance(doc); } } mapReduceWrapper.FinalizeSegment(m_subReaders[i], validator.GetCountCollectors()); } } } }
public override bool Score(ICollector collector, int maxDoc) { if (maxDoc != int.MaxValue) { throw new ArgumentOutOfRangeException(nameof(maxDoc), "maxDoc must be System.Int32.MaxValue"); // LUCENENET specific - changed from IllegalArgumentException to ArgumentOutOfRangeException (.NET convention) } //if (DEBUG) { // System.out.println("\nscore: reader=" + context.reader()); //} //System.out.println("score r=" + context.reader()); FakeScorer scorer = new FakeScorer(this); collector.SetScorer(scorer); if (drillDownCollector != null) { drillDownCollector.SetScorer(scorer); drillDownCollector.SetNextReader(context); } foreach (DocsAndCost dim in dims) { dim.sidewaysCollector.SetScorer(scorer); dim.sidewaysCollector.SetNextReader(context); } // TODO: if we ever allow null baseScorer ... it will // mean we DO score docs out of order ... hmm, or if we // change up the order of the conjuntions below if (Debugging.AssertsEnabled) { Debugging.Assert(baseScorer != null); } // some scorers, eg ReqExlScorer, can hit NPE if cost is called after nextDoc long baseQueryCost = baseScorer.GetCost(); int numDims = dims.Length; long drillDownCost = 0; for (int dim = 0; dim < numDims; dim++) { DocIdSetIterator disi = dims[dim].disi; if (dims[dim].bits is null && disi != null) { drillDownCost += disi.GetCost(); } } long drillDownAdvancedCost = 0; if (numDims > 1 && dims[1].disi != null) { drillDownAdvancedCost = dims[1].disi.GetCost(); } // Position all scorers to their first matching doc: baseScorer.NextDoc(); int numBits = 0; foreach (DocsAndCost dim in dims) { if (dim.disi != null) { dim.disi.NextDoc(); } else if (dim.bits != null) { numBits++; } } IBits[] bits = new IBits[numBits]; ICollector[] bitsSidewaysCollectors = new ICollector[numBits]; DocIdSetIterator[] disis = new DocIdSetIterator[numDims - numBits]; ICollector[] sidewaysCollectors = new ICollector[numDims - numBits]; int disiUpto = 0; int bitsUpto = 0; for (int dim = 0; dim < numDims; dim++) { DocIdSetIterator disi = dims[dim].disi; if (dims[dim].bits is null) { disis[disiUpto] = disi; sidewaysCollectors[disiUpto] = dims[dim].sidewaysCollector; disiUpto++; } else { bits[bitsUpto] = dims[dim].bits; bitsSidewaysCollectors[bitsUpto] = dims[dim].sidewaysCollector; bitsUpto++; } } /* * System.out.println("\nbaseDocID=" + baseScorer.docID() + " est=" + estBaseHitCount); * System.out.println(" maxDoc=" + context.reader().maxDoc()); * System.out.println(" maxCost=" + maxCost); * System.out.println(" dims[0].freq=" + dims[0].freq); * if (numDims > 1) { * System.out.println(" dims[1].freq=" + dims[1].freq); * } */ if (bitsUpto > 0 || scoreSubDocsAtOnce || baseQueryCost < drillDownCost / 10) { //System.out.println("queryFirst: baseScorer=" + baseScorer + " disis.length=" + disis.length + " bits.length=" + bits.length); DoQueryFirstScoring(collector, disis, sidewaysCollectors, bits, bitsSidewaysCollectors); } else if (numDims > 1 && (dims[1].disi is null || drillDownAdvancedCost < baseQueryCost / 10)) { //System.out.println("drillDownAdvance"); DoDrillDownAdvanceScoring(collector, disis, sidewaysCollectors); }