Lucene學習總結之八：Lucene的查詢語法，JavaCC及QueryParser(1)

weixin_34391854發表於2010-05-08
Java

一、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表示檔案的結束。

詞法分析器工作過程如圖所示：

clip_image002

此一系列Token將被傳給語法分析器(當然並不是所有的Token都會傳給語法分析器，本例中SPACE就例外)，從而形成一棵語法分析樹來表示程式的結構。

clip_image004

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
{
  static = false;
}

PARSER_BEGIN(Adder)
package org.apache.javacc;

public class Adder
{
  public static void main(String args []) throws ParseException
  {
    Adder parser = new Adder(System.in);
    parser.start();
  }
}
PARSER_END(Adder)

SKIP :
{
  " "
| "\r"
| "\t"
| "\n"
}

TOKEN : /* OPERATORS */
{
  < PLUS : "+" >
}

TOKEN :
{
  < NUMBER : ([ "0"-"9" ])+ >
}

void start() :
{}
{
  <NUMBER>
  (
    <PLUS>
    <NUMBER>
  )*
}

用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.
Was expecting:
    <NUMBER> ...
    at org.apache.javacc.Adder.generateParseException(Adder.java:185)
    at org.apache.javacc.Adder.jj_consume_token(Adder.java:123)
    at org.apache.javacc.Adder.start(Adder.java:24)
    at org.apache.javacc.Adder.main(Adder.java:8)

如果輸入“123-456”則報如下異常：

Exception in thread "main" org.apache.javacc.TokenMgrError: Lexical error at line 1, column 4.  Encountered: "-" (45), after : ""
    at org.apache.javacc.AdderTokenManager.getNextToken(AdderTokenManager.java:262)
    at org.apache.javacc.Adder.jj_ntk(Adder.java:148)
    at org.apache.javacc.Adder.start(Adder.java:15)
    at org.apache.javacc.Adder.main(Adder.java:8)

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
{
  static = false;
}

PARSER_BEGIN(Calculator)
package org.apache.javacc.calculater;
  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)

SKIP : { " " }
TOKEN : { < EOL: "\n" | "\r" | "\r\n" > }
TOKEN : { < PLUS : "+" > }
TOKEN : { < MINUS : "-" > }
TOKEN : { < TIMES : "*" > }
TOKEN : { < DIVIDE : "/" > }
TOKEN : { < NUMBER : <DIGITS> | <DIGITS> "." <DIGITS> | <DIGITS> "." | "." <DIGITS>> }
TOKEN : { < #DIGITS : (["0"-"9"])+ > }
TOKEN : { < OPEN_PAR : "(" > }
TOKEN : { < CLOSE_PAR : ")" > }
TOKEN : { < PREVIOUS : "$" > }

void start(PrintStream printStream) throws NumberFormatException :
{}
{
  (
    previousValue = Expression()
    { printStream.println( previousValue ) ; }
  )*
}

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 ; }
}

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 ; }
}

生成的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");

}

 

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

相關文章：

 

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

 

 

相關文章