一、Lucene的查詢語法
Lucene所支援的查詢語法可見http://lucene.apache.org/java/3_0_1/queryparsersyntax.html
(1) 語法關鍵字
+ - && || ! ( ) { } [ ] ^ " ~ * ? : \
如果所要查詢的查詢詞中本身包含關鍵字，則需要用\進行轉義
(2) 查詢詞(Term)
Lucene支援兩種查詢詞，一種是單一查詢詞，如"hello"，一種是片語(phrase)，如"hello world"。
(3) 查詢域(Field)
在查詢語句中，可以指定從哪個域中尋找查詢詞，如果不指定，則從預設域中查詢。
查詢域和查詢詞之間用:分隔，如title:"Do it right"。
:僅對緊跟其後的查詢詞起作用，如果title:Do it right，則僅表示在title中查詢Do，而it right要在預設域中查詢。
(4) 萬用字元查詢(Wildcard)
支援兩種萬用字元：?表示一個字元，*表示多個字元。
萬用字元可以出現在查詢詞的中間或者末尾，如te?t，test*，te*t，但決不能出現在開始，如*test，?test。
(5) 模糊查詢(Fuzzy)
模糊查詢的演算法是基於Levenshtein Distance，也即當兩個詞的差別小於某個比例的時候，就算匹配，如roam~0.8，即表示差別小於0.2，相似度大於0.8才算匹配。
(6) 臨近查詢(Proximity)
在片語後面跟隨~10，表示片語中的多個詞之間的距離之和不超過10，則滿足查詢。
所謂詞之間的距離，即查詢片語中詞為滿足和目標片語相同的最小移動次數。
如索引中有片語"apple boy cat"。
如果查詢詞為"apple boy cat"~0，則匹配。
如果查詢詞為"boy apple cat"~2，距離設為2方能匹配，設為1則不能匹配。
|
(0) |
boy |
apple |
cat |
|
(1) |
boy apple |
cat | |
|
(2) |
apple |
boy |
cat |
如果查詢詞為"cat boy apple"~4，距離設為4方能匹配。
|
(0) |
cat |
boy |
apple |
|
(1) |
cat boy |
apple | |
|
(2) |
boy |
cat apple | |
|
(3) |
boy apple |
cat | |
|
(4) |
apple |
boy |
cat |
(7) 區間查詢(Range)
區間查詢包含兩種，一種是包含邊界，用[A TO B]指定，一種是不包含邊界，用{A TO B}指定。
如date:[20020101 TO 20030101]，當然區間查詢不僅僅用於時間，如title:{Aida TO Carmen}
(8) 增加一個查詢詞的權重(Boost)
可以在查詢詞後面加^N來設定此查詢詞的權重，預設是1，如果N大於1，則說明此查詢詞更重要，如果N小於1，則說明此查詢詞更不重要。
如jakarta^4 apache，"jakarta apache"^4 "Apache Lucene"
(9) 布林操作符
布林操作符包括連線符，如AND，OR，和修飾符，如NOT，+，-。
預設狀態下，空格被認為是OR的關係，QueryParser.setDefaultOperator(Operator.AND)設定為空格為AND。
+表示一個查詢語句是必須滿足的(required)，NOT和-表示一個查詢語句是不能滿足的(prohibited)。
(10) 組合
可以用括號，將查詢語句進行組合，從而設定優先順序。
如(jakarta OR apache) AND website
Lucene的查詢語法是由QueryParser來進行解析，從而生成查詢物件的。
通過編譯原理我們知道，解析一個語法表示式，需要經過詞法分析和語法分析的過程，也即需要詞法分析器和語法分析器。
QueryParser是通過JavaCC來生成詞法分析器和語法分析器的。
二、JavaCC介紹
本節例子基本出於JavaCC tutorial的文章，http://www.engr.mun.ca/~theo/JavaCC-Tutorial/
JavaCC是一個詞法分析器和語法分析器的生成器。
所謂詞法分析器就是將一系列字元分成一個個的Token，並標記Token的分類。
例如，對於下面的C語言程式：
|
int main() { return 0 ; } |
將被分成以下的Token:
|
“int”, “ ”, “main”, “(”, “)”, “”,“{”, “\n”, “\t”, “return” “”,“0”,“”,“;”,“\n”, “}”, “\n”, “” |
標記了Token的型別後如下：
|
KWINT, SPACE, ID, OPAR, CPAR, SPACE, OBRACE, SPACE, SPACE, KWRETURN, SPACE, OCTALCONST, SPACE, SEMICOLON, SPACE, CBRACE, SPACE, EOF |
EOF表示檔案的結束。
詞法分析器工作過程如圖所示：
此一系列Token將被傳給語法分析器(當然並不是所有的Token都會傳給語法分析器，本例中SPACE就例外)，從而形成一棵語法分析樹來表示程式的結構。
JavaCC本身既不是一個詞法分析器，也不是一個語法分析器，而是根據指定的規則生成兩者的生成器。
2.1、第一個例項——正整數相加
下面我們來看第一個例子，即能夠解析正整數相加的表示式，例如99+42+0+15。
(1) 生成一個adder.jj檔案
此檔案中寫入的即生成詞法分析器和語法分析器的規則。
(2) 設定選項，並宣告類
|
/* adder.jj Adding up numbers */ options { STATIC = false ; } PARSER_BEGIN(Adder) class Adder { static void main( String[] args ) throws ParseException, TokenMgrError { Adder parser = new Adder( System.in ) ; parser.Start() ; } } PARSER_END(Adder) |
STATIC選項預設是true，設為false，使得生成的函式不是static的。
PARSER_BEGIN和PARSER_END之間的java程式碼部分，此部分不需要通過JavaCC根據規則生成java程式碼，而是直接拷貝到生成的java程式碼中的。
(3) 宣告一個詞法分析器
|
SKIP : { " " } SKIP : { "\n" | "\r" | "\r\n" } TOKEN : { < PLUS : "+" > } TOKEN : { < NUMBER : (["0"-"9"])+ > } |
第一二行表示空格和回車換行是不會傳給語法分析器的。
第三行宣告瞭一個Token，名稱為PLUS，符號為“+”。
第四行宣告瞭一個Token，名稱為NUMBER，符號位一個或多個0-9的數的組合。
如果詞法分析器分析的表示式如下：
- “123 + 456\n”，則分析為NUMBER, PLUS, NUMBER, EOF
- “123 - 456\n”，則報TokenMgrError，因為“-”不是一個有效的Token.
- “123 ++ 456\n”，則分析為NUMBER, PLUS, PLUS, NUMBER, EOF，詞法分析正確，後面的語法分析將會錯誤。
(4) 宣告一個語法分析器
|
void Start() : {} { <NUMBER> ( <PLUS> <NUMBER> )* <EOF> } |
語法分析器使用BNF表示式。
上述宣告將生成start函式，稱為Adder類的一個成員函式
語法分析器要求輸入的語句必須以NUMBER開始，以EOF結尾，中間是零到多個PLUS和NUMBER的組合。
(5) 用javacc編譯adder.jj來生成語法分析器和詞法分析器
最後生成的adder.jj如下：
|
options PARSER_BEGIN(Adder) public class Adder SKIP : TOKEN : /* OPERATORS */ TOKEN : void start() : |
用JavaCC編譯adder.jj生成如下檔案：
- Adder.java：語法分析器。其中的main函式是完全從adder.jj中拷貝的，而start函式是被javacc由adder.jj描述的規則生成的。
- AdderConstants.java：一些常量，如PLUS, NUMBER, EOF等。
- AdderTokenManager.java：詞法分析器。
- ParseException.java：用於在語法分析錯誤的時候丟擲。
- SimpleCharStream.java：用於將一系列字串傳入詞法分析器。
- Token.java：代表詞法分析後的一個個Token。Token物件有一個整型域kind，來表示此Token的型別(PLUS, NUMBER, EOF)，有一個String型別的域image，來表示此Token的值。
- TokenMgrError.java：用於在詞法分析錯誤的時候丟擲。
下面我們對adder.jj生成的start函式進行分析：
|
final public void start() throws ParseException { //從詞法分析器取得下一個Token，而且要求必須是NUMBER型別，否則丟擲異常。 //此步要求表示式第一個出現的字元必須是NUMBER。 jj_consume_token(NUMBER); label_1: while (true) { //jj_ntk()是取得下一個Token的型別，如果是PLUS，則繼續進行，如果是EOF則退出迴圈。 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { case PLUS: ; break; default: jj_la1[0] = jj_gen; break label_1; } //要求下一個PLUS字元，再下一個是一個NUMBER，如此下去。 jj_consume_token(PLUS); jj_consume_token(NUMBER); } } |
(6) 執行Adder.java
如果輸入“123+456”則不報任何錯誤。
如果輸入“123++456”則報如下異常：
|
Exception in thread "main" org.apache.javacc.ParseException: Encountered " "+" "+ "" at line 1, column 5. |
如果輸入“123-456”則報如下異常：
|
Exception in thread "main" org.apache.javacc.TokenMgrError: Lexical error at line 1, column 4. Encountered: "-" (45), after : "" |
2.2、擴充套件語法分析器
在上面的例子中的start函式中，我們僅僅通過語法分析器來判斷輸入的語句是否正確。
我們可以擴充套件BNF表示式，加入Java程式碼，使得經過語法分析後，得到我們想要的結果或者物件。
我們將start函式改寫為：
|
int start() throws NumberFormatException : { //start函式中有三個變數 Token t ; int i ; int value ; } { //首先要求表示式的第一個一定是一個NUMBER，並把其值付給t t= <NUMBER> //將t的值取出來，解析為整型，放入變數i中 { i = Integer.parseInt( t.image ) ; } //最後的結果value設為i { value = i ; } //緊接著應該是零個或者多個PLUS和NUMBER的組合 ( <PLUS> //每出現一個NUMBER，都將其付給t，並將t的值解析為整型，付給i t= <NUMBER> { i = Integer.parseInt( t.image ) ; } //將i加到value上 { value += i ; } )* //最後的value就是表示式的和 { return value ; } } |
生成的start函式如下：
|
final public int start() throws ParseException, NumberFormatException { Token t; int i; int value; t = jj_consume_token(NUMBER); i = Integer.parseInt(t.image); value = i; label_1: while (true) { switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { case PLUS: ; break; default: jj_la1[0] = jj_gen; break label_1; } jj_consume_token(PLUS); t = jj_consume_token(NUMBER); i = Integer.parseInt(t.image); value += i; } { if (true) return value; } throw new Error("Missing return statement in function"); } |
從上面的例子，我們發現，把一個NUMBER取出，並解析為整型這一步是可以共用的，所以可以抽象為一個函式：
|
int start() throws NumberFormatException : { int i; int value ; } { value = getNextNumberValue() ( <PLUS> i = getNextNumberValue() { value += i ; } )* { return value ; } } int getNextNumberValue() throws NumberFormatException : { Token t ; } { t=<NUMBER> { return Integer.parseInt( t.image ) ; } } |
生成的函式如下：
|
final public int start() throws ParseException, NumberFormatException { int i; int value; value = getNextNumberValue(); label_1: while (true) { switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { case PLUS: ; break; default: jj_la1[0] = jj_gen; break label_1; } jj_consume_token(PLUS); i = getNextNumberValue(); value += i; } { if (true) return value; } throw new Error("Missing return statement in function"); } final public int getNextNumberValue() throws ParseException, NumberFormatException { Token t; t = jj_consume_token(NUMBER); { if (true) return Integer.parseInt(t.image); } throw new Error("Missing return statement in function"); } |
2.3、第二個例項：計算器
(1) 生成一個calculator.jj檔案
用於寫入生成計算器詞法分析器和語法分析器的規則。
(2) 設定選項，並宣告類
|
options { STATIC = false ; } PARSER_BEGIN(Calculator) import java.io.PrintStream ; class Calculator { static void main( String[] args ) throws ParseException, TokenMgrError, NumberFormatException { Calculator parser = new Calculator( System.in ) ; parser.Start( System.out ) ; } double previousValue = 0.0 ; } PARSER_END(Calculator) |
previousValue用來記錄上一次計算的結果。
(3) 宣告一個詞法分析器
|
SKIP : { " " } TOKEN : { < EOL:"\n" | "\r" | "\r\n" > } TOKEN : { < PLUS : "+" > } |
我們想要支援小數，則有四種情況：沒有小數，小數點在中間，小數點在前面，小數點在後面。則語法規則如下：
|
TOKEN { < NUMBER : (["0"-"9"])+ | (["0"-"9"])+ "." (["0"-"9"])+ | (["0"-"9"])+ "." | "." (["0"-"9"])+ > } |
由於同一個表示式["0"-"9"]使用了多次，因而我們可以定義變數，如下：
|
TOKEN : { < NUMBER : <DIGITS> | <DIGITS> "." <DIGITS> | <DIGITS> "." | "." <DIGITS>> } TOKEN : { < #DIGITS : (["0"-"9"])+ > } |
(4) 宣告一個語法分析器
我們想做的計算器包含多行，每行都是一個四則運算表示式，語法規則如下：
|
Start -> (Expression EOL)* EOF |
|
void Start(PrintStream printStream) throws NumberFormatException : {} { ( previousValue = Expression() <EOL> { printStream.println( previousValue ) ; } )* <EOF> } |
每一行的四則運算表示式如果只包含加法，則語法規則如下：
|
Expression -> Primary (PLUS Primary)* |
|
double Expression() throws NumberFormatException : { double i ; double value ; } { value = Primary() ( <PLUS> i= Primary() { value += i ; } )* { return value ; } } |
其中Primary()得到一個數的值：
|
double Primary() throws NumberFormatException : { Token t ; } { t= <NUMBER> { return Double.parseDouble( t.image ) ; } } |
(5) 擴充套件詞法分析器和語法分析器
如果我們想支援減法，則需要在詞法分析器中新增：
|
TOKEN : { < MINUS : "-" > } |
語法分析器應該變為：
|
Expression -> Primary (PLUS Primary | MINUS Primary)* |
|
double Expression() throws NumberFormatException : { double i ; double value ; } { value = Primary() ( <PLUS> i = Primary() { value += i ; } | <MINUS> i = Primary() { value -= i ; } )* { return value ; } } |
如果我們想新增乘法和除法，則在詞法分析器中應該加入：
|
TOKEN : { < TIMES : "*" > } TOKEN : { < DIVIDE : "/" > } |
對於加減乘除混合運算，則應該考慮優先順序，乘除的優先順序高於加減，應該先做乘除，再做加減：
|
Expression -> Term (PLUSTerm | MINUSTerm)* Term -> Primary (TIMES Primary | DIVIDE Primary)* |
|
double Expression() throws NumberFormatException : { double i ; double value ; } { value = Term() ( <PLUS> i= Term() { value += i ; } | <MINUS> i= Term() { value -= i ; } )* { return value ; } } |
|
double Term() throws NumberFormatException : { double i ; double value ; } { value = Primary() ( <TIMES> i = Primary() { value *= i ; } | <DIVIDE> i = Primary() { value /= i ; } )* { return value ; } } |
下面我們要開始支援括號，負號，以及取得上一行四則運算表示式的值。
對於詞法分析器，我們新增如下Token：
|
TOKEN : { < OPEN PAR : "(" > } TOKEN : { < CLOSE PAR : ")" > } TOKEN : { < PREVIOUS : "$" > } |
對於語法分析器，對於最基本的表示式，有四種情況：
其可以是一個NUMBER，也可以是上一行四則運算表示式的值PREVIOUS，也可以是被括號括起來的一個子語法表示式，也可以是取負的一個基本語法表示式。
|
Primary –> NUMBER | PREVIOUS | OPEN_PAR Expression CLOSE_PAR | MINUS Primary |
|
double Primary() throws NumberFormatException : { Token t ; double d ; } { t=<NUMBER> { return Double.parseDouble( t.image ) ; } | <PREVIOUS> { return previousValue ; } | <OPEN PAR> d=Expression() <CLOSE PAR> { return d ; } | <MINUS> d=Primary() { return -d ; } } |
(6) 用javacc編譯calculator.jj來生成語法分析器和詞法分析器
最後生成的calculator.jj如下：
|
options PARSER_BEGIN(Calculator) SKIP : { " " } void start(PrintStream printStream) throws NumberFormatException : double Expression() throws NumberFormatException : double Term() throws NumberFormatException : double Primary() throws NumberFormatException : |
生成的start函式如下：
|
final public void start(PrintStream printStream) throws ParseException, NumberFormatException { label_1: while (true) { switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { case MINUS: case NUMBER: case OPEN_PAR: case PREVIOUS: ; break; default: jj_la1[0] = jj_gen; break label_1; } previousValue = Expression(); printStream.println( previousValue ) ; } } final public double Expression() throws ParseException, NumberFormatException { double i ; double value ; value = Term(); label_2: while (true) { switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { case PLUS: case MINUS: ; break; default: jj_la1[1] = jj_gen; break label_2; } switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { case PLUS: jj_consume_token(PLUS); i = Term(); value += i ; break; case MINUS: jj_consume_token(MINUS); i = Term(); value -= i ; break; default: jj_la1[2] = jj_gen; jj_consume_token(-1); throw new ParseException(); } } {if (true) return value ;} throw new Error("Missing return statement in function"); } final public double Term() throws ParseException, NumberFormatException { double i ; double value ; value = Primary(); label_3: while (true) { switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { case TIMES: case DIVIDE: ; break; default: jj_la1[3] = jj_gen; break label_3; } switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { case TIMES: jj_consume_token(TIMES); i = Primary(); value *= i ; break; case DIVIDE: jj_consume_token(DIVIDE); i = Primary(); value /= i ; break; default: jj_la1[4] = jj_gen; jj_consume_token(-1); throw new ParseException(); } } {if (true) return value ;} throw new Error("Missing return statement in function"); } final public double Primary() throws ParseException, NumberFormatException { Token t ; double d ; switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { case NUMBER: t = jj_consume_token(NUMBER); {if (true) return Double.parseDouble( t.image ) ;} break; case PREVIOUS: jj_consume_token(PREVIOUS); {if (true) return previousValue ;} break; case OPEN_PAR: jj_consume_token(OPEN_PAR); d = Expression(); jj_consume_token(CLOSE_PAR); {if (true) return d ;} break; case MINUS: jj_consume_token(MINUS); d = Primary(); {if (true) return -d ;} break; default: jj_la1[5] = jj_gen; jj_consume_token(-1); throw new ParseException(); } throw new Error("Missing return statement in function"); } |
----------------------------------------------------------------------------------------------------------
相關文章：
http://www.cnblogs.com/forfuture1978/archive/2009/12/14/1623594.html
http://www.cnblogs.com/forfuture1978/archive/2009/12/14/1623596.html
http://www.cnblogs.com/forfuture1978/archive/2009/12/14/1623597.html
http://www.cnblogs.com/forfuture1978/archive/2009/12/14/1623599.html
http://www.cnblogs.com/forfuture1978/archive/2010/02/02/1661436.html
http://www.cnblogs.com/forfuture1978/archive/2010/02/02/1661439.html
http://www.cnblogs.com/forfuture1978/archive/2010/02/02/1661440.html
http://www.cnblogs.com/forfuture1978/archive/2010/02/02/1661441.html
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
http://www.cnblogs.com/forfuture1978/archive/2010/03/07/1680007.html
http://www.cnblogs.com/forfuture1978/archive/2010/04/04/1704242.html
http://www.cnblogs.com/forfuture1978/archive/2010/04/04/1704245.html
http://www.cnblogs.com/forfuture1978/archive/2010/04/04/1704250.html
http://www.cnblogs.com/forfuture1978/archive/2010/04/04/1704254.html
http://www.cnblogs.com/forfuture1978/archive/2010/04/04/1704258.html
http://www.cnblogs.com/forfuture1978/archive/2010/04/04/1704263.html