Tuesday, April 04, 2006

 

Some notes on Lucene and its derivatives - 1

1.
From http://jalorsoft.com/holen/holen_lucene_01.html

Lucene研究之一——起源、现状及初步应用

作者:陈光(holen@263.net)

时间:2004-08-23

本文是Lucene研究文集的首篇,主要介绍了Lucene的起源、发展、现状,以及Luence的初步应用,可以作为了解和学习Lucene的入门资料。

1. 起源与发展

Lucene是一个高性能、纯Java的全文检索引擎,而且免费、开源。Lucene几乎适合于任何需要全文检索的应用,尤其是跨平台的应用。

Lucene的作者Doug Cutting是一个资深的全文检索专家,刚开始,Doug Cutting将Lucene发表在自己的主页上,2000年3月将其转移到sourceforge,于2001年10捐献给Apache,作为Jakarta的一个子工程。

2.使用现状

经过多年的发展,Lucene在全文检索领域已经有了很多的成功案例,并积累了良好的声誉。

基于Lucene的全文检索产品(Lucene本身只是一个组件,而非一个完整的应用)和应用Lucene的项目在世界各地已经非常之多,比较知名的有:

l Eclipse:主流Java开发工具,其帮助文档采用Lucene作为检索引擎

l Jive:知名论坛系统,其检索功能基于Lucene

l Ifinder:出自德国的网站检索系统,基于Lucene(http://ifinder.intrafind.org/)

l MIT DSpace Federation:一个文档管理系统(http://www.dspace.org/)

国内外采用Lucene作为网站全文检索引擎的也很多,比较知名的有:

l http://www.blogchina.com/weblucene/

l http://www.ioffer.com/

l http://search.soufun.com/

l http://www.taminn.com/

(更多案例,请参见http://wiki.apache.org/jakarta-lucene/PoweredBy)

在所有这些案例中,开源应用占了很大一部分,但更多的还是商化业产品和网站。毫不夸张的说,Lucene的出现,极大的推动了全文检索技术在各个行业或领域中的深层次应用。

3.初步应用

前面提到,Lucene本身只是一个组件,而非一个完整的应用,所以若想让Lucene跑起来,还得在Lucene基础上进行必要的二次开发。

下载与安装

首先,你需要到Lucene的官方网站http://jakarta.apache.org/lucene/ 去下载一份拷贝,最新版是1.4。下载后将得到一个名为lucene-1.4-final.zip的压缩文件,将其解压,里面有一个名为lucene-1.4-final.jar的文件,这就是Lucene组件包了,若需要在项目使用Lucene,只需要把lucene-1.4-final.jar置于类路径下即可,至于解压后的其他文件都是参考用的。

接下来,我用Eclipse建立一个工程,实现基于Lucene的建库、记录加载和记录查询等功能。

如上图所示,这是开发完成后的工程,其中有三个源文件CreateDataBase.java,InsertRecords.java,QueryRecords.java,分别实现建库、入库、检索的功能。

以下是对这三个源文件的分析。

建库源码及说明

CreateDataBase.java

package com.holen.part1;

import java.io.File;

import org.apache.lucene.analysis.standard.StandardAnalyzer;

import org.apache.lucene.index.IndexWriter;

/**

* @author Holen Chen

* 初始化检索库

*/

public class CreateDataBase {

public CreateDataBase() {

}

public int createDataBase(File file){

int returnValue = 0;

if(!file.isDirectory()){

file.mkdirs();

}

try{

IndexWriter indexWriter = new IndexWriter(file,new StandardAnalyzer(),true);

indexWriter.close();

returnValue = 1;

}catch(Exception ex){

ex.printStackTrace();

}

return returnValue;

}

/**

* 传入检索库路径,初始化库

* @param file

* @return

*/

public int createDataBase(String file){

return this.createDataBase(new File(file));

}

public static void main(String[] args) {

CreateDataBase temp = new CreateDataBase();

if(temp.createDataBase("e:\\lucene\\holendb") == 1){

System.out.println("db init succ");

}

}

}

说明:这里最关键的语句是IndexWriter indexWriter = new IndexWriter(file,new StandardAnalyzer(),true)。

第一个参数是库的路径,也就是说你准备把全文检索库保存在哪个位置,比如main方法中设定的“e:\\lucene\\holendb”,Lucene支持多库,且每个库的位置允许不同。

第二个参数是分析器,这里采用的是Lucene自带的标准分析器,分析器用于对整篇文章进行分词解析,这里的标准分析器实现对英文(或拉丁文,凡是由字母组成,由空格分开的文字均可)的分词,分析器将把整篇英文按空格切成一个个的单词(在全文检索里这叫切词,切词是全文检索的核心技术之一,Lucene默认只能切英文或其他拉丁文,默认不支持中日韩等双字节文字,关于中文切词技术将在后续章节重点探讨)。

第三个参数是是否初始化库,这里我设的是true,true意味着新建库或覆盖已经存在的库,false意味着追加到已经存在的库。这里新建库,所以肯定需要初始化,初始化后,库目录下只存在一个名为segments的文件,大小为1k。但是当库中存在记录时执行初始化,库中内容将全部丢失,库回复到初始状态,即相当于新建了该库,所以真正做项目时,该方法一定要慎用。

加载记录源码及说明

InsertRecords.java

package com.holen.part1;

import java.io.File;

import java.io.FileReader;

import java.io.Reader;

import org.apache.lucene.analysis.standard.StandardAnalyzer;

import org.apache.lucene.document.Document;

import org.apache.lucene.document.Field;

import org.apache.lucene.index.IndexWriter;

/**

* @author Holen Chen

* 记录加载

*/

public class InsertRecords {

public InsertRecords() {

}

public int insertRecords(String dbpath,File file){

int returnValue = 0;

try{

IndexWriter indexWriter

= new IndexWriter(dbpath,new StandardAnalyzer(),false);

this.addFiles(indexWriter,file);

returnValue = 1;

}catch(Exception ex){

ex.printStackTrace();

}

return returnValue;

}

/**

* 传入需加载的文件名

* @param file

* @return

*/

public int insertRecords(String dbpath,String file){

return this.insertRecords(dbpath,new File(file));

}

public void addFiles(IndexWriter indexWriter,File file){

Document doc = new Document();

try{

doc.add(Field.Keyword("filename",file.getName()));

//以下两句只能取一句,前者是索引不存储,后者是索引且存储

//doc.add(Field.Text("content",new FileReader(file)));

doc.add(Field.Text("content",this.chgFileToString(file)));

indexWriter.addDocument(doc);

indexWriter.close();

}catch(Exception ex){

ex.printStackTrace();

}

}

/**

* 从文本文件中读取内容

* @param file

* @return

*/

public String chgFileToString(File file){

String returnValue = null;

StringBuffer sb = new StringBuffer();

char[] c = new char[4096];

try{

Reader reader = new FileReader(file);

int n = 0;

while(true){

n = reader.read(c);

if(n > 0){

sb.append(c,0,n);

}else{

break;

}

}

reader.close();

}catch(Exception ex){

ex.printStackTrace();

}

returnValue = sb.toString();

return returnValue;

}

public static void main(String[] args) {

InsertRecords temp = new InsertRecords();

String dbpath = "e:\\lucene\\holendb";

//holen1.txt中包含关键字"holen"和"java"

if(temp.insertRecords(dbpath,"e:\\lucene\\holen1.txt") == 1){

System.out.println("add file1 succ");

}

//holen2.txt中包含关键字"holen"和"chen"

if(temp.insertRecords(dbpath,"e:\\lucene\\holen2.txt") == 1){

System.out.println("add file2 succ");

}

}

}

说明:这个类里面主要有3个方法insertRecords(String dbpath,File file),addFiles(IndexWriter indexWriter,File file),chgFileToString(File file)。

ChgFileToString方法用于读取文本型文件到一个String变量中。

InsertRecords方法用于加载一条记录,这里是将单个文件入全文检索库,第一个参数是库路径,第二个参数是需要入库的文件。

InsertRecords需要调用addFiles,addFiles是文件入库的真正执行者。AddFiles里有如下几行重点代码:

doc.add(Field.Keyword("filename",file.getName()));

注意,在Lucene里没有严格意义上表,Lucene的表是通过Field类的方法动态构建的,比如Field.Keyword("filename",file.getName())就相当于在一条记录加了一个字段,字段名为filename,该字段的内容为file.getName()。

常用的Field方法如下:

方法
切词
索引
存储
用途

Field.Text(String name, String value)
Y
Y
Y
标题,文章内容

Field.Text(String name, Reader value)
Y
Y
N
META信息

Field.Keyword(String name, String value)
N
Y
Y
作者

Field.UnIndexed(String name, String value)
N
N
Y
文件路径

Field.UnStored(String name, String value)
Y
Y
N
与第二种类似

为了更深入的了解全文检索库,我们可以将全文检索库与通常的关系型数据库(如Oracle,Mysql)作一下对比。

全文检索库对关系型数据库对比

对比项
全文检索库(Lucene)
关系型数据库(Oracle)

核心功能
以文本检索为主,插入(insert)、删除(delete)、修改(update)比较麻烦,适合于大文本块的查询。
插入(insert)、删除(delete)、修改(update)十分方便,有专门的SQL命令,但对于大文本块(如CLOB)类型的检索效率低下。


与Oracle类似,都可以建多个库,且各个库的存储位置可以不同。
可以建多个库,每个库一般都有控制文件和数据文件等,比较复杂。


没有严格的表的概念,比如Lucene的表只是由入库时的定义字段松散组成。
有严格的表结构,有主键,有字段类型等。

记录
由于没有严格表的概念,所以记录体现为一个对象,在Lucene里记录对应的类是Document。
Record,与表结构对应。

字段
字段类型只有文本和日期两种,字段一般不支持运算,更无函数功能。

在Lucene里字段的类是Field,如document(field1,field2…)
字段类型丰富,功能强大。

record(field1,field2…)

查询结果集
在Lucene里表示查询结果集的类是Hits,如hits(doc1,doc2,doc3…)
在JDBC为例, Resultset(record1,record2,record3...)

两种库对比图如下:

Lucene

doc(field1,field2..),doc(field1,field2..)

入库: indexer

Hits(doc(field1,field2..),doc(field1,field2..)...)

查询: seracher

Oracle

record(field1,field2..),doc(field1,field2..)

入库: insert

rResultset(record(field1,field2..),doc(field1,field2..)

查询: select

检索源码及说明

QueryRecords.java

package com.holen.part1;

import java.util.ArrayList;

import org.apache.lucene.analysis.standard.StandardAnalyzer;

import org.apache.lucene.document.Document;

import org.apache.lucene.queryParser.QueryParser;

import org.apache.lucene.search.Hits;

import org.apache.lucene.search.IndexSearcher;

import org.apache.lucene.search.Query;

import org.apache.lucene.search.Searcher;

/**

* @author Holen Chen

* 检索查询

*/

public class QueryRecords {

public QueryRecords() {

}

/**

* 检索查询,将结果集返回

* @param searchkey

* @param dbpath

* @param searchfield

* @return

*/

public ArrayList queryRecords(String searchkey,String dbpath,String searchfield){

ArrayList list = null;

try{

Searcher searcher = new IndexSearcher(dbpath);

Query query

= QueryParser.parse(searchkey,searchfield,new StandardAnalyzer());

Hits hits = searcher.search(query);

if(hits != null){

list = new ArrayList();

int temp_hitslength = hits.length();

Document doc = null;

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

doc = hits.doc(i);

list.add(doc.get("filename"));

}

}

}catch(Exception ex){

ex.printStackTrace();

}

return list;

}

public static void main(String[] args) {

QueryRecords temp = new QueryRecords();

ArrayList list = null;

list = temp.queryRecords("holen","e:\\lucene\\holendb","content");

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

System.out.println((String)list.get(i));

}

}

}

说明:该类中Searcher负责查询,并把查询结果以Hits对象集方式返回,Hits好比JDBC中的RecordSet,Hits是Document的集合,每个Document相当于一条记录,Document中包含一个或多个字段,可以通过Document.get(“字段名”)方法得到每个字段的内容。

通过这三个类,就完成了一个简单的基于Lucene的全文检索应用。

4.总结

Lucene十分精练纯粹,就一个jar包,引入到你的工程中,调用其接口,就可以为你的应用增添全文检索功能。

通过上一节的初步应用会发现,Lucene使用起来很简单,与JDBC有些类似,应用时重点掌握好IndexWriter,Document,Field,Searcher等几个类即可。

Lucene的结构很清晰,每个package司职一项,比如org.apache.Lucene.search负责检索,org.apache.Lucene.index索引,org.apache.Lucene.analysis切词等,且Lucene的主要动作都采用了抽象类,扩展起来十分方便。

相对于一些商业化全文检索,Lucene的入库速度更快。因为它的存储采取分步合并的方法,先建立小索引,待时机成熟才把小索引合并到大索引树上。因此,我们在操作应用数据时可以同步进行全文检索库的操作而不会(或许很少)影响系统的效能。

Lucene性能稳定,使用简单,而且开源免费,有Apache基金在后面做支撑,资金和技术力量都十分雄厚,这两年也一直是稳步更新,每次新版本的推出,业界均争相报导。

参考资料

1. Introduction to Text Indexing with Apache Jakarta Lucene(Otis Gospodnetic)
http://www.onjava.com/pub/a/onjava/2003/01/15/lucene.html

2. Lucene Introduction in Chinese(车东)
http://www.chedong.com/tech/lucene.html

3. Lucene Tutorial(Steven J. Owens)
http://www.darksleep.com/lucene/

2.
From http://jalorsoft.com/holen/holen_lucene_02.html

Lucene研究之二——系统结构分析初步

作者:陈光(holen@263.net)

时间:2004-08-26

本文主要讨论Lucene的系统结构,希望对其结构的初步分析,更深入的了解Lucene的运作机制,从而实现对Lucene的功能扩展。

1. Lucene的包结构

如上图所示,Lucene源码中共包括7个子包,每个包完成特定的功能:

Lucene包结构功能表

包名
功能

org.apache.lucene.analysis
语言分析器,主要用于的切词,支持中文主要是扩展此类

org.apache.lucene.document
索引存储时的文档结构管理,类似于关系型数据库的表结构

org.apache.lucene.index
索引管理,包括索引建立、删除等

org.apache.lucene.queryParser
查询分析器,实现查询关键词间的运算,如与、或、非等

org.apache.lucene.search
检索管理,根据查询条件,检索得到结果

org.apache.lucene.store
数据存储管理,主要包括一些底层的I/O操作

org.apache.lucene.util
一些公用类

2. Lucene的主要逻辑图

Lucene功能强大,但从根本上说,主要包括两块:一是文本内容经切词后索引入库;二是根据查询条件返回结果。

以下是上述两大功能的逻辑图:

STORAGE

(存储器)

ACCESS INDEX

(访问索引)

SERACHER

(查询器)

ANALYZER

(语言分析器)

QUERY PARSER

(查询分析器)

DOCUMENT

(文档结构)

SEARCHER

(查询)

INDEXER

(入库)

FS

BDD

RAM

Lucene功能逻辑图

查询逻辑

按先后顺序,查询逻辑可分为如下几步:

1. 查询者输入查询条件
条件之间可以通过特定运算符进行运算,比如查询希望查询到与“中国”和“北京”相关的记录,但不希望结果中包括“海淀区中关村”,于是输入条件为“中国+北京-海淀区中关村”;

2. 查询条件被传达到查询分析器中,分析器将将对“中国+北京-海淀区中关村”进行分析,首先分析器解析字符串的连接符,即这里的加号和减号,然后对每个词进行切词,一般最小的词元是两个汉字,则中国和北京两个词不必再切分,但对海淀区中关村需要切分,假设根据切词算法,把该词切分为“海淀区”和“中关村”两部分,则最后得到的查询条件可以表示为:“中国” AND “北京” AND NOT(“海淀区” AND “中关村”)。

3. 查询器根据这个条件遍历索引树,得到查询结果,并返回结果集,返回的结果集类似于JDBC中的ResultSet。

4. 将返回的结果集显示在查询结果页面,当点击某一条内容时,可以链接到原始网页,也可以打开全文检索库中存储的网页内容。

这就是查询的逻辑过程,需要说明的是,Lucene默认只支持英文,为了便于说明问题,以上查询过程采用中文举例,事实上,当Lucene被扩充支持中文后就是这么一个查询过程。

入库逻辑

入库将把内容加载到全文检索库中,按顺序,入库逻辑包括如下过程:

1. 入库者定义到库中文档的结构,比如需要把网站内容加载到全文检索库,让用户通过“站内检索”搜索到相关的网页内容。入库文档结构与关系型数据库中的表结构类似,每个入库的文档由多个字段构成,假设这里需要入库的网站内容包括如下字段:文章标题、作者、发布时间、原文链接、正文内容(一般作为网页快照)。

2. 包含N个字段的文档(DOCUMENT)在真正入库前需要经过切词(或分词)索引,切词的规则由语言分析器(ANALYZER)完成。

3. 切分后的“单词”被注册到索引树上,供查询时用,另外也需要也其它不需要索引的内容入库,所有这些是文件操作均由STORAGE完成。

以上就是记录加载流程,索引树是一种比较复杂的数据存储结构,将在后续章节陆续介绍,这里就不赘述了,需要说明的一点是,Lucene的索引树结构非常优秀,是Lucene的一大特色。

接下来将对Lucene的各个子包的结构进行讨论。

3. 语言分析包org.apache.lucene.analysis

Analyzer是一个抽象类,司职对文本内容的切分词规则。

切分后返回一个TokenStream,TokenStream中有一个非常重要方法next(),即取到下一个词。简单点说,通过切词规则,把一篇文章从头到尾分成一个个的词,这就是org.apache.lucene.analysis的工作。

对英文而言,其分词规则很简单,因为每个单词间都有一个空格,按空格取单词即可,当然为了提高英文检索的准确度,也可以把一些短语作为一个整体,其间不切分,这就需要一个词库,对德文、俄文也是类似,稍有不同。

对中文而言,文字之间都是相连的,没有空格,但我们同样可以把字切分,即把每个汉字作为一个词切分,这就是所谓的“切字”,但切字方式方式的索引没有意义,准确率太低,要想提高准确度一般都是切词,这就需要一个词库,词库越大准确度将越高,但入库效率越低。

若要支持中文切词,则需要扩展Analyzer类,根据词库中的词把文章切分。

简单点说,org.apache.lucene.analysis就是完成将文章切分词的任务。

4. 文档结构包org.apache.lucene.document

document包相对而言比较简单,该包下面就3个类,Document相对于关系型数据库的记录对象,主要负责字段的管理,字段分两种,一是Field,即文本型字段,另一个是日期型字段DateField。这个包中关键需要理解的是Field中字段存储方式的不同,这在上一篇中已列表提到,下面我们可以参见一下其详细的类图:

5. 索引管理包org.apache.lucene.index

索引包是整个系统核心,全文检索的的根本就为每个切出来的词建索引,查询时就只需要遍历索引,而不需要去正文中遍历,从而极大的提高检索效率,索引建设的质量关键整个系统的质量。Lucene的索引树是非常优质高效的,具体的索引树细节,将在后续章节中重要探讨。

在这个包中,主要学习IndexWriter和IndexReader这个类。

通过上一篇的初步应用可知,全文检索库的初始化和记录加载均需要通过该类来完成。

初始化全文库的语句为:

IndexWriter indexWriter = new IndexWriter(“全文库的目录位置”,new StandardAnalyzer(),true);

记录加载的语句为:indexWriter.addDocument(doc);

IndexWriter主要用于写库,当需要读取库内容时,就需要用到IndexReader这个类了。

6. 查询分析包org.apache.lucene.queryParser和检索包org.apache.lucene.search

通过查询分析器(queryParser)解析后,将返回一个查询对象(query),根据查询对象就可进行检索了。上图描述了query对象的生成,下图描述了查询结果集(Hits)的生成。

7. 存储包org.apache.lucene.store

一些底层的文件I/O操作。

8. 工具包org.apache.lucene.util

该包中包括4个工具类。

9. 总结

通过对Lucene源码包的分析,我们可以初步认识到Lucene的核心类包主要有3个:

l org.apache.lucene.analysis

l org.apache.lucene.index

l org.apache.lucene.search

其中org.apache.lucene.analysis 主要用于切分词,切分词的工作由Analyzer的扩展类来实现,Lucene自带了StandardAnalyzer类,我们可以参照该写出自己的切词分析器类,如中文分析器等。

org.apache.lucene.index主要提供库的读写接口,通过该包可以创建库、添加删除记录及读取记录等。

org.apache.lucene.search主要提供了检索接口,通过该包,我们可以输入条件,得到查询结果集,与org.apache.lucene.queryParser包配合还可以自定义的查询规则,像google一样支持查询条件间的与、或、非、属于等复合查询。

参考资料

1. http://www-igm.univ-mlv.fr/~dr/XPOSE2003/lucene/node1.html (按:This article is really good)

3.
From http://www.matrix.org.cn/article/22.html

lucene结构说明

本文定义了Lucene(版本1.3)用到的索引文件的格式。

Jakarta Lucene是用Java写成的,同时有很多团体正在默默的用其他的程序语言来改写它。如果这些新的版本想和Jakarta Lucene兼容,就需要一个与具体语言无关的Lucene索引文件格式。本文正是试图提供一个完整的与语言无关的Jakarta Lucene 1.3索引文件格式的规格定义。

随着Lucene不断发展,本文也应该更新。不同语言写成的Lucene实现版本应当尽力遵守文件格式,也必须产生本文的新版本。

本文同时提供兼容性批注,描述文件格式上与前一版本不同的地方。

定义

Lucene中最基础的概念是索引(index),文档(document),域(field)和项(term)。

索引包含了一个文档的序列。

· 文档是一些域的序列。

· 域是一些项的序列。

· 项就是一个字串。

存在于不同域中的同一个字串被认为是不同的项。因此项实际是用一对字串表示的,第一个字串是域名,第二个是域中的字串。

倒排索引

为了使得基于项的搜索更有效率,索引中项是静态存储的。Lucene的索引属于索引方式中的倒排索引,因为对于一个项这种索引可以列出包含它的文档。这刚好是文档与项自然联系的倒置。

域的类型

Lucene中,域的文本可能以逐字的非倒排的方式存储在索引中。而倒排过的域称为被索引过了。域也可能同时被存储和被索引。

域的文本可能被分解许多项目而被索引,或者就被用作一个项目而被索引。大多数的域是被分解过的,但是有些时候某些标识符域被当做一个项目索引是很有用的。

段(Segment)

Lucene索引可能由多个子索引组成,这些子索引成为段。每一段都是完整独立的索引,能被搜索。索引是这样作成的:

1. 为新加入的文档创建新段。

2. 合并已经存在的段。

搜索时需要涉及到多个段和/或者多个索引,每一个索引又可能由一些段组成。

文档号(Document Number)

内部的来说,Lucene用一个整形(interger)的文档号来指示文档。第一个被加入到索引中的文档就是0号,顺序加入的文档将得到一个由前一个号码递增而来的号码。

注意文档号是可能改变的,所以在Lucene外部存储这些号码时必须小心。特别的,号码的改变的情况如下:

· 只有段内的号码是相同的,不同段之间不同,因而在一个比段广泛的上下文环境中使用这些号码时,就必须改变它们。标准的技术是根据每一段号码多少为每一段分配一个段号。将段内文档号转换到段外时,加上段号。将某段外的文档号转换到段内时,根据每段中可能的转换后号码范围来判断文档属于那一段,并减调这一段的段号。例如有两个含5个文档的段合并,那么第一段的段号就是0,第二段段号5。第二段中的第三个文档,在段外的号码就是8。

· 文档删除后,连续的号码就出现了间断。这可以通过合并索引来解决,段合并时删除的文档相应也删掉了,新合并而成的段并没有号码间断。

绪论

索引段维护着以下的信息:

· 域集合。包含了索引中用到的所有的域。

· 域值存储表。每一个文档都含有一个“属性-值”对的列表,属性即为域名。这个列表用来存储文档的一些附加信息,如标题,url或者访问数据库的一个ID。在搜索时存储域的集合可以被返回。这个表以文档号标识。

· 项字典。这个字典含有所有文档的所有域中使用过的的项,同时含有使用过它的文档的文档号,以及指向使用频数信息和位置信息的指针。

· 项频数信息。对于项字典中的每个项,这些信息包含含有这个项的文档的总数,以及每个文档中使用的次数。

· 项位置信息。对于项字典中的每个项,都存有在每个文档中出现的各个位置。

· Normalization factors. For each field in each document, a value is stored that is multiplied into the score for hits on that field. 标准化因子。对于文档中的每一个域,存有一个值,用来以后乘以这个这个域的命中数(hits)。

· 被删除的文档信息。这是一个可选文件,用来表明那些文档已经删除了。

接下来的各部分部分详细描述这些信息。

文件的命名(File Naming)

同属于一个段的文件拥有相同的文件名,不同的扩展名。扩展名由以下讨论的各种文件格式确定。

一般来说,一个索引存放一个目录,其所有段都存放在这个目录里,尽管我们不要求您这样做。

基本数据类型(Primitive Types)

Byte

最基本的数据类型就是字节(byte,8位)。文件就是按字节顺序访问的。其它的一些数据类型也定义为字节的序列,文件的格式具有字节意义上的独立性。

UInt32

32位无符号整数,由四个字节组成,高位优先。

UInt32 --> 4

Uint64

64位无符号整数,由八字节组成,高位优先。

UInt64 --> 8

VInt

可变长的正整数类型,每字节的最高位表明还剩多少字节。每字节的低七位表明整数的值。因此单字节的值从0到127,两字节值从128到16,383,等等。

VInt 编码示例

Value
First byte
Second byte
Third byte

0
00000000

1
00000001

2
00000010

...

127
01111111

128
10000000
00000001

129
10000001
00000001

130
10000010
00000001

...

16,383
11111111
01111111


16,384
10000000
10000000
00000001

16,385
10000001
10000000
00000001

...

这种编码提供了一种在高效率解码时压缩数据的方法。

Chars

Lucene输出UNICODE字符序列,使用标准UTF-8编码。

String

Lucene输出由VINT和字符串组成的字串,VINT表示字串长,字符串紧接其后。

String --> VInt, Chars

索引包含的文件(Per-Index Files)

这部分介绍每个索引包含的文件。

Segments文件

索引中活动的段存储在Segments文件中。每个索引只能含有一个这样的文件,名为"segments".这个文件依次列出每个段的名字和每个段的大小。

Segments --> SegCount, SegCount

SegCount, SegSize --> UInt32

SegName --> String

SegName表示该segment的名字,同时作为索引其他文件的前缀。

SegSize是段索引中含有的文档数。

Lock文件

有一些文件用来表示另一个进程在使用索引。

· 如果存在"commit.lock"文件,表示有进程在写"segments"文件和删除无用的段索引文件,或者表示有进程在读"segments"文件和打开某些段的文件。在一个进程在读取"segments"文件段信息后,还没来得及打开所有该段的文件前,这个Lock文件可以防止另一个进程删除这些文件。

· 如果存在"index.lock"文件,表示有进程在向索引中加入文档,或者是从索引中删除文档。这个文件防止很多文件同时修改一个索引。

Deleteable文件

名为"deletetable"的文件包含了索引不再使用的文件的名字,这些文件可能并没有被实际的删除。这种情况只存在与Win32平台下,因为Win32下文件仍打开时并不能删除。

Deleteable --> DelableCount, DelableCount

DelableCount --> UInt32

DelableName --> String

段包含的文件(Per-Segment Files)

剩下的文件是每段中包含的文件,因此由后缀来区分。

域(Field)


域集合信息(Field Info)

所有域名都存储在这个文件的域集合信息中,这个文件以后缀.fnm结尾。

FieldInfos (.fnm) --> FieldsCount, FieldsCount

FieldsCount --> VInt

FieldName --> String

FieldBits --> Byte

目前情况下,FieldBits只有使用低位,对于已索引的域值为1,对未索引的域值为0。

文件中的域根据它们的次序编号。因此域0是文件中的第一个域,域1是接下来的,等等。这个和文档号的编号方式相同。


域值存储表(Stored Fields)

域值存储表使用两个文件表示:

1. 域索引(.fdx文件)。

如下,对于每个文档这个文件包含指向域值的指针:

FieldIndex (.fdx) --> SegSize

FieldValuesPosition --> Uint64

FieldValuesPosition指示的是某一文档的某域的域值在域值文件中的位置。因为域值文件含有定长的数据信息,因而很容易随机访问。在域值文件中,文档n的域值信息就存在n*8位置处(The position of document n's field data is the Uint64 at n*8 in this file.)。

2. 域值(.fdt文件)。

如下,每个文档的域值信息包含:

FieldData (.fdt) --> SegSize

DocFieldData --> FieldCount, FieldCount

FieldCount --> VInt

FieldNum --> VInt

Bits --> Byte

Value --> String

目前情况下,Bits只有低位被使用,值为1表示域名被分解过,值为0表示未分解过。

项字典(Term Dictionary)

项字典用以下两个文件表示:

1. 项信息(.tis文件)。

TermInfoFile (.tis)--> TermCount, TermInfos

TermCount --> UInt32

TermInfos --> TermCount

TermInfo -->

Term -->

Suffix --> String

PrefixLength, DocFreq, FreqDelta, ProxDelta
--> VInt

项信息按项排序。项信息排序时先按项所属的域的文字顺序排序,然后按照项的字串的文字顺序排序。

项的字前缀往往是共同的,与字的后缀组成字。PrefixLength变量就是表示与前一项相同的前缀的字数。因此,如果前一个项的字是"bone",后一个是"boy"的话,PrefixLength值为2,Suffix值为"y"。

FieldNum指明了项属于的域号,而域名存储在.fdt文件中。

DocFreg表示的是含有该项的文档的数量。

FreqDelta指明了项所属TermFreq变量在.frq文件中的位置。详细的说,就是指相对于前一个项的数据的位置偏移量(或者是0,表示文件中第一个项)。

ProxDelta指明了项所属的TermPosition变量在.prx文件中的位置。详细的说,就是指相对于前一个项的数据的位置偏移量(或者是0,表示文件中第一个项)。

2. 项信息索引(.tii文件)。

每个项信息索引文件包含.tis文件中的128个条目,依照条目在.tis文件中的顺序。这样设计是为了一次将索引信息读入内存能,然后使用它来随机的访问.tis文件。

这个文件的结构和.tis文件非常类似,只在每个条目记录上增加了一个变量IndexDelta。

TermInfoIndex (.tii)--> IndexTermCount, TermIndices

IndexTermCount --> UInt32

TermIndices --> IndexTermCount

IndexDelta --> VInt

IndexDelta表示该项的TermInfo变量值在.tis文件中的位置。详细的讲,就是指相对于前一个条目的偏移量(或者是0,对于文件中第一个项)。

项频数(Frequencies)

.frq文件包含每一项的文档的列表,还有该项在对应文档中出现的频数。

FreqFile (.frq) --> TermCount

TermFreqs --> DocFreq

TermFreq --> DocDelta, Freq?

DocDelta,Freq --> VInt

TermFreqs序列按照项来排序(依据于.tis文件中的项,即项是隐含存在的)。

TermFreq元组按照文档号升序排列。

DocDelta决定了文档号和频数。详细的说,DocDelta/2表示相对于前一文档号的偏移量(或者是0,表示这是TermFreqs里面的第一项)。当DocDelta是奇数时表示在该文档中频数为1,当DocDelta是偶数时,另一个VInt(Freq)就表示在该文档中出现的频数。

例如,假设某一项在文档7中出现一次,在文档11中出现了3次,在TermFreqs中就存在如下的VInts序列:

15, 22, 3

项位置(Position)

.prx文件包含了某文档中某项出现的位置信息的列表。

ProxFile (.prx) --> TermCount

TermPositions --> DocFreq

Positions --> Freq

PositionDelta --> VInt

TermPositions按照项来排序(依据于.tis文件中的项,即项是隐含存在的)。

Positions元组按照文档号升序排列。

PositionDelta是相对于前一个出现位置的偏移位置(或者为0,表示这是第一次在这个文档中出现)。

例如,假设某一项在某文档第4项出现,在另一个文档中第5项和第9项出现,将存在如下的VInt序列:

4, 5, 4

标准化因子(Normalization Factor)

.nrm文件包含了每个文档的标准化因子,标准化因子用来以后乘以这个这个域的命中数。

Norms (.nrm) --> SegSize

每个字节记录一个浮点数。位0-2包含了3位的尾数部分,位3-8包含了5位的指数部分。

按如下规则可将这些字节转换为IEEE标准单精度浮点数:

1. 如果该字节是0,就是浮点0;

2. 否则,设置新浮点数的标志位为0;

3. 将字节中的指数加上48后作为新的浮点数的指数;

4. 将字节中的尾数映射到新浮点数尾数的高3位;并且

5. 设置新浮点数尾数的低21位为0。

被删除的文档(Deleted Document)

.del文件是可选的,只有在某段中存在删除操作后才存在:

Deletions (.del) --> ByteCount,BitCount,Bits

ByteSize,BitCount --> Uint32

Bits --> ByteCount

ByteCount表示的是Bits列表中Byte的数量。典型的,它等于(SegSize/8)+1。

BitCount表示Bits列表中多少个已经被设置过了。

Bits列表包含了一些位(bit),顺序表示一个文档。当对应于文档号的位被设置了,就标志着这个文档已经被删除了。位的顺序是从低到高。因此,如果Bits包含两个字节,0x00和0x02,那么表示文档9已经删除了。

局限性(Limitations)

在以上的文件格式中,好几处都有限制项和文档的最大个数为32位数的极限,即接近于40亿。今天看来,这不会造成问题,但是,长远的看,可能造成问题。因此,这些极限应该或者换为UInt64类型的值,或者更好的,换为VInt类型的值(VInt值没有上限)。

有两处地方的代码要求必须是定长的值,他们是:

1. FieldValuesPosition变量(存储于域索引文件中,.fdx文件)。它已经是一个UInt64型,所以不会有问题。

2. TermCount变量(存储于项信息文件中,.tis文件)。这是最后输出到文件中的,但是最先被读取,因此是存储于文件的最前端 。索引代码先在这里写入一个0值,然后在其他文件输出完毕后覆盖这个值。所以无论它存储在什么地方,它都必须是一个定长的值,它应该被变成UInt64型。

除此之外,所有的UInt值都可以换成VInt型以去掉限制。



<< Home

This page is powered by Blogger. Isn't yours?