Lucene学习总结之八:Lucene的查询语法,JavaCC及QueryParser(2)

三、解析QueryParser.jj

 

3.1、声明QueryParser类

在QueryParser.jj文件中,PARSER_BEGIN(QueryParser)和PARSER_END(QueryParser)之间,定义了QueryParser类。

其中最重要的一个函数是public Query parse(String query)函数,也即我们解析Lucene查询语法的时候调用的函数。

这是一个纯Java代码定义的函数,会直接拷贝到QueryParser.java文件中。

parse函数中,最重要的一行代码是调用Query res = TopLevelQuery(field),而TopLevelQuery函数是QueryParser.jj中定义的语法分析器被JavaCC编译后会生成的函数。

3.2、声明词法分析器

在解析词法分析器之前,首先介绍一下JavaCC的词法状态的概念(lexical state)。

有可能存在如下的情况,在不同的情况下,要求的词法词法规则不同,比如我们要解析一个java文件(即满足java语法的表达式),在默认的状态DEFAULT下,是要求解析的对象(即表达式)满足java语言的词法规则,然而当出现"/**"的时候,其后面的表达式则不需要满足java语言的语法规则,而是应该满足java注释的语法规则(要识别@param变量等),于是我们做如下定义:

//默认处于DEFAULT状态,当遇到/**的时候,转换为IN_JAVADOC_COMMENT状态

<DEFAULT> TOKEN : {<STARTDOC : “/**” > : IN_JAVADOC_COMMENT }

//在IN_JAVADOC_COMMENT状态下,需要识别@param变量

<IN_JAVADOC_COMMENT> TOKEN : {<PARAM : "@param" >}

//在IN_JAVADOC_COMMENT状态下,遇到*/的时候,装换为DEFAULT状态

<IN_JAVADOC_COMMENT> TOKEN : {<ENDDOC: "*/">: DEFAULT }

<*> 表示应用于任何状态。

(1) 应用于所有状态的变量

<*> TOKEN : {

  <#_NUM_CHAR:   ["0"-"9"] > //数字

| <#_ESCAPED_CHAR: "\\" ~[] > //"\"后的任何一个字符都是被转义的

| <#_TERM_START_CHAR: ( ~[ " ", "\t", "\n", "\r", "\u3000", "+", "-", "!", "(", ")", ":", "^", "[", "]", "\"", "{", "}", "~", "*", "?", "\\" ] | <_ESCAPED_CHAR> ) > //表达式中任何一个term,都不能以[]括起来的列表中的lucene查询语法关键字开头,当然被转义的除外。

| <#_TERM_CHAR: ( <_TERM_START_CHAR> | <_ESCAPED_CHAR> | "-" | "+" ) > //表达式中的term非起始字符,可以包含任何非语法关键字字符,转义过的字符,也可以包含+, -(但包含+,-的符合词法,不合语法)。

| <#_WHITESPACE: ( " " | "\t" | "\n" | "\r" | "\u3000") > //被认为是空格的字符

| <#_QUOTED_CHAR: ( ~[ "\"", "\\" ] | <_ESCAPED_CHAR> ) > //被引号括起来的字符不应再包括"和\,当然转义过的除外。

}

 

(2) 默认状态的Token

<DEFAULT> TOKEN : {

  <AND:       ("AND" | "&&") >

| <OR:        ("OR" | "||") >

| <NOT:       ("NOT" | "!") >

| <PLUS:      "+" >

| <MINUS:     "-" >

| <LPAREN:    "(" >

| <RPAREN:    ")" >

| <COLON:     ":" >

| <STAR:      "*" >

| <CARAT:     "^" > : Boost //当遇到^的时候,后面跟随的是boost表达式,进入Boost状态

| <QUOTED:     "\"" (<_QUOTED_CHAR>)* "\"">

| <TERM:      <_TERM_START_CHAR> (<_TERM_CHAR>)*  >

| <FUZZY_SLOP:     "~" ( (<_NUM_CHAR>)+ ( "." (<_NUM_CHAR>)+ )? )? > //Fuzzy查询,~后面跟小数。

| <PREFIXTERM:  ("*") | ( <_TERM_START_CHAR> (<_TERM_CHAR>)* "*" ) > //使用*进行Prefix查询,可以尽包含*,或者末尾包含*,然而只包含*符合词法,不合语法。

| <WILDTERM:  (<_TERM_START_CHAR> | [ "*", "?" ]) (<_TERM_CHAR> | ( [ "*", "?" ] ))* > //使用*和?进行wildcard查询

| <RANGEIN_START: "[" > : RangeIn //遇到[]的时候,是包含边界的Range查询

| <RANGEEX_START: "{" > : RangeEx //遇到{}的时候,是不包含边界的Range查询

}

<Boost> TOKEN : {

<NUMBER:    (<_NUM_CHAR>)+ ( "." (<_NUM_CHAR>)+ )? > : DEFAULT //boost是一个小数

}

//包含边界的Range查询是[A TO B]的形式。

<RangeIn> TOKEN : {

<RANGEIN_TO: "TO">

| <RANGEIN_END: "]"> : DEFAULT

| <RANGEIN_QUOTED: "\"" (~["\""] | "\\\"")+ "\"">

| <RANGEIN_GOOP: (~[ " ", "]" ])+ >

}

//不包含边界的Range查询是{A TO B}的形式

<RangeEx> TOKEN : {

<RANGEEX_TO: "TO">

| <RANGEEX_END: "}"> : DEFAULT

| <RANGEEX_QUOTED: "\"" (~["\""] | "\\\"")+ "\"">

| <RANGEEX_GOOP: (~[ " ", "}" ])+ >

}

 

3.3、声明语法分析器

Lucene的语法规则如下:

Query  ::= ( Clause )*

Clause ::= ["+", "-"] [<TERM> ":"] ( <TERM> | "(" Query ")" )

(1) 从Query到Clause

一个Query查询语句,是由多个clause组成的,每个clause有修饰符Modifier,或为+, 或为-,clause之间的有连接符,或为AND,或为OR,或为NOT。

在Lucene的语法解析中NOT被算作Modifier,和-起相同作用。

此过程表达式如下:

Query TopLevelQuery(String field) :

{

    Query q;

}

{

    q=Query(field) <EOF>

    {

        return q;

    }

}

Query Query(String field) :

{

  List<BooleanClause> clauses = new ArrayList<BooleanClause>();

  Query q, firstQuery=null;

  int conj, mods;

}

{

  //查询语句开头是一个Modifier,可以为空

  //Modifier后面便是子语句clause,可以生成子查询语句q

  mods=Modifiers() q=Clause(field)

  {

    //如果第一个语句的Modifier是空,则将子查询q付给firstQuery,从后面我们可以看到,当只有一个查询语句的时候,如果其Modifier为空,则不返回BooleanQuery,而是返回子查询对象firstQuery。从这里我们可以看出,如果查询语句为"A",则生成TermQuery,其term为"A",如果查询语句为"+A",则生成BooleanQuery,其子查询只有一个,就是TermQuery,其term为"A"。

    addClause(clauses, CONJ_NONE, mods, q);

    if (mods == MOD_NONE)

        firstQuery=q;

  }

  (

    //除了第一个语句外,其他的前面可以有连接符,或为AND,或为OR。

    //如果在第一个语句之前出现连接符,则报错,如"OR a",会报Encountered " <OR> "OR "" at line 1, column 0.

    //除了连接符,也会有Modifier,后面是子语句clause,生成子查询q,并加入BooleanQuery中。

    conj=Conjunction() mods=Modifiers() q=Clause(field)

    { addClause(clauses, conj, mods, q); }

  )*

  {

    //如果只有一个查询语句,且其modifier为空,则返回firstQuery,否则由所有的子语句clause,生成BooleanQuery。

    if (clauses.size() == 1 && firstQuery != null)

      return firstQuery;

    else {

      return getBooleanQuery(clauses);

    }

  }

}

int Modifiers() : {

  //默认modifier为空,如果遇到+,就是required,如果遇到-或者NOT,就是prohibited。

  int ret = MOD_NONE;

}

{

  [

     <PLUS> { ret = MOD_REQ; }

     | <MINUS> { ret = MOD_NOT; }

     | <NOT> { ret = MOD_NOT; }

  ]

  { return ret; }

}

//连接符

int Conjunction() : {

  int ret = CONJ_NONE;

}

{

  [

    <AND> { ret = CONJ_AND; }

    | <OR>  { ret = CONJ_OR; }

  ]

  { return ret; }

}

 

(2) 一个子语句clause

由上面的分析我们可以知道,JavaCC使用的是编译原理里面的自上而下分析法,基本采用的是LL(1)的方法:

  • 第一个L :从左到右扫描输入串
  • 第二个L :生成的是最左推导
  • (1):向前看一个输入符号(lookahead)

JavaCC还提供LOOKAHEAD(n),也即当仅读入下一个符号时,不足以判断接下来的如何解析,会出现Choice Conflict,则需要多读入几个符号,来进一步判断。

 

Query Clause(String field) : {

  Query q;

  Token fieldToken=null, boost=null;

}

{

  //此处之所以向前看两个符号,就是当看到<TERM>的时候,不知道它是一个field,还是一个term,当<TERM><COLON>在一起的时候,说明<TERM>代表一个field, 否则代表一个term

  [

    LOOKAHEAD(2)

    (

    fieldToken=<TERM> <COLON> {field=discardEscapeChar(fieldToken.image);}

    | <STAR> <COLON> {field="*";}

    )

  ]

  (

  //或者是一个term,则由此term生成一个查询对象

   //或者是一个由括号括起来的子查询

   //()?表示可能存在一个boost,格式为^加一个数字

   q=Term(field)

   | <LPAREN> q=Query(field) <RPAREN> (<CARAT> boost=<NUMBER>)?

  )

  {

    //如果存在boost,则设定查询对象的boost

    if (boost != null) {

      float f = (float)1.0;

      try {

        f = Float.valueOf(boost.image).floatValue();

        q.setBoost(f);

      } catch (Exception ignored) { }

    }

    return q;

  }

}

 

Query Term(String field) : {

  Token term, boost=null, fuzzySlop=null, goop1, goop2;

  boolean prefix = false;

  boolean wildcard = false;

  boolean fuzzy = false;

  Query q;

}

{

  (

     (

      //如果term仅结尾包含*则是prefix查询。

       //如果以*开头,或者中间包含*,或者结尾包含*(如果仅结尾包含,则prefix优先)则为wildcard查询。

       term=<TERM>

       | term=<STAR> { wildcard=true; }

       | term=<PREFIXTERM> { prefix=true; }

       | term=<WILDTERM> { wildcard=true; }

       | term=<NUMBER>

     )

     //如果term后面是~,则是fuzzy查询

     [ fuzzySlop=<FUZZY_SLOP> { fuzzy=true; } ]

     [ <CARAT> boost=<NUMBER> [ fuzzySlop=<FUZZY_SLOP> { fuzzy=true; } ] ]

     {

        //如果是wildcard查询,则调用getWildcardQuery,

        //    *:*得到MatchAllDocsQuery,将返回所有的文档

        //    目前不支持最前面带通配符的查询(虽然词法分析和语法分析都能通过),否则报ParseException

        //    最后生成WildcardQuery

        //如果是prefix查询,则调用getPrefixQuery,生成PrefixQuery

        //如果是fuzzy查询,则调用getFuzzyQuery,生成FuzzyQuery

        //如果是普通查询,则调用getFieldQuery

       String termImage=discardEscapeChar(term.image);

       if (wildcard) {

         q = getWildcardQuery(field, termImage);

       } else if (prefix) {

         q = getPrefixQuery(field, discardEscapeChar(term.image.substring(0, term.image.length()-1)));

       } else if (fuzzy) {

         float fms = fuzzyMinSim;

         try {

           fms = Float.valueOf(fuzzySlop.image.substring(1)).floatValue();

         } catch (Exception ignored) { }

         if(fms < 0.0f || fms > 1.0f){

           throw new ParseException("Minimum similarity for a FuzzyQuery has to be between 0.0f and 1.0f !");

         }

         q = getFuzzyQuery(field, termImage,fms);

       } else {

         q = getFieldQuery(field, termImage);

       }

     }

     //包含边界的range查询,取得[goop1 TO goop2],调用getRangeQuery,生成TermRangeQuery

     | ( <RANGEIN_START> ( goop1=<RANGEIN_GOOP>|goop1=<RANGEIN_QUOTED> )

         [ <RANGEIN_TO> ] ( goop2=<RANGEIN_GOOP>|goop2=<RANGEIN_QUOTED> )

         <RANGEIN_END> )

       [ <CARAT> boost=<NUMBER> ]

        {

          if (goop1.kind == RANGEIN_QUOTED) {

            goop1.image = goop1.image.substring(1, goop1.image.length()-1);

          }

          if (goop2.kind == RANGEIN_QUOTED) {

            goop2.image = goop2.image.substring(1, goop2.image.length()-1);

          }

          q = getRangeQuery(field, discardEscapeChar(goop1.image), discardEscapeChar(goop2.image), true);

        }

     //不包含边界的range查询,取得{goop1 TO goop2},调用getRangeQuery,生成TermRangeQuery

     | ( <RANGEEX_START> ( goop1=<RANGEEX_GOOP>|goop1=<RANGEEX_QUOTED> )

         [ <RANGEEX_TO> ] ( goop2=<RANGEEX_GOOP>|goop2=<RANGEEX_QUOTED> )

         <RANGEEX_END> )

       [ <CARAT> boost=<NUMBER> ]

        {

          if (goop1.kind == RANGEEX_QUOTED) {

            goop1.image = goop1.image.substring(1, goop1.image.length()-1);

          }

          if (goop2.kind == RANGEEX_QUOTED) {

            goop2.image = goop2.image.substring(1, goop2.image.length()-1);

          }

          q = getRangeQuery(field, discardEscapeChar(goop1.image), discardEscapeChar(goop2.image), false);

        }

     //被""括起来的term,得到phrase查询,调用getFieldQuery

     | term=<QUOTED>

       [ fuzzySlop=<FUZZY_SLOP> ]

       [ <CARAT> boost=<NUMBER> ]

       {

         int s = phraseSlop;

         if (fuzzySlop != null) {

           try {

             s = Float.valueOf(fuzzySlop.image.substring(1)).intValue();

           }

           catch (Exception ignored) { }

         }

         q = getFieldQuery(field, discardEscapeChar(term.image.substring(1, term.image.length()-1)), s);

       }

  )

  {

    if (boost != null) {

      float f = (float) 1.0;

      try {

        f = Float.valueOf(boost.image).floatValue();

      }

      catch (Exception ignored) {

      }

      // avoid boosting null queries, such as those caused by stop words

      if (q != null) {

        q.setBoost(f);

      }

    }

    return q;

  }

}

 

此处需要详细解析的是getFieldQuery:

protected Query getFieldQuery(String field, String queryText)  throws ParseException {

  //需要用analyzer对文本进行分词

  TokenStream source;

  try {

    source = analyzer.reusableTokenStream(field, new StringReader(queryText));

    source.reset();

  } catch (IOException e) {

    source = analyzer.tokenStream(field, new StringReader(queryText));

  }

  CachingTokenFilter buffer = new CachingTokenFilter(source);

  TermAttribute termAtt = null;

  PositionIncrementAttribute posIncrAtt = null;

  int numTokens = 0;

  boolean success = false;

  try {

    buffer.reset();

    success = true;

  } catch (IOException e) {

  }

  //得到TermAttribute和PositionIncrementAttribute,此两项将决定到底产生什么样的Query对象

  if (success) {

    if (buffer.hasAttribute(TermAttribute.class)) {

      termAtt = buffer.getAttribute(TermAttribute.class);

    }

    if (buffer.hasAttribute(PositionIncrementAttribute.class)) {

      posIncrAtt = buffer.getAttribute(PositionIncrementAttribute.class);

    }

  }

  int positionCount = 0;

  boolean severalTokensAtSamePosition = false;

  boolean hasMoreTokens = false;

  if (termAtt != null) {

    try {

      //遍历分词后的所有Token,统计Tokens的个数numTokens,以及positionIncrement的总数,即positionCount。

      //当有一次positionIncrement为0的时候,severalTokensAtSamePosition设为true,表示有多个Token处在同一个位置。

      hasMoreTokens = buffer.incrementToken();

      while (hasMoreTokens) {

        numTokens++;

        int positionIncrement = (posIncrAtt != null) ? posIncrAtt.getPositionIncrement() : 1;

        if (positionIncrement != 0) {

          positionCount += positionIncrement;

        } else {

          severalTokensAtSamePosition = true;

        }

        hasMoreTokens = buffer.incrementToken();

      }

    } catch (IOException e) {

    }

  }

  try {

    //重设buffer,以便生成phrase查询的时候,term和position可以重新遍历。

    buffer.reset();

    source.close();

  }

  catch (IOException e) {

  }

  if (numTokens == 0)

    return null;

  else if (numTokens == 1) {

    //如果分词后只有一个Token,则生成TermQuery

    String term = null;

    try {

      boolean hasNext = buffer.incrementToken();

      term = termAtt.term();

    } catch (IOException e) {

    }

    return newTermQuery(new Term(field, term));

  } else {

   //如果分词后不只有一个Token

    if (severalTokensAtSamePosition) {

   //如果有多个Token处于同一个位置

      if (positionCount == 1) {

        //并且处于同一位置的Token还全部处于第一个位置,则生成BooleanQuery,处于同一位置的Token之间是OR的关系

        BooleanQuery q = newBooleanQuery(true);

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

          String term = null;

          try {

            boolean hasNext = buffer.incrementToken();

            term = termAtt.term();

          } catch (IOException e) {

          }

          Query currentQuery = newTermQuery(new Term(field, term));

          q.add(currentQuery, BooleanClause.Occur.SHOULD);

        }

        return q;

      }

      else {

        //如果有多个Token处于同一位置,但不是第一个位置,则生成MultiPhraseQuery。

        //所谓MultiPhraseQuery即其可以包含多个phrase,其又一个ArrayList<Term[]> termArrays,每一项都是一个Term的数组,属于同一个数组的Term表示在同一个位置。它有函数void add(Term[] terms)一次添加一个数组的Term。比如我们要搜索"microsoft app*",其表示多个phrase,"microsoft apple","microsoft application"都算。此时用QueryParser.parse("\"microsoft app*\"")从而生成PhraseQuery是搜不出microsoft apple和microsoft application的,也不能搜出microsoft app,因为*一旦被引号所引,就不算通配符了。所以必须生成MultiPhraseQuery,首先用add(new Term[]{new Term("field", "microsoft")})将microsoft作为一个Term数组添加进去,然后用add(new Term[]{new Term("field", "app"), new Term("field", "apple"), new Term("field", "application")})作为一个Term数组添加进去(算作同一个位置的),则三者都能搜的出来。

        MultiPhraseQuery mpq = newMultiPhraseQuery();

        mpq.setSlop(phraseSlop);

        List<Term> multiTerms = new ArrayList<Term>();

        int position = -1;

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

          String term = null;

          int positionIncrement = 1;

          try {

            boolean hasNext = buffer.incrementToken();

            assert hasNext == true;

            term = termAtt.term();

            if (posIncrAtt != null) {

              positionIncrement = posIncrAtt.getPositionIncrement();

            }

          } catch (IOException e) {

          }

          if (positionIncrement > 0 && multiTerms.size() > 0) {

            //如果positionIncrement大于零,说明此Term和前一个Term已经不是同一个位置了,所以原来收集在multiTerms中的Term都算作同一个位置,添加到MultiPhraseQuery中作为一项。并清除multiTerms,以便重新收集相同位置的Term。

            if (enablePositionIncrements) {

              mpq.add(multiTerms.toArray(new Term[0]),position);

            } else {

              mpq.add(multiTerms.toArray(new Term[0]));

            }

            multiTerms.clear();

          }

          //将此Term收集到multiTerms中。

          position += positionIncrement;

          multiTerms.add(new Term(field, term));

        }

        //当遍历完所有的Token,同处于最后一个位置的Term已经收集到multiTerms中了,把他们加到MultiPhraseQuery中作为一项。

        if (enablePositionIncrements) {

          mpq.add(multiTerms.toArray(new Term[0]),position);

        } else {

          mpq.add(multiTerms.toArray(new Term[0]));

        }

        return mpq;

      }

    }

    else {

      //如果不存在多个Token处于同一个位置的情况,则直接生成PhraseQuery

      PhraseQuery pq = newPhraseQuery();

      pq.setSlop(phraseSlop);

      int position = -1;

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

        String term = null;

        int positionIncrement = 1;

        try {

          boolean hasNext = buffer.incrementToken();

          assert hasNext == true;

          term = termAtt.term();

          if (posIncrAtt != null) {

            positionIncrement = posIncrAtt.getPositionIncrement();

          }

        } catch (IOException e) {

        }

        if (enablePositionIncrements) {

          position += positionIncrement;

          pq.add(new Term(field, term),position);

        } else {

          pq.add(new Term(field, term));

        }

      }

      return pq;

    }

  }

}

 

 

----------------------------------------------------------------------------------------------------------

相关文章:

 

Lucene学习总结之一:全文检索的基本原理

http://www.cnblogs.com/forfuture1978/archive/2009/12/14/1623594.html

Lucene学习总结之二:Lucene的总体架构

http://www.cnblogs.com/forfuture1978/archive/2009/12/14/1623596.html 

Lucene学习总结之三:Lucene的索引文件格式(1)

http://www.cnblogs.com/forfuture1978/archive/2009/12/14/1623597.html

Lucene学习总结之三:Lucene的索引文件格式(2)

http://www.cnblogs.com/forfuture1978/archive/2009/12/14/1623599.html

Lucene学习总结之三:Lucene的索引文件格式(3)

http://www.cnblogs.com/forfuture1978/archive/2010/02/02/1661436.html

Lucene学习总结之四:Lucene索引过程分析(1)

http://www.cnblogs.com/forfuture1978/archive/2010/02/02/1661439.html

Lucene学习总结之四:Lucene索引过程分析(2)

http://www.cnblogs.com/forfuture1978/archive/2010/02/02/1661440.html

Lucene学习总结之四:Lucene索引过程分析(3)

http://www.cnblogs.com/forfuture1978/archive/2010/02/02/1661441.html

Lucene学习总结之四:Lucene索引过程分析(4) 

http://www.cnblogs.com/forfuture1978/archive/2010/02/02/1661442.html 

Lucene学习总结之五:Lucene段合并(merge)过程分析

http://www.cnblogs.com/forfuture1978/archive/2010/03/06/1679501.html

Lucene学习总结之六:Lucene打分公式的数学推导

http://www.cnblogs.com/forfuture1978/archive/2010/03/07/1680007.html

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

http://www.cnblogs.com/forfuture1978/archive/2010/04/04/1704242.html

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

http://www.cnblogs.com/forfuture1978/archive/2010/04/04/1704245.html

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

http://www.cnblogs.com/forfuture1978/archive/2010/04/04/1704250.html

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

http://www.cnblogs.com/forfuture1978/archive/2010/04/04/1704254.html

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

http://www.cnblogs.com/forfuture1978/archive/2010/04/04/1704258.html

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

http://www.cnblogs.com/forfuture1978/archive/2010/04/04/1704263.html

 

posted @ 2010-05-08 00:21  刘超觉先  阅读(7284)  评论(0编辑  收藏  举报