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) {