简单介绍下在较早版本的Lucene中对一定范围内的查询RanageQuery。该Query继承于MulitTermQuery，在重写（rewrite）Query树的时候将会遵从一个原则：

根据起始区间值获取term,然后遍历，根据满足条件的term的数目来决定重写Query的类型

如下代码所示：

FilteredTermEnum enumerator = query.getEnum(reader);//PrefixTermEnum
try {
while(true) {一个循环，取出与MultiTermQuery相关的所有的Term。
Term t = enumerator.term();
if (t != null) {
pendingTerms.add(t);//将满足条件的term搜集
// Loading the TermInfo from the terms dict here
// should not be costly, because 1) the// query/filter will load the TermInfo when it  runs, and 2) the terms dict has a cache:
docVisitCount += reader.docFreq(t);//获取词频
}
// 方式一 ：如果Term数目超限，或者文档数目超限，则可能非常影响倒排表合并的性能，采用Filter方式
if (pendingTerms.size() >= termCountLimit || docVisitCount >= docCountCutoff) {
// Too many terms -- make a filter.
Query result = new ConstantScoreQuery(new MultiTermQueryWrapperFilter(query));
result.setBoost(query.getBoost());
return result;
//方式二：如果Term 数目不太多，而且文档数目也不太多，不会影响倒排表合并的性能
} else  if (!enumerator.next()) {
// Enumeration is done, and we hit a small
// enough number of terms & docs -- just make a
// BooleanQuery, now
Iterator it = pendingTerms.iterator();
BooleanQuery bq = new BooleanQuery(true);//构建BooleanQuery
while(it.hasNext()) {//将区间Query分解成独立的TermQuery后构造成BooleanQuery,最终通过每个TermQuery的结果合并的方式来达到区间查询的目的
TermQuery tq = new TermQuery((Term) it.next());
bq.add(tq, BooleanClause.Occur.SHOULD);
}
// Strip scores
Query result = new ConstantScoreQuery(new QueryWrapperFilter(bq));
result.setBoost(query.getBoost());
query.incTotalNumberOfTerms(pendingTerms.size());
return result;
}
}
} finally {
enumerator.close();
}

（图一）具体见MultiTermQuery.ConstantScoreAutoRewrite.rewrite()方法


两种方式区别：


方式一：如果区间范围较大，获取terms较多则采取Filter过滤的方式遍历以start开始的term，获取[start,end]的范围内的TermEnum从而取出docIDSet。

方式二：如果区间范围不大，获取terms不多，将区间Query分解成多个termQuery独立查询，然后根据BooleanQuery来合并docId

缺点：

方式一：只支持字符串形式的范围查询，区间满足的term数据越多，查询性能越差。

方式二：会构造太多termQuery很可能造成TooManyClause异常，而且获取结果再合并将极大影响性能。

因为方式二其实现和普通BooleanQuery–>termQuery查询方式一致，而本文主要阐述Range查询，所以将不会方式二实现原理。

OK，那我们看看TermRangeQuery如何实现查询的，我们知道重写Query树后，接下来就是生成weight树，从图一中可以看到方式一中重写的RangeQuey被包装成ConstantScoreQuery(newMultiTermQueryWrapperFilter(query));那么从下面的代码实现结构可以看到生成的weight：

ConstantScoreQuery.createWeight()

|

|–newConstantScoreQuery.ConstantWeight(searcher);

生成Weight树后，weight树将负责Scorer树的生成，如下代码实现结构所示:

ConstantWeight.  Scorer()
|
|– new  ConstantScorer ( similarity , reader, this  );
|
|– DocIdSet docIdSet  =  MultiTermQueryWrapperFilter .getDocIdSet(reader) ;
|–    DocIdSetIterator iter = docIdSet.iterator();
|–      docIdSetIterator = iter;

Query树->weight树->Scorer树生成后，将开始打分并收集docId的过程。如下所示：

Scorer scorer = weight.scorer();
|
|– scorer.score(collector);//scorer= ConstantScorer

整个score过程是遍历直到取出的值==NO_MORE_DOCS。见如下代码所示：

public void score(Collector collector) throws IOException {
collector.setScorer(this);
int doc;
while ((doc = nextDoc()) != NO_MORE_DOCS) {
collector.collect(doc);
}
}

而nextDoc由ConstantScorer实现：

public int nextDoc() throws IOException {
return docIdSetIterator.nextDoc();
}

结合ConstantScorer的构造函数可以看到整个docId的范围过滤都在：

// filter= MultiTermQueryWrapperFilter得到所有的文档号，形成统一的倒排表，参与倒排表合并。
DocIdSet docIdSet = filter.getDocIdSet(reader);

完成，接下来在看看该方法的具体实现：


MultiTermQueryWrapperFilter.getDocIdSet(reader）；

|//得到TermRangeQuery的Term枚举器

|–finalTermEnumenumerator=query.getEnum(reader);

|

|–newTermRangeTermEnum(reader,field,lowerTerm,upperTerm,includeLower,includeUpper,collator);

TermRangeTermEnum的构造函数其包含的成员变量如下：

_StringlowerTerm;左边界字符串

_StringupperTerm;右边界字符串

_booleanincludeLower;是否包括左边界

_booleanincludeUpper;是否包含右边界

_Stringfield;域

_Collatorcollator;其允许用户实现其函数intcompare(Stringsource,Stringtarget)来决定怎么样算是大于，怎么样算是小于。

TermRangeTermEnum来保证满足区间条件的term能被MultiTermQueryWrapperFilter.TermGenerator.generate()方法收集到OpenBitSet中，如下所示：

public DocIdSet getDocIdSet(IndexReader reader) throws IOException {
final TermEnum enumerator = query.getEnum(reader);得到MultiTermQuery的Term枚举器
try {
// if current term in enum is null, the enum is empty -> shortcut
if (enumerator.term() == null)
return DocIdSet.EMPTY_DOCIDSET;
// else fill into a OpenBitSet
final OpenBitSet bitSet = new OpenBitSet(reader.maxDoc());//创建包含多个Term的文档号集合
new TermGenerator() {
public void handleDoc(int doc) {
bitSet.set(doc);
}
}.generate(reader, enumerator);
return bitSet;
} finally {
enumerator.close();
}
}

而generate()具体实现为：

public void generate(IndexReader reader, TermEnum enumerator) throws IOException {
final int[] docs = new int[32];
final int[] freqs = new int[32];
TermDocs termDocs = reader.termDocs();
try {
int termCount = 0;
do {一个循环，取出对应的所有的Term，取出他们的文档号，加入集合
Term term = enumerator.term();
if (term == null)
break;
termCount++;
termDocs.seek(term);//term定位到搜索条件的指定的Term开始往后遍历
while (true) {
final int count = termDocs.read(docs, freqs);
if (count != 0) {
for(int i=0;i<count;i++) {
handleDoc(docs[i]);
}
} else {
break;
}
}
} while (enumerator.next());
query.incTotalNumberOfTerms(termCount);
} finally {
termDocs.close();
}
}

从上述代码可以看出TermRangeTermEnum最关键的2个方法就是term()和next()方法，

（1）TermRangeTermEnum.term()方法是获取遍历过程中当前的term。

（2）TermRangeTermEnum.next()方法是遍历Term的枚举列表

在TermRangeTermEnum并没有重写next()方法，所以从父类FilteredTermEnum中的next可以看到：

public boolean next() throws IOException {
if (actualEnum == null) return false; // the actual enumerator is not initialized!
currentTerm = null;
while (currentTerm == null) {
if (endEnum()) return false;
if (actualEnum.next()) {
Term term = actualEnum.term();
if (termCompare(term)) {// 满足前缀就OK
currentTerm = term;
return true;
}
}
else return false;
}
currentTerm = null;
return false;
}

从上述代码可以得知遍历结束取决：

（1）endEnum()==true;//结束枚举遍历

（2）actualEnum.next()==false;//整个term的枚举遍历完毕

（3）termCompare(term)==false;//当前的term字符串不在[start,end]区间范围内

而从termRanageTermEnum中endEnum其实也是由termCompare(term)方法来影响，所以人为能影响的区间查询都由termCompare方法来决定，代码如下所示：

protected boolean termCompare(Term term) {
if (collator == null) {//如果用户没有设定collator，则使用字符串比较。
// Use Unicode code point ordering
boolean checkLower = false;
if (!includeLower) // make adjustments to set to exclusive
checkLower = true;
if (term != null && term.field() == field) { // interned comparison
if (!checkLower || null==lowerTermText || term.text().compareTo(lowerTermText) > 0) {
checkLower = false;
if (upperTermText != null) {
int compare = upperTermText.compareTo(term.text());
最大的termText小于当前的termText值则标示不在区间内所以返回false,
//同时置endEnum=true;立即结束整个遍历查询过程
if ((compare < 0) ||
(!includeUpper && compare==0)) {
endEnum = true;
return false;
}
}
return true;
}
} else {
// break
endEnum = true;
return false;
}
return false;
} else {//用户设定自己订阅的collator,从而人为控制term值的大小比较
if (term != null && term.field() == field) { // interned comparison
if ((lowerTermText == null
|| (includeLower
? collator.compare(term.text(), lowerTermText) >= 0
: collator.compare(term.text(), lowerTermText) > 0))
&& (upperTermText == null
|| (includeUpper
? collator.compare(term.text(), upperTermText) <= 0
: collator.compare(term.text(), upperTermText) < 0))) {
return true;
}
return false;
}
endEnum = true;
return false;
}
}

如上代码所述,区间查询的时间是和区间范围内term的个数有关系的，也就是说如果区间范围越大，意味着查询的next()term的次数也会更多。

另外该范围查询只支持字符串范围查询，并不支持数值型的范围查询。所以从Lucene2.9开始，Lucene提供对数字范围的支持，但是然而欲使用此查询，必须使用NumericField来添加域。这也是NumericField和numericRangeQuery结合起来的数值型范围查询。