Lucene学习总结之七：Lucene搜索过程解析(8)转

2.4、搜索查询对象

 

 

2.4.4、收集文档结果集合及计算打分

在函数IndexSearcher.search(Weight, Filter, int) 中，有如下代码：

TopScoreDocCollector collector = TopScoreDocCollector.create(nDocs, !weight.scoresDocsOutOfOrder());

search(weight, filter, collector);

return collector.topDocs();

2.4.4.1、创建结果文档收集器

TopScoreDocCollector collector = TopScoreDocCollector.create(nDocs, !weight.scoresDocsOutOfOrder());

public static TopScoreDocCollector create(int numHits, boolean docsScoredInOrder) {

  if (docsScoredInOrder) {

    return new InOrderTopScoreDocCollector(numHits);

  } else {

    return new OutOfOrderTopScoreDocCollector(numHits);

  }

}

其根据是否按照文档号从小到大返回文档而创建InOrderTopScoreDocCollector或者OutOfOrderTopScoreDocCollector，两者的不同在于收集文档的方式不同。

2.4.4.2、收集文档号

当创建完毕Scorer对象树和SumScorer对象树后，IndexSearcher.search(Weight, Filter, Collector) 有以下调用：

scorer.score(collector) ，如下代码所示，其不断的得到合并的倒排表后的文档号，并收集它们。

public void score(Collector collector) throws IOException {

  collector.setScorer(this);

  while ((doc = countingSumScorer.nextDoc()) != NO_MORE_DOCS) {

    collector.collect(doc);

  }

}

InOrderTopScoreDocCollector的collect函数如下：

public void collect(int doc) throws IOException {

  float score = scorer.score();

  totalHits++;

  if (score <= pqTop.score) {

    return;

  }

  pqTop.doc = doc + docBase;

  pqTop.score = score;

  pqTop = pq.updateTop();

}

OutOfOrderTopScoreDocCollector的collect函数如下：

public void collect(int doc) throws IOException {

  float score = scorer.score();

  totalHits++;

  doc += docBase;

  if (score < pqTop.score || (score == pqTop.score && doc > pqTop.doc)) {

    return;

  }

  pqTop.doc = doc;

  pqTop.score = score;

  pqTop = pq.updateTop();

}

从上面的代码可以看出，collector的作用就是首先计算文档的打分，然后根据打分，将文档放入优先级队列(最小堆)中，最后在优先级队列中取前N篇文档。

然而存在一个问题，如果要取10篇文档，而第8,9,10,11,12篇文档的打分都相同，则抛弃那些呢？Lucene的策略是，在文档打分相同的情况下，文档号小的优先。

也即8,9,10被保留，11,12被抛弃。

由上面的叙述可知，创建collector的时候，根据文档是否将按照文档号从小到大的顺序返回而创建InOrderTopScoreDocCollector或者OutOfOrderTopScoreDocCollector。

对于InOrderTopScoreDocCollector，由于文档是按照顺序返回的，后来的文档号肯定大于前面的文档号，因而当score <= pqTop.score的时候，直接抛弃。

对于OutOfOrderTopScoreDocCollector，由于文档不是按顺序返回的，因而当score<pqTop.score，自然直接抛弃，当score==pqTop.score的时候，则要比较后来的文档和前面的文档的大小，如果大于，则抛弃，如果小于则入队列。

2.4.4.3、打分计算

BooleanScorer2的打分函数如下：

• 将子语句的打分乘以coord

public float score() throws IOException {

  coordinator.nrMatchers = 0;

  float sum = countingSumScorer.score();

  return sum * coordinator.coordFactors[coordinator.nrMatchers];

}

ConjunctionScorer的打分函数如下：

• 将取交集的子语句的打分相加，然后乘以coord

public float score() throws IOException {

  float sum = 0.0f;

  for (int i = 0; i < scorers.length; i++) {

    sum += scorers[i].score();

  }

  return sum * coord;

}

DisjunctionSumScorer的打分函数如下：

public float score() throws IOException { return currentScore; }

currentScore计算如下：

currentScore += scorerDocQueue.topScore();

以上计算是在DisjunctionSumScorer的倒排表合并算法中进行的，其是取堆顶的打分函数。

public final float topScore() throws IOException {

    return topHSD.scorer.score();

}

ReqExclScorer的打分函数如下：

• 仅仅取required语句的打分

public float score() throws IOException {

  return reqScorer.score();

}

ReqOptSumScorer的打分函数如下：

• 上面曾经指出，ReqOptSumScorer的nextDoc()函数仅仅返回required语句的文档号。
• 而optional的部分仅仅在打分的时候有所体现，从下面的实现可以看出optional的语句的分数加到required语句的分数上，也即文档还是required语句包含的文档，只不过是当此文档能够满足optional的语句的时候，打分得到增加。

public float score() throws IOException {

  int curDoc = reqScorer.docID();

  float reqScore = reqScorer.score();

  if (optScorer == null) {

    return reqScore;

  }

  int optScorerDoc = optScorer.docID();

  if (optScorerDoc < curDoc && (optScorerDoc = optScorer.advance(curDoc)) == NO_MORE_DOCS) {

    optScorer = null;

    return reqScore;

  }

  return optScorerDoc == curDoc ? reqScore + optScorer.score() : reqScore;

}

TermScorer的打分函数如下：

• 整个Scorer及SumScorer对象树的打分计算，最终都会源自叶子节点TermScorer上。
• 从TermScorer的计算可以看出，它计算出tf * norm * weightValue = tf * norm * queryNorm * idf^2 * t.getBoost()

public float score() {

  int f = freqs[pointer];

  float raw = f < SCORE_CACHE_SIZE ? scoreCache[f] : getSimilarity().tf(f)*weightValue;       

  return norms == null ? raw : raw * SIM_NORM_DECODER[norms[doc] & 0xFF];

}

Lucene的打分公式整体如下，2.4.1计算了图中的红色的部分，此步计算了蓝色的部分：

 

打分计算到此结束。

2.4.4.4、返回打分最高的N篇文档

IndexSearcher.search(Weight, Filter, int)中，在收集完文档后，调用collector.topDocs()返回打分最高的N篇文档：

public final TopDocs topDocs() {

  return topDocs(0, totalHits < pq.size() ? totalHits : pq.size());

}

public final TopDocs topDocs(int start, int howMany) {

  int size = totalHits < pq.size() ? totalHits : pq.size();

  howMany = Math.min(size - start, howMany);

  ScoreDoc[] results = new ScoreDoc[howMany];

  //由于pq是最小堆，因而要首先弹出最小的文档。比如qp中总共有50篇文档，想取第5到10篇文档，则应该先弹出打分最小的40篇文档。

  for (int i = pq.size() - start - howMany; i > 0; i--) { pq.pop(); }

  populateResults(results, howMany);

  return newTopDocs(results, start);

}

protected void populateResults(ScoreDoc[] results, int howMany) {

  //然后再从pq弹出第5到10篇文档，并按照打分从大到小的顺序放入results中。

  for (int i = howMany - 1; i >= 0; i--) {

    results[i] = pq.pop();

  }

}

protected TopDocs newTopDocs(ScoreDoc[] results, int start) {

  return results == null ? EMPTY_TOPDOCS : new TopDocs(totalHits, results);

}

 

 

 

 

 

2.4.5、Lucene如何在搜索阶段读取索引信息

以上叙述的是搜索过程中如何进行倒排表合并以及计算打分。然而索引信息是从索引文件中读出来的，下面分析如何读取这些信息。

其实读取的信息无非是两种信息，一个是词典信息，一个是倒排表信息。

词典信息的读取是在Scorer对象树生成的时候进行的，真正读取这些信息的是叶子节点TermScorer。

倒排表信息的读取时在合并倒排表的时候进行的，真正读取这些信息的也是叶子节点TermScorer.nextDoc()。

2.4.5.1、读取词典信息

此步是在TermWeight.scorer(IndexReader, boolean, boolean) 中进行的，其代码如下：

public Scorer scorer(IndexReader reader, boolean scoreDocsInOrder, boolean topScorer) {

  TermDocs termDocs = reader.termDocs(term);

  if (termDocs == null)

    return null;

  return new TermScorer(this, termDocs, similarity, reader.norms(term.field()));

}

ReadOnlySegmentReader.termDocs(Term)是找到Term并生成用来读倒排表的TermDocs对象：

public TermDocs termDocs(Term term) throws IOException {

  ensureOpen();

  TermDocs termDocs = termDocs();

  termDocs.seek(term);

  return termDocs;

}

termDocs()函数首先生成SegmentTermDocs对象，用于读取倒排表：

protected SegmentTermDocs(SegmentReader parent) {

  this.parent = parent;

  this.freqStream = (IndexInput) parent.core.freqStream.clone();//用于读取freq

  synchronized (parent) {

    this.deletedDocs = parent.deletedDocs;

  }

  this.skipInterval = parent.core.getTermsReader().getSkipInterval();

  this.maxSkipLevels = parent.core.getTermsReader().getMaxSkipLevels();

}

SegmentTermDocs.seek(Term)是读取词典中的Term，并将freqStream指向此Term对应的倒排表：

public void seek(Term term) throws IOException {

  TermInfo ti = parent.core.getTermsReader().get(term);

  seek(ti, term);

}

TermInfosReader.get(Term, boolean)主要是读取词典中的Term得到TermInfo，代码如下：

  private TermInfo get(Term term, boolean useCache) {

    if (size == 0) return null;

    ensureIndexIsRead();

    TermInfo ti;

    ThreadResources resources = getThreadResources();

    SegmentTermEnum enumerator = resources.termEnum;

    seekEnum(enumerator, getIndexOffset(term));

    enumerator.scanTo(term);

    if (enumerator.term() != null && term.compareTo(enumerator.term()) == 0) {

      ti = enumerator.termInfo();

    } else {

      ti = null;

    }

    return ti;

  }

在IndexReader打开一个索引文件夹的时候，会从tii文件中读出的Term index到indexPointers数组中，TermInfosReader.seekEnum(SegmentTermEnum enumerator, int indexOffset)负责在indexPointers数组中找Term对应的tis文件中所在的跳表区域的位置。

private final void seekEnum(SegmentTermEnum enumerator, int indexOffset) throws IOException {

  enumerator.seek(indexPointers[indexOffset],

                 (indexOffset * totalIndexInterval) - 1,

                 indexTerms[indexOffset], indexInfos[indexOffset]);

}

final void SegmentTermEnum.seek(long pointer, int p, Term t, TermInfo ti) {

  input.seek(pointer);

  position = p;

  termBuffer.set(t);

  prevBuffer.reset();

  termInfo.set(ti);

}

SegmentTermEnum.scanTo(Term)在跳表区域中，一个一个往下找，直到找到Term：

final int scanTo(Term term) throws IOException {

  scanBuffer.set(term);

  int count = 0;

  //不断取得下一个term到termBuffer中，目标term放入scanBuffer中，当两者相等的时候，目标Term找到。

  while (scanBuffer.compareTo(termBuffer) > 0 && next()) {

    count++;

  }

  return count;

}

public final boolean next() throws IOException {

  if (position++ >= size - 1) {

    prevBuffer.set(termBuffer);

    termBuffer.reset();

    return false;

  }

  prevBuffer.set(termBuffer);

  //读取Term的字符串

  termBuffer.read(input, fieldInfos);

  //读取docFreq，也即多少文档包含此Term

  termInfo.docFreq = input.readVInt();

  //读取偏移量

  termInfo.freqPointer += input.readVLong();

  termInfo.proxPointer += input.readVLong();

  if (termInfo.docFreq >= skipInterval)

      termInfo.skipOffset = input.readVInt();

  indexPointer += input.readVLong();

  return true;

}

TermBuffer.read(IndexInput, FieldInfos) 代码如下：

  public final void read(IndexInput input, FieldInfos fieldInfos) {

    this.term = null;

    int start = input.readVInt();

    int length = input.readVInt();

    int totalLength = start + length;

    text.setLength(totalLength);

    input.readChars(text.result, start, length);

    this.field = fieldInfos.fieldName(input.readVInt());

  }

SegmentTermDocs.seek(TermInfo ti, Term term)根据TermInfo，将freqStream指向此Term对应的倒排表位置：

void seek(TermInfo ti, Term term) {

  count = 0;

  FieldInfo fi = parent.core.fieldInfos.fieldInfo(term.field);

  df = ti.docFreq;

  doc = 0;

  freqBasePointer = ti.freqPointer;

  proxBasePointer = ti.proxPointer;

  skipPointer = freqBasePointer + ti.skipOffset;

  freqStream.seek(freqBasePointer);

  haveSkipped = false;

}

2.4.5.2、读取倒排表信息

当读出Term的信息得到TermInfo后，并且freqStream指向此Term的倒排表位置的时候，下面就是在TermScorer.nextDoc()函数中读取倒排表信息：

public int nextDoc() throws IOException {

  pointer++;

  if (pointer >= pointerMax) {

    pointerMax = termDocs.read(docs, freqs);   

    if (pointerMax != 0) {

      pointer = 0;

    } else {

      termDocs.close();

      return doc = NO_MORE_DOCS;

    }

  }

  doc = docs[pointer];

  return doc;

}

SegmentTermDocs.read(int[], int[]) 代码如下：

 

public int read(final int[] docs, final int[] freqs) {

  final int length = docs.length;

  int i = 0;

  while (i < length && count < df) {

    //读取docid

    final int docCode = freqStream.readVInt();

    doc += docCode >>> 1;

    if ((docCode & 1) != 0)      

      freq = 1;        

    else

      freq = freqStream.readVInt();     //读取freq

    count++;

    if (deletedDocs == null || !deletedDocs.get(doc)) {

      docs[i] = doc;

      freqs[i] = freq;

      ++i;

    }

    return i;

  }

}