solr中docValues字段排序源码分析

分析docValues的字段的排序实现

根据各种字段的类型不同需要有不同的comparator
首先排序需要使用TopFieldCollector来收集doc
topCollector = TopFieldCollector.create(weightSort(cmd.getSort()), len,
false, needScores, needScores, true);
org.apache.lucene.search.TopFieldCollector.create(Sort, int, boolean, boolean, boolean, boolean)
org.apache.lucene.search.TopFieldCollector.create(Sort, int, FieldDoc, boolean, boolean, boolean, boolean)
这个方法中首先新建一个优先队列
FieldValueHitQueue<Entry> queue = FieldValueHitQueue.create(sort.fields, numHits);
org.apache.lucene.search.FieldValueHitQueue.create(SortField[], int)

if (fields.length == 1) {//如果排序的字段只有一个就用OneComparatorFieldValueHitQueue
return new OneComparatorFieldValueHitQueue<T>(fields, size);
} else {//如果排序的字段有多个那么用MultiComparatorsFieldValueHitQueue
return new MultiComparatorsFieldValueHitQueue<T>(fields, size);
}
假设只有一个字段下面就是OneComparatorFieldValueHitQueue的初始化的过程org.apache.lucene.search.FieldValueHitQueue.OneComparatorFieldValueHitQueue.OneComparatorFieldValueHitQueue(SortField[], int)
首先调用父类的初始化org.apache.lucene.search.FieldValueHitQueue.FieldValueHitQueue(SortField[], int)
首先初始化队列的大小然后定义comparator
comparators = new FieldComparator[numComparators];
reverseMul = new int[numComparators];

setComparator(0,field.getComparator(size, 0));
org.apache.lucene.search.SortField.getComparator(int, int)

switch (type) {根据不同的type设置不同的comparator
case SCORE:
return new FieldComparator.RelevanceComparator(numHits);
case DOC:
return new FieldComparator.DocComparator(numHits);

接下来回到solrIndexSearcher，就要调用lucene的IndexSearcher的
super.search(query, luceneFilter, collector);
org.apache.lucene.search.IndexSearcher.search(Query, Filter, Collector)
org.apache.lucene.search.IndexSearcher.search(List<AtomicReaderContext>, Weight, Collector)

for (AtomicReaderContext ctx : leaves) { // search each subreader
try {
collector.setNextReader(ctx); //为collector设置reader
} catch (CollectionTerminatedException e) {
// there is no doc of interest in this reader context
// continue with the following leaf
continue;
}
Scorer scorer = weight.scorer(ctx, !collector.acceptsDocsOutOfOrder(), true, ctx.reader().getLiveDocs());//生成scorer
if (scorer != null) {
try {
scorer.score(collector);//打分
} catch (CollectionTerminatedException e) {
// collection was terminated prematurely
// continue with the following leaf
}
}
}
collector.setNextReader(ctx); 的过程分析：
org.apache.lucene.search.TopFieldCollector.OneComparatorNonScoringCollector.setNextReader(AtomicReaderContext)

public void setNextReader(AtomicReaderContext context) throws IOException {
this.docBase = context.docBase; //设置docid的base
queue.setComparator(0, comparator.setNextReader(context));//设置comparator
comparator = queue.firstComparator;
}
comparator.setNextReader(context)分析

@Override
public FieldComparator<Integer> setNextReader(AtomicReaderContext context) throws IOException {
// NOTE: must do this before calling super otherwise
// we compute the docsWithField Bits twice!
currentReaderValues = FieldCache.DEFAULT.getInts(context.reader(), field, parser, missingValue != null);
return super.setNextReader(context);
}

就会调用FieldCacheImpl的getInts，获取字段的field值

public Ints getInts(AtomicReader reader, String field, IntParser parser, boolean setDocsWithField)
throws IOException {
final NumericDocValues valuesIn = reader.getNumericDocValues(field);//首先检查字段是否是docValues的字段，如果是的话那么直接获取valuesIn
if (valuesIn != null) {
// Not cached here by FieldCacheImpl (cached instead
// per-thread by SegmentReader):
return new Ints() {
@Override
public int get(int docID) {
return (int) valuesIn.get(docID);
}
};
} else {
final FieldInfo info = reader.getFieldInfos().fieldInfo(field);
if (info == null) {
return Ints.EMPTY;
} else if (info.hasDocValues()) {
throw new IllegalStateException("Type mismatch: " + field + " was indexed as " + info.getDocValuesType());
} else if (!info.isIndexed()) {
return Ints.EMPTY;
}
return (Ints) caches.get(Integer.TYPE).get(reader, new CacheKey(field, parser), setDocsWithField);
}
}

下面分析收集docid并打分的过程
scorer.score(collector);
org.apache.lucene.search.Scorer.score(Collector)

public void score(Collector collector) throws IOException {
assert docID() == -1; // not started
collector.setScorer(this);
int doc;
// int count = 0;
// while (count < 100 && ((doc = nextDoc()) != NO_MORE_DOCS)) {
while ((doc = nextDoc()) != NO_MORE_DOCS) { //nextDoc()获取下一个满足检索条件的docid
collector.collect(doc);//收集并打分
// count++;
}
}
org.apache.lucene.search.TopFieldCollector.OneComparatorNonScoringCollector.collect(int)

@Override
public void collect(int doc) throws IOException {
++totalHits;
if (queueFull) {
if ((reverseMul * comparator.compareBottom(doc)) <= 0) {
// since docs are visited in doc Id order, if compare is 0, it means
// this document is larger than anything else in the queue, and
// therefore not competitive.
return;
}

// This hit is competitive - replace bottom element in queue & adjustTop
comparator.copy(bottom.slot, doc);
updateBottom(doc);
comparator.setBottom(bottom.slot);
} else {
// Startup transient: queue hasn't gathered numHits yet
final int slot = totalHits - 1;
// Copy hit into queue
comparator.copy(slot, doc);
add(slot, doc, Float.NaN);
if (queueFull) {
comparator.setBottom(bottom.slot);
}
}
}

org.apache.lucene.search.FieldComparator.IntComparator.copy(int, int)
org.apache.lucene.codecs.lucene42.Lucene42DocValuesProducer.loadNumeric(FieldInfo)