`

Lucene学习总结之七:Lucene搜索过程解析(3)

阅读更多

2.3、QueryParser解析查询语句生成查询对象

代码为:

QueryParser parser = new QueryParser(Version.LUCENE_CURRENT, "contents", new StandardAnalyzer(Version.LUCENE_CURRENT));

Query query = parser.parse("+(+apple* -boy) (cat* dog) -(eat~ foods)");

此过程相对复杂,涉及JavaCC,QueryParser,分词器,查询语法等,本章不会详细论述,会在后面的章节中一一说明。

此处唯一要说明的是,根据查询语句生成的是一个Query树,这棵树很重要,并且会生成其他的树,一直贯穿整个索引过程。

query    BooleanQuery  (id=96)   
  |  boost    1.0   
  |  clauses    ArrayList<E>  (id=98)   
  |      elementData    Object[10]  (id=100)   
  |------[0]    BooleanClause  (id=102)   
  |          |   occur    BooleanClause$Occur$1  (id=106)   
  |          |        name    "MUST" //AND  
  |          |        ordinal    0   
  |          |---query    BooleanQuery  (id=108)   
  |                  |   boost    1.0   
  |                  |   clauses    ArrayList<E>  (id=112)   
  |                  |      elementData    Object[10]  (id=113)   
  |                  |------[0]    BooleanClause  (id=114)   
  |                  |          |   occur    BooleanClause$Occur$1  (id=106)   
  |                  |          |      name    "MUST"   //AND 
  |                  |          |      ordinal    0   
  |                  |          |--query    PrefixQuery  (id=116)   
  |                  |                 boost    1.0   
  |                  |                 numberOfTerms    0   
  |                  |                 prefix    Term  (id=117)   
 
|                  |                     field    "contents"    
  |                  |                     text    "apple"   
  |                  |                 rewriteMethod    MultiTermQuery$1  (id=119)   
  |                  |                     docCountPercent    0.1   
  |                  |                     termCountCutoff    350   
  |                  |------[1]    BooleanClause  (id=115)    
  |                             |   occur    BooleanClause$Occur$3  (id=123)   
  |                             |       name    "MUST_NOT"   //NOT
  |                             |       ordinal    2   
  |                             |--query    TermQuery  (id=125)   
  |                                    boost    1.0   
  |                                    term    Term  (id=127)   
  |                                        field    "contents"   
  |                                        text    "boy"    
  |                      size    2   
  |                  disableCoord    false   
  |                  minNrShouldMatch    0   
  |------[1]    BooleanClause  (id=104)   
  |          |   occur    BooleanClause$Occur$2  (id=129)   
  |          |        name    "SHOULD"  //OR
  |          |        ordinal    1   
  |          |---query    BooleanQuery  (id=131)   
  |                  |   boost    1.0   
  |                  |   clauses    ArrayList<E>  (id=133)   
  |                  |      elementData    Object[10]  (id=134)   
  |                  |------[0]    BooleanClause  (id=135)   
  |                  |          |  occur    BooleanClause$Occur$2  (id=129)   
  |                  |          |      name    "SHOULD"  //OR  
  |                  |          |      ordinal    1   
  |                  |          |--query    PrefixQuery  (id=137)   
  |                  |                 boost    1.0   
  |                  |                 numberOfTerms    0   
  |                  |                 prefix    Term  (id=138)   
  |                  |                     field    "contents"   
  |                  |                     text    "cat"   
  |                  |                 rewriteMethod    MultiTermQuery$1  (id=119)   
  |                  |                     docCountPercent    0.1   
  |                  |                     termCountCutoff    350   
  |                  |------[1]    BooleanClause  (id=136)   
  |                             |  occur    BooleanClause$Occur$2  (id=129)   
  |                             |      name    "SHOULD"  //OR   
  |                             |      ordinal    1   
  |                             |--query    TermQuery  (id=140)   
  |                                   boost    1.0   
  |                                   term    Term  (id=141)   
 
|                                       field    "contents"   
 
|                                       text    "dog"    
  |                      size    2   
  |                  disableCoord    false   
  |                  minNrShouldMatch    0   
  |------[2]    BooleanClause  (id=105)   
             |   occur    BooleanClause$Occur$3  (id=123)   
             |       name    "MUST_NOT"   //NOT
             |       ordinal    2   
             |---query    BooleanQuery  (id=143)   
                     |   boost    1.0   
                     |   clauses    ArrayList<E>  (id=146)   
                     |     elementData    Object[10]  (id=147)   
                     |------[0]    BooleanClause  (id=148)   
                     |          |    occur    BooleanClause$Occur$2  (id=129)   
                     |          |       name    "SHOULD"   //OR
                     |          |       ordinal    1   
                     |          |--query    FuzzyQuery  (id=150)   
                     |                boost    1.0   
                     |                minimumSimilarity    0.5   
                     |                numberOfTerms    0   
                     |                prefixLength    0   
                     |                rewriteMethod MultiTermQuery$ScoringBooleanQueryRewrite  (id=152)   
                     |                term    Term  (id=153)   
                     |                   field    "contents"   
                     |                   text    "eat"   
                     |                termLongEnough    true   
                     |------[1]    BooleanClause  (id=149)    
                                |    occur    BooleanClause$Occur$2  (id=129)   
                                |       name    "SHOULD"  //OR 
                                |       ordinal    1   
                                |--query    TermQuery  (id=155)   
                                      boost    1.0   
                                      term    Term  (id=156)   
                                          field    "contents"   
                                          text    "foods"
    
                        size    2   
                    disableCoord    false   
                    minNrShouldMatch    0    
        size    3   
    disableCoord    false   
    minNrShouldMatch    0   

 

 

对于Query对象有以下说明:

  • BooleanQuery即所有的子语句按照布尔关系合并
    • +也即MUST表示必须满足的语句
    • SHOULD表示可以满足的,minNrShouldMatch表示在SHOULD中必须满足的最小语句个数,默认是0,也即既然是SHOULD,也即或的关系,可以一个也不满足(当然没有MUST的时候除外)。
    • -也即MUST_NOT表示必须不能满足的语句
  • 树的叶子节点中:
    • 最基本的是TermQuery,也即表示一个词
    • 当然也可以是PrefixQuery和FuzzyQuery,这些查询语句由于特殊的语法,可能对应的不是一个词,而是多个词,因而他们都有rewriteMethod对象指向MultiTermQuery的Inner Class,表示对应多个词,在查询过程中会得到特殊处理。

2.4、搜索查询对象

代码为:

TopDocs docs = searcher.search(query, 50);

其最终调用search(createWeight(query), filter, n);

索引过程包含以下子过程:

  • 创建weight树,计算term weight
  • 创建scorer及SumScorer树,为合并倒排表做准备
  • 用SumScorer进行倒排表合并
  • 收集文档结果集合及计算打分

 

2.4.1、创建Weight对象树,计算Term Weight

IndexSearcher(Searcher).createWeight(Query) 代码如下:

protected Weight createWeight(Query query) throws IOException {

  return query.weight(this);

}

BooleanQuery(Query).weight(Searcher) 代码为:

public Weight weight(Searcher searcher) throws IOException {

  //重写Query对象树

  Query query = searcher.rewrite(this);

  //创建Weight对象树

  Weight weight = query.createWeight(searcher);

  //计算Term Weight分数

  float sum = weight.sumOfSquaredWeights();

  float norm = getSimilarity(searcher).queryNorm(sum);

  weight.normalize(norm);

  return weight;

}

此过程又包含以下过程:

  • 重写Query对象树
  • 创建Weight对象树
  • 计算Term Weight分数
2.4.1.1、重写Query对象树

从BooleanQuery的rewrite函数我们可以看出,重写过程也是一个递归的过程,一直到Query对象树的叶子节点。

BooleanQuery.rewrite(IndexReader) 代码如下:

BooleanQuery clone = null;

for (int i = 0 ; i < clauses.size(); i++) {

  BooleanClause c = clauses.get(i);

  //对每一个子语句的Query对象进行重写

  Query query = c.getQuery().rewrite(reader);

  if (query != c.getQuery()) {

    if (clone == null)

      clone = (BooleanQuery)this.clone();

    //重写后的Query对象加入复制的新Query对象树

    clone.clauses.set(i, new BooleanClause(query, c.getOccur()));

  }

}

if (clone != null) {

  return clone; //如果有子语句被重写,则返回复制的新Query对象树。

} else

  return this; //否则将老的Query对象树返回。

让我们把目光聚集到叶子节点上,叶子节点基本是两种,或是TermQuery,或是MultiTermQuery,从Lucene的源码可以看出TermQuery的rewrite函数就是返回对象本身,也即真正需要重写的是MultiTermQuery,也即一个Query代表多个Term参与查询,如本例子中的PrefixQuery及FuzzyQuery。

对此类的Query,Lucene不能够直接进行查询,必须进行重写处理:

  • 首先,要从索引文件的词典中,把多个Term都找出来,比如"appl*",我们在索引文件的词典中可以找到如下Term:"apple","apples","apply",这些Term都要参与查询过程,而非原来的"appl*"参与查询过程,因为词典中根本就没有"appl*"。
  • 然后,将取出的多个Term重新组织成新的Query对象进行查询,基本有两种方式:
    • 方式一:将多个Term看成一个Term,将包含它们的文档号取出来放在一起(DocId Set),作为一个统一的倒排表来参与倒排表的合并。
    • 方式二:将多个Term组成一个BooleanQuery,它们之间是OR的关系。

从上面的Query对象树中,我们可以看到,MultiTermQuery都有一个RewriteMethod成员变量,就是用来重写Query对象的,有以下几种:

  • ConstantScoreFilterRewrite采取的是方式一,其rewrite函数实现如下:

public Query rewrite(IndexReader reader, MultiTermQuery query) {

  Query result = new ConstantScoreQuery(new MultiTermQueryWrapperFilter<MultiTermQuery>(query));

  result.setBoost(query.getBoost());

  return result;

}

MultiTermQueryWrapperFilter中的getDocIdSet函数实现如下:

 

public DocIdSet getDocIdSet(IndexReader reader) throws IOException {

  //得到MultiTermQuery的Term枚举器

  final TermEnum enumerator = query.getEnum(reader);

  try {

    if (enumerator.term() == null)

      return DocIdSet.EMPTY_DOCIDSET;

    //创建包含多个Term的文档号集合

    final OpenBitSet bitSet = new OpenBitSet(reader.maxDoc());

    final int[] docs = new int[32];

    final int[] freqs = new int[32];

    TermDocs termDocs = reader.termDocs();

    try {

      int termCount = 0;

      //一个循环,取出对应MultiTermQuery的所有的Term,取出他们的文档号,加入集合

      do {

        Term term = enumerator.term();

        if (term == null)

          break;

        termCount++;

        termDocs.seek(term);

        while (true) {

          final int count = termDocs.read(docs, freqs);

          if (count != 0) {

            for(int i=0;i<count;i++) {

              bitSet.set(docs[i]);

            }

          } else {

            break;

          }

        }

      } while (enumerator.next());

      query.incTotalNumberOfTerms(termCount);

    } finally {

      termDocs.close();

    }

    return bitSet;

  } finally {

    enumerator.close();

  }

}

  • ScoringBooleanQueryRewrite及其子类ConstantScoreBooleanQueryRewrite采取方式二,其rewrite函数代码如下:

 

public Query rewrite(IndexReader reader, MultiTermQuery query) throws IOException {

  //得到MultiTermQuery的Term枚举器

  FilteredTermEnum enumerator = query.getEnum(reader);

  BooleanQuery result = new BooleanQuery(true);

  int count = 0;

  try {

      //一个循环,取出对应MultiTermQuery的所有的Term,加入BooleanQuery

    do {

      Term t = enumerator.term();

      if (t != null) {

        TermQuery tq = new TermQuery(t);

        tq.setBoost(query.getBoost() * enumerator.difference());

        result.add(tq, BooleanClause.Occur.SHOULD);

        count++;

      }

    } while (enumerator.next());   

  } finally {

    enumerator.close();

  }

  query.incTotalNumberOfTerms(count);

  return result;

}

  • 以上两种方式各有优劣:
    • 方式一使得MultiTermQuery对应的所有的Term看成一个Term,组成一个docid set,作为统一的倒排表参与倒排表的合并,这样无论这样的Term在索引中有多少,都只会有一个倒排表参与合并,不会产生TooManyClauses异常,也使得性能得到提高。但是多个Term之间的tf, idf等差别将被忽略,所以采用方式二的RewriteMethod为ConstantScoreXXX,也即除了用户指定的Query boost,其他的打分计算全部忽略。
    • 方式二使得整个Query对象树被展开,叶子节点都为TermQuery,MultiTermQuery中的多个Term可根据在索引中的tf, idf等参与打分计算,然而我们事先并不知道索引中和MultiTermQuery相对应的Term到底有多少个,因而会出现TooManyClauses异常,也即一个BooleanQuery中的子查询太多。这样会造成要合并的倒排表非常多,从而影响性能。
    • Lucene认为对于MultiTermQuery这种查询,打分计算忽略是很合理的,因为当用户输入"appl*"的时候,他并不知道索引中有什么与此相关,也并不偏爱其中之一,因而计算这些词之间的差别对用户来讲是没有意义的。从而Lucene对方式二也提供了ConstantScoreXXX,来提高搜索过程的性能,从后面的例子来看,会影响文档打分,在实际的系统应用中,还是存在问题的。
    • 为了兼顾上述两种方式,Lucene提供了ConstantScoreAutoRewrite,来根据不同的情况,选择不同的方式。

ConstantScoreAutoRewrite.rewrite代码如下:

public Query rewrite(IndexReader reader, MultiTermQuery query) throws IOException {

  final Collection<Term> pendingTerms = new ArrayList<Term>();

  //计算文档数目限制,docCountPercent默认为0.1,也即索引文档总数的0.1%

  final int docCountCutoff = (int) ((docCountPercent / 100.) * reader.maxDoc());

  //计算Term数目限制,默认为350

  final int termCountLimit = Math.min(BooleanQuery.getMaxClauseCount(), termCountCutoff);

  int docVisitCount = 0;

  FilteredTermEnum enumerator = query.getEnum(reader);

  try {

    //一个循环,取出与MultiTermQuery相关的所有的Term。

    while(true) {

      Term t = enumerator.term();

      if (t != null) {

        pendingTerms.add(t);

        docVisitCount += reader.docFreq(t);

      }

      //如果Term数目超限,或者文档数目超限,则可能非常影响倒排表合并的性能,因而选用方式一,也即ConstantScoreFilterRewrite的方式

      if (pendingTerms.size() >= termCountLimit || docVisitCount >= docCountCutoff) {

        Query result = new ConstantScoreQuery(new MultiTermQueryWrapperFilter<MultiTermQuery>(query));

        result.setBoost(query.getBoost());

        return result;

      } else  if (!enumerator.next()) {

        //如果Term数目不太多,而且文档数目也不太多,不会影响倒排表合并的性能,因而选用方式二,也即ConstantScoreBooleanQueryRewrite的方式。

        BooleanQuery bq = new BooleanQuery(true);

        for (final Term term: pendingTerms) {

          TermQuery tq = new TermQuery(term);

          bq.add(tq, BooleanClause.Occur.SHOULD);

        }

        Query result = new ConstantScoreQuery(new QueryWrapperFilter(bq));

        result.setBoost(query.getBoost());

        query.incTotalNumberOfTerms(pendingTerms.size());

        return result;

      }

    }

  } finally {

    enumerator.close();

  }

}

从上面的叙述中,我们知道,在重写Query对象树的时候,从MultiTermQuery得到的TermEnum很重要,能够得到对应MultiTermQuery的所有的Term,这是怎么做的的呢?

MultiTermQuery的getEnum返回的是FilteredTermEnum,它有两个成员变量,其中TermEnum actualEnum是用来枚举索引中所有的Term的,而Term currentTerm指向的是当前满足条件的Term,FilteredTermEnum的next()函数如下:

public boolean next() throws IOException {

    if (actualEnum == null) return false;

    currentTerm = null;

    //不断得到下一个索引中的Term

    while (currentTerm == null) {

        if (endEnum()) return false;

        if (actualEnum.next()) {

            Term term = actualEnum.term();

             //如果当前索引中的Term满足条件,则赋值为当前的Term

            if (termCompare(term)) {

                currentTerm = term;

                return true;

            }

        }

        else return false;

    }

    currentTerm = null;

    return false;

}

不同的MultiTermQuery的termCompare不同:

  • 对于PrefixQuery的getEnum(IndexReader reader)得到的是PrefixTermEnum,其termCompare实现如下:

protected boolean termCompare(Term term) {

  //只要前缀相同,就满足条件

  if (term.field() == prefix.field() && term.text().startsWith(prefix.text())){                                                                             

    return true;

  }

  endEnum = true;

  return false;

}

  • 对于FuzzyQuery的getEnum得到的是FuzzyTermEnum,其termCompare实现如下:

protected final boolean termCompare(Term term) {

  //对于FuzzyQuery,其prefix设为空"",也即这一条件一定满足,只要计算的是similarity

  if (field == term.field() && term.text().startsWith(prefix)) {

      final String target = term.text().substring(prefix.length());

      this.similarity = similarity(target);

      return (similarity > minimumSimilarity);

  }

  endEnum = true;

  return false;

}

//计算Levenshtein distance 也即 edit distance,对于两个字符串,从一个转换成为另一个所需要的最少基本操作(添加,删除,替换)数。

 

private synchronized final float similarity(final String target) {

    final int m = target.length();

    final int n = text.length();

    // init matrix d

    for (int i = 0; i<=n; ++i) {

      p[i] = i;

    }

    // start computing edit distance

    for (int j = 1; j<=m; ++j) { // iterates through target

      int bestPossibleEditDistance = m;

      final char t_j = target.charAt(j-1); // jth character of t

      d[0] = j;

      for (int i=1; i<=n; ++i) { // iterates through text

        // minimum of cell to the left+1, to the top+1, diagonally left and up +(0|1)

        if (t_j != text.charAt(i-1)) {

          d[i] = Math.min(Math.min(d[i-1], p[i]),  p[i-1]) + 1;

        } else {

          d[i] = Math.min(Math.min(d[i-1]+1, p[i]+1),  p[i-1]);

        }

        bestPossibleEditDistance = Math.min(bestPossibleEditDistance, d[i]);

      }

      // copy current distance counts to 'previous row' distance counts: swap p and d

      int _d[] = p;

      p = d;

      d = _d;

    }

    return 1.0f - ((float)p[n] / (float) (Math.min(n, m)));

  }

有关edit distance的算法详见http://www.merriampark.com/ld.htm

计算两个字符串s和t的edit distance算法如下:

Step 1:
Set n to be the length of s.
Set m to be the length of t.
If n = 0, return m and exit.
If m = 0, return n and exit.
Construct a matrix containing 0..m rows and 0..n columns.

Step 2:
Initialize the first row to 0..n.
Initialize the first column to 0..m.

Step 3:
Examine each character of s (i from 1 to n).

Step 4:
Examine each character of t (j from 1 to m).

Step 5:
If s[i] equals t[j], the cost is 0.
If s[i] doesn't equal t[j], the cost is 1.

Step 6:
Set cell d[i,j] of the matrix equal to the minimum of:
a. The cell immediately above plus 1: d[i-1,j] + 1.
b. The cell immediately to the left plus 1: d[i,j-1] + 1.
c. The cell diagonally above and to the left plus the cost: d[i-1,j-1] + cost.

Step 7:
After the iteration steps (3, 4, 5, 6) are complete, the distance is found in cell d[n,m].

举例说明其过程如下:

比较的两个字符串为:“GUMBO” 和 "GAMBOL".

 

 

下面做一个试验,来说明ConstantScoreXXX对评分的影响:

在索引中,添加了以下四篇文档:

file01.txt : apple other other other other

file02.txt : apple apple other other other

file03.txt : apple apple apple other other

file04.txt : apple apple apple other other

搜索"apple"结果如下:

docid : 3 score : 0.67974937
docid : 2 score : 0.58868027
docid : 1 score : 0.4806554
docid : 0 score : 0.33987468

文档按照包含"apple"的多少排序。

而搜索"apple*"结果如下:

docid : 0 score : 1.0
docid : 1 score : 1.0
docid : 2 score : 1.0
docid : 3 score : 1.0

也即Lucene放弃了对score的计算。

经过rewrite,得到的新Query对象树如下:

query    BooleanQuery  (id=89)   
   |  boost    1.0   
   |  clauses    ArrayList<E>  (id=90)   
   |     elementData    Object[3]  (id=97)   
   |------[0]    BooleanClause  (id=99)   
   |          |   occur    BooleanClause$Occur$1  (id=103)   
   |          |       name    "MUST"   
   |          |       ordinal    0   
   |          |---query    BooleanQuery  (id=105)   
   |                  |  boost    1.0   
   |                  |  clauses    ArrayList<E>  (id=115)   
   |                  |    elementData    Object[2]  (id=120)   

   |                  |       //"apple*"被用方式一重写为ConstantScoreQuery
   |                  |---[0]    BooleanClause  (id=121)   
   |                  |      |     occur    BooleanClause$Occur$1  (id=103)   
   |                  |      |         name    "MUST"   
   |                  |      |         ordinal    0   
   |                  |      |---query    ConstantScoreQuery  (id=123)   
   |                  |               boost    1.0   
   |                  |               filter    MultiTermQueryWrapperFilter<Q>  (id=125)   
   |                  |                   query    PrefixQuery  (id=48)   
   |                  |                       boost    1.0   
   |                  |                       numberOfTerms    0   
   |                  |                       prefix    Term  (id=127)   
   |                  |                           field    "contents"   
   |                  |                           text    "apple"   
   |                  |                       rewriteMethod    MultiTermQuery$1  (id=50)    
   |                  |---[1]    BooleanClause  (id=122)   
   |                         |    occur    BooleanClause$Occur$3  (id=111)   
   |                         |        name    "MUST_NOT"   
   |                         |        ordinal    2   
   |                         |---query    TermQuery  (id=124)   
   |                                  boost    1.0   
   |                                  term    Term  (id=130)   
   |                                      field    "contents"   
   |                                      text    "boy"   
   |                     modCount    0   
   |                     size    2   
   |                 disableCoord    false   
   |                 minNrShouldMatch    0   
   |------[1]    BooleanClause  (id=101)   
   |          |   occur    BooleanClause$Occur$2  (id=108)   
   |          |       name    "SHOULD"   
   |          |       ordinal    1   
   |          |---query    BooleanQuery  (id=110)   
   |                  |  boost    1.0   
   |                  |  clauses    ArrayList<E>  (id=117)   
   |                  |    elementData    Object[2]  (id=132)   

   |                  |       //"cat*"被用方式一重写为ConstantScoreQuery
   |                  |------[0]    BooleanClause  (id=133)   
   |                  |          |   occur    BooleanClause$Occur$2  (id=108)   
   |                  |          |       name    "SHOULD"   
   |                  |          |       ordinal    1   
   |                  |          |---query    ConstantScoreQuery  (id=135)   
   |                  |                   boost    1.0   
   |                  |                   filter    MultiTermQueryWrapperFilter<Q>  (id=137)   
   |                  |                     query    PrefixQuery  (id=63)   
   |                  |                        boost    1.0   
   |                  |                        numberOfTerms    0   
   |                  |                        prefix    Term  (id=138)   
   |                  |                            field    "contents"   
   |                  |                            text    "cat"   
   |                  |                       rewriteMethod    MultiTermQuery$1  (id=50)   
   |                  |------[1]    BooleanClause  (id=134)   
   |                             |   occur    BooleanClause$Occur$2  (id=108)   
   |                             |        name    "SHOULD"   
   |                             |        ordinal    1   
   |                             |---query    TermQuery  (id=136)   
   |                                      boost    1.0   
   |                                      term    Term  (id=140)   
  
|                                          field    "contents"   
  
|                                          text    "dog"   
   |                     modCount    0   
   |                     size    2   
   |                 disableCoord    false   
   |                 minNrShouldMatch    0   
   |------[2]    BooleanClause  (id=102)   
              |    occur    BooleanClause$Occur$3  (id=111)   
              |        name    "MUST_NOT"   
              |        ordinal    2   
              |---query    BooleanQuery  (id=113)   
                      |  boost    1.0   
                      |  clauses    ArrayList<E>  (id=119)   
                      |     elementData    Object[2]  (id=142)   
                      |------[0]    BooleanClause  (id=143)   
                      |          |   occur    BooleanClause$Occur$2  (id=108)   
                      |          |       name    "SHOULD"   
                      |          |       ordinal    1   

                      |          |    //"eat~"作为FuzzyQuery,被重写成BooleanQuery,
                      |          |     索引中满足 条件的Term有"eat"和"cat"。FuzzyQuery
                      |          |     不用上述的任何一种RewriteMethod,而是用方式二自己
                      |          |     实现了rewrite函数,是将同"eat"的edit distance最近的
                      |          |     最多maxClauseCount(默认1024)个Term组成BooleanQuery。
                      |          |---query    BooleanQuery  (id=145)   
                      |                   |  boost    1.0   
                      |                   |  clauses    ArrayList<E>  (id=146)   
                      |                   |     elementData    Object[10]  (id=147)   
                      |                   |------[0]    BooleanClause  (id=148)   
                      |                   |          |    occur    BooleanClause$Occur$2  (id=108)   
                      |                   |          |       name    "SHOULD"   
                      |                   |          |       ordinal    1   
                      |                   |          |---query    TermQuery  (id=150)   
                      |                   |                  boost    1.0   
                      |                   |                  term    Term  (id=152)   
                      |                   |                      field    "contents"   
                      |                   |                      text    "eat"   
                      |                   |------[1]    BooleanClause  (id=149)   
                      |                              |    occur    BooleanClause$Occur$2  (id=108)   
                      |                              |       name    "SHOULD"   
                      |                              |       ordinal    1   
                      |                              |---query    TermQuery  (id=151)   
                      |                                       boost    0.33333325   
                      |                                       term    Term  (id=153)   
                      |                                           field    "contents"   
                      |                                           text    "cat"       
                      |                  modCount    2   
                      |                  size    2   
                      |              disableCoord    true   
                      |              minNrShouldMatch    0   
                      |------[1]    BooleanClause  (id=144)   
                                  |   occur    BooleanClause$Occur$2  (id=108)   
                                  |       name    "SHOULD"   
                                  |       ordinal    1   
                                  |---query    TermQuery  (id=154)   
                                          boost    1.0   
                                          term    Term  (id=155)   
                                             field    "contents"   
                                             text    "foods"
  
                        modCount    0   
                        size    2   
                    disableCoord    false   
                    minNrShouldMatch    0   
        modCount    0   
        size    3   
    disableCoord    false   
    minNrShouldMatch    0   

 

  • 大小: 102.1 KB
  • 大小: 20 KB
  • 大小: 25.2 KB
分享到:
评论
3 楼 wushexin 2011-01-21  
xiaohui6636 写道
楼主,您好!
请问您是怎么打印出 Query查询树 的?

eclipse中 调试时,在 (x)=Variables 窗口中,选择query变量,右键  选择 Inspect 即可。
2 楼 xiaohui6636 2010-10-14  
楼主,您好!
请问您是怎么打印出 Query查询树 的?
1 楼 yangfuchao418 2010-04-07  
不错,希望博主能一口气写完。

相关推荐

    IKAnalyzer中文分词支持lucene6.5.0版本

    由于林良益先生在2012之后未对IKAnalyzer进行更新,后续lucene分词接口发生变化,导致不可使用,所以此jar包支持lucene6.0以上版本

    Lucene学习源码.rar

    通过学习Lucene源码,我们可以定制自己的分词器、查询解析器,甚至优化搜索算法,以满足特定的搜索需求。例如,在中文环境下,可以使用IK Analyzer或者jieba分词库来增强对中文的支持。 总结,Lucene作为Java平台上...

    lucene学习资料收集

    【标题】:“Lucene学习资料收集” 【描述】:Lucene是一个开源的全文搜索引擎库,由Apache软件基金会开发。这个资料集可能包含了关于如何理解和使用Lucene的各种资源,特别是通过博主huanglz19871030在iteye上的...

    lucene学习总结

    **Lucene学习总结** 在深入理解Lucene之前,我们首先需要了解什么是全文检索。全文检索是一种从大量文本数据中快速查找所需信息的技术。它通过建立索引来实现高效的搜索,而Lucene正是Java环境下最著名的全文搜索...

    Lucene的的学习资料及案例

    **Lucene学习指南** Lucene是一个高性能、全文检索库,由Apache软件基金会开发并维护,是Java编程语言中广泛使用的搜索引擎库。它提供了一个简单的API,使得开发者能够方便地在应用中实现全文检索功能。本篇文章将...

    lucene学习pdf2

    3. **查询解析**:Lucene支持复杂的查询语法,包括布尔运算、短语匹配、通配符和模糊搜索等。 4. **评分机制**:基于TF-IDF、BM25等算法,Lucene可以对匹配的文档进行评分,用于决定搜索结果的排序。 5. **过滤器...

    lucene3源码分析

    ### Lucene3源码分析知识点概述 #### 一、全文检索的基本原理 ##### 1....以上是对Lucene3源码分析的一些关键知识点总结,通过对这些概念和技术的理解,可以更好地掌握Lucene的工作原理及其应用。

    Lucene 7.2.1 官方jar包

    总结来说,Lucene 7.2.1 是一个强大的全文检索工具,通过其丰富的功能和高效性能,为开发者提供了构建强大搜索引擎的可能。对于需要处理大量文本数据的应用,使用Lucene进行索引和查询无疑是一个明智的选择。

    Lucene搜索技术

    【Lucene搜索技术】是一种基于Java的全文索引引擎工具包,它并非一个完整的全文搜索引擎,而是提供了一套用于构建全文检索应用的API。Lucene的主要目标是方便开发者将其嵌入到各种应用程序中,实现对特定数据源的...

    lucene 最新版本所有jar包

    同时,它还包含分词器(Analyzer)用于将文本分割成可搜索的词元,以及查询解析器(QueryParser)将用户输入转化为搜索查询。 `lucene-analyzers-common-4.10.2.jar`是Lucene的通用分析器包。分析器是处理文本的...

    Lucene3.3.0学习Demo

    **Lucene 3.3.0 学习Demo** ...总之,"Lucene3.3.0学习Demo"是一个宝贵的资源,对于想要掌握全文搜索技术的开发者来说,它提供了丰富的实践案例和学习材料,可以帮助你快速上手并深入理解Lucene的核心机制。

    lucene学习lucene学习

    Lucene 是一个强大的全文搜索引擎库,它以 Java 语言实现,并作为 Apache 软件基金会的 Apache Jakarta 项目的一部分开放源代码。Lucene 提供了高效、可扩展的索引和搜索功能,允许开发者轻松地在应用程序中集成高级...

    lucene3.6 搜索例子

    《Lucene 3.6 搜索实例解析》 Apache Lucene 是一个开源全文搜索引擎库,为开发者提供了在Java应用程序中实现高效、可扩展的搜索功能的工具。在本篇文章中,我们将深入探讨Lucene 3.6版本中的搜索功能,通过实例...

    lucene学习总结_博客记录1

    本篇文章将深入探讨 Lucene 的核心原理,从全文检索的基础概念出发,逐步解析索引创建过程以及搜索机制。 一、全文检索的基本原理 1. 总论 全文检索是通过索引机制,快速找到文档中包含特定关键词的过程。Lucene ...

    经典的lucene实例代码及详细解析以及lucene结构流程介绍

    Lucene应用是指使用Lucene搜索引擎库构建搜索应用程序的过程。Lucene应用程序可以用于各种领域,包括文本搜索、图片搜索和视频搜索等。 在上面的代码中,我们使用了Lucene搜索引擎库构建了一个文本搜索应用程序。该...

    lucene学习资料

    《Lucene学习资料》 Lucene是一个开源的全文搜索引擎库,由Apache软件基金会维护。它提供了高级的文本分析和索引功能,使得开发者能够轻松地在应用程序中集成强大的搜索功能。这个资料包中的《Lucene in Action_2nd...

    Lucene原理及使用总结

    总的来说,Lucene提供了一套完整的框架,涵盖了从文本处理到搜索结果返回的全过程,使开发者能够专注于构建具有高级搜索功能的应用,而无需关心底层实现细节。通过理解Lucene的基本原理和使用方法,我们可以构建出...

    官方最新完整版lucene-6.6.0.zip

    3. **查询解析**:将用户输入的查询语句转化为适合索引搜索的形式。 4. **搜索执行**:高效执行查询,返回匹配文档的ID及得分。 5. **结果集操作**:对搜索结果进行过滤、排序、分页等操作。 三、API使用 1. **创建...

    lucene个人总结

    根据提供的文件信息,以下是对Lucene 3.5版本的核心知识点进行的详细解析与总结: ### Lucene 3.5 概述 Lucene 3.5 是一款高性能的全文检索引擎工具包,广泛应用于搜索引擎、文档管理和内容管理等领域。Lucene 的...

Global site tag (gtag.js) - Google Analytics