Collector decouples the score from the collected doc: the score computation is skipped entirely
if it's not needed. Collectors that do need the score should implement the #setScorer
method, to hold onto the passed Scorer instance, and call Scorer#score() within
the collect method to compute the current hit's score. If your collector may request the score
for a single hit multiple times, you should use ScoreCachingWrappingScorer.
NOTE: The doc that is passed to the collect method is relative to the current reader. If your collector needs to resolve this to the docID space of the Multi*Reader, you must re-base it by recording the docBase from the most recent setNextReader call. Here's a simple example showing how to collect docIDs into a BitSet:
IndexSearcher searcher = new IndexSearcher(indexReader);
final BitSet bits = new BitSet(indexReader.maxDoc());
searcher.search(query, new Collector() {
public LeafCollector getLeafCollector(LeafReaderContext context)
throws IOException {
final int docBase = context.docBase;
return new LeafCollector() {
// ignore scorer
public void setScorer(Scorer scorer) throws IOException {
}
public void collect(int doc) throws IOException {
bits.set(docBase + doc);
}
};
}
});
Not all collectors will need to rebase the docID. For example, a collector that simply counts the total number of hits would skip it.
collect(int doc)Called once for every document matching a query, with the unbased document number.
Note: The collection of the current segment can be terminated by throwing a CollectionTerminatedException. In this case, the last docs of the current org.apache.lucene.index.LeafReaderContext will be skipped and IndexSearcher will
swallow the exception and continue collection with the next leaf.
Note: This is called in an inner search loop. For good search performance, implementations
of this method should not call StoredFields#document on every hit. Doing so can slow
searches by an order of magnitude or more.
Bulk-collect doc IDs.
Note: The provided DocIdStream may be reused across calls and should be consumed
immediately.
Note: The provided DocIdStream typically only holds a small subset of query matches.
This method may be called multiple times per segment.
Like #collect(int), it is guaranteed that doc IDs get collected in order, ie. doc
IDs are collected in order within a DocIdStream, and if called twice, all doc IDs from
the second DocIdStream will be greater than all doc IDs from the first DocIdStream.
It is legal for callers to mix calls to #collect(DocIdStream) and #collect(int).
The default implementation calls stream.forEach(this::collect).
collectRange(int min, int max)Collect a range of doc IDs, between min inclusive and max exclusive.
max is guaranteed to be greater than min.
Extending this method is typically useful to take advantage of pre-aggregated data exposed
in a DocValuesSkipper.
The default implementation calls #collect(DocIdStream) on a DocIdStream that
matches the given range.
Optionally returns an iterator over competitive documents.
Collectors should delegate this method to their comparators if their comparators provide the skipping functionality over non-competitive docs.
The default is to return null which is interpreted as the collector provide any
competitive iterator.
finish()Hook that gets called once the leaf that is associated with this collector has finished
collecting successfully, including when a CollectionTerminatedException is thrown. This
is typically useful to compile data that has been collected on this leaf, e.g. to convert facet
counts on leaf ordinals to facet counts on global ordinals. The default implementation does
nothing.
Note: It can be assumed that this method will only be called once per LeafCollector instance.
setScorer(org.apache.lucene.search.Scorable scorer) · also: set_scorerCalled before successive calls to #collect(int). Implementations that need the score of
the current document (passed-in to #collect(int)), should save the passed-in Scorer and
call scorer.score() when needed.