public override bool Score(ICollector collector, int maxDoc) { // the normalization trick already applies the boost of this query, // so we can use the wrapped scorer directly: collector.SetScorer(scorer); if (scorer.DocID == -1) { scorer.NextDoc(); } while (true) { int scorerDoc = scorer.DocID; if (scorerDoc < maxDoc) { if (filterBits.Get(scorerDoc)) { collector.Collect(scorerDoc); } scorer.NextDoc(); } else { break; } } return(scorer.DocID != Scorer.NO_MORE_DOCS); }
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); other.SetScorer(cachedScorer); while (curBase + curUpto < seg.End) { if (curUpto == m_curDocs.Length) { curBase += m_curDocs.Length; m_curDocs = m_cachedDocs[chunkUpto]; curScores = cachedScores[chunkUpto]; chunkUpto++; curUpto = 0; } cachedScorer.score = curScores[curUpto]; cachedScorer.doc = m_curDocs[curUpto]; other.Collect(m_curDocs[curUpto++]); } } }
public virtual void SetScorer(Scorer scorer) { // Set a ScoreCachingWrappingScorer in case the wrapped Collector will call // score() also. this.scorer = new ScoreCachingWrappingScorer(scorer); c.SetScorer(this.scorer); }
public override bool Score(ICollector c, int maxDoc) { Debug.Assert(doc == -1); doc = 3000; FakeScorer fs = new FakeScorer(); fs.doc = doc; fs.score = 1.0f; c.SetScorer(fs); c.Collect(3000); return(false); }
public override bool Score(ICollector collector, int max) { FakeScorer fakeScorer = new FakeScorer(); collector.SetScorer(fakeScorer); if (_doc == -1) { _doc = NextDocOutOfOrder(); } while (_doc < max) { fakeScorer.doc = _doc; fakeScorer._score = outerInstance._scores[outerInstance._ords[_scoreUpto]]; collector.Collect(_doc); _doc = NextDocOutOfOrder(); } return(_doc != DocIdSetIterator.NO_MORE_DOCS); }
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 override bool Score(ICollector collector, int max) { // TODO: this may be sort of weird, when we are // embedded in a BooleanScorer, because we are // called for every chunk of 2048 documents. But, // then, scorer is a FakeScorer in that case, so any // Collector doing something "interesting" in // setScorer will be forced to use BS2 anyways: collector.SetScorer(scorer); if (max == DocIdSetIterator.NO_MORE_DOCS) { ScoreAll(collector, scorer); return(false); } else { int doc = scorer.DocID; if (doc < 0) { doc = scorer.NextDoc(); } return(ScoreRange(collector, scorer, doc, max)); } }
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 max) { collector.SetScorer(new FakeScorer()); collector.Collect(0); return(false); }
public virtual void SetScorer(Scorer scorer) { // we must wrap again here, but using the value passed in as parameter: collector.SetScorer(new ConstantScorer(outerInstance.outerInstance, scorer, outerInstance.weight, outerInstance.theScore)); }
public virtual void SetScorer(Scorer scorer) { Other.SetScorer(scorer); SubScorers.Clear(); SetSubScorers(scorer, "TOP"); }
public virtual void SetScorer(Scorer scorer) => @in.SetScorer(AssertingScorer.GetAssertingScorer(random, scorer));
public virtual void SetScorer(Scorer scorer) { m_in.SetScorer(scorer); }
public override bool Score(ICollector collector, int maxDoc) { if (maxDoc != int.MaxValue) { throw new ArgumentException("maxDoc must be System.Int32.MaxValue"); } //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 == 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 == 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 == null || drillDownAdvancedCost < baseQueryCost / 10)) { //System.out.println("drillDownAdvance"); DoDrillDownAdvanceScoring(collector, disis, sidewaysCollectors); } else { //System.out.println("union"); DoUnionScoring(collector, disis, sidewaysCollectors); } return(false); }
public override bool Score(ICollector collector, int max) { bool more; Bucket tmp; FakeScorer fs = new FakeScorer(); // The internal loop will set the score and doc before calling collect. collector.SetScorer(fs); do { bucketTable.first = null; while (current != null) // more queued { // check prohibited & required if ((current.Bits & PROHIBITED_MASK) == 0) { // TODO: re-enable this if BQ ever sends us required // clauses //&& (current.bits & requiredMask) == requiredMask) { // NOTE: Lucene always passes max = // Integer.MAX_VALUE today, because we never embed // a BooleanScorer inside another (even though // that should work)... but in theory an outside // app could pass a different max so we must check // it: if (current.Doc >= max) { tmp = current; current = current.Next; tmp.Next = bucketTable.first; bucketTable.first = tmp; continue; } if (current.Coord >= minNrShouldMatch) { fs.score = (float)(current.Score * coordFactors[current.Coord]); fs.doc = current.Doc; fs.freq = current.Coord; collector.Collect(current.Doc); } } current = current.Next; // pop the queue } if (bucketTable.first != null) { current = bucketTable.first; bucketTable.first = current.Next; return(true); } // refill the queue more = false; end += BucketTable.SIZE; for (SubScorer sub = scorers; sub != null; sub = sub.Next) { if (sub.More) { sub.More = sub.Scorer.Score(sub.Collector, end); more |= sub.More; } } current = bucketTable.first; } while (current != null || more); return(false); }
public void SetScorer(Scorer scorer) { this.Scorer_Renamed = scorer; fakeScorer = new FakeScorer(); @in.SetScorer(fakeScorer); }
public void SetScorer(Scorer scorer) { this.scorer = scorer; fakeScorer = new FakeScorer(); @in.SetScorer(fakeScorer); }