桃花雪

1. 1.总述  IndexSearch全过程源码分析--->生成weight树  
2. IndexSearch ---> search(createWeight(query), filter, n, sort)  
3.     |--createWeight(query)  |实际为生成Weight树  
4.          |--return query.weight(this);  
5.       
6. 2.创建weight树总过程  
7. query.weight(this)  
8.     |--Query query = searcher.rewrite(this);  |重新解析Query，将Query生成为单个可供直接查询的Query  
9.     |--Weight weight = query.createWeight(searcher);  
10.     |--float sum = weight.sumOfSquaredWeights();  |计算sum分值  
11.     |--float norm = getSimilarity(searcher).queryNorm(sum); |获取标准因子  
12.     |--weight.normalize(norm);   |标准化  
13.     |--return weight;  |返回weight权值树  
14.   
15. 3.重写Query对象，生成Query树  
16. IndexSearcher.rewrite(Query original) |重写Query对象，主要实现拆分  
17.     |--for (Query rewrittenQuery = query.rewrite(reader); rewrittenQuery != query; rewrittenQuery = query.rewrite(reader)) |重写直至不能再拆分  
18.          |--query = rewrittenQuery;  
19.                 |--eg1:BooleanQuery.rewrite(reader) 实现  
20.                      |--for (int i = 0 ; i < clauses.size(); i++)  
21.                                         |--Query query = c.getQuery().rewrite(reader);   ｜重写query对象，重复写的过程，最后都生成BooleanQuery对象  
22.                                         |--clone.clauses.set(i, new BooleanClause(query, c.getOccur()));  |合成新的BooleanQuery对象  
23.                 |--eg2:MultiTermQuery.rewrite(reader) 实现  
24.                      ｜--rewriteMethod.rewrite(reader, this);  
25.                                 |--ConstantScoreFilterRewrite.rewrite(reader)   |将所有Term当成一个Term处理  
26.                                         |--Query result = new ConstantScoreQuery(new MultiTermQueryWrapperFilter(query));  
27.                                 |--result.setBoost(query.getBoost());  
28.                         |--ScoringBooleanQueryRewrite.rewrite(reader)   |将Term分离出来，风险在于350Term的限制值  
29.                               |--ConstantScoreBooleanQueryRewrite  
30.                                     |--result.add(tq, BooleanClause.Occur.SHOULD);  |逐一分离Term,生成Boolean查询  
31.                       
32.                                 |--ConstantScoreAutoRewrite.rewrite(reader)     |结合上述二者，自动选择，以term < 350 为界，进行选择  
33.                                         |--FilteredTermEnum enumerator = query.getEnum(reader);    |根据需要改变的query生成枚举器  
34.                                         |--Term t = enumerator.term();              |此时含IO操作?  
35.                                         |--Iterator it = pendingTerms.iterator();  
36.                                  |--BooleanQuery bq = new BooleanQuery(true);  
37.                                  |--while(it.hasNext())   |逐个循环，生成term  
38.                                     |--TermQuery tq = new TermQuery((Term) it.next());  
39.                                     |--bq.add(tq, BooleanClause.Occur.SHOULD);       
40.                              |--Query result = new ConstantScoreQuery(new QueryWrapperFilter(bq));  
41.                              |--result.setBoost(query.getBoost());          |设置分值  
42.                              |--query.incTotalNumberOfTerms(pendingTerms.size());       |增加Term总数  
43.   |--return query;  |返回最终生成的Query树  
44.     
45. 4.不同的Query查询，重写后生成新的Query                              
46. ｜--eg2.1:PrefixQuery.getEnum(reader)  
47.                 |--return new PrefixTermEnum(reader, prefix);  |返回FilterTermEnum的子类  
48.                      |--setEnum(reader.terms(new Term(prefix.field(), prefix.text())));  
49.                             |--if (term != null && termCompare(term))   |比较前缀  
50.                              |--currentTerm = term;  
51.                 |--else next()  
52.                              |--if (actualEnum.next())         |取下一个term,判断是否为当前term的pre  
53.                                         |-- Term term = actualEnum.term();  
54.                                         |-- if (termCompare(term)) {  
55.                                     |--currentTerm = term;  
56. ｜--eg2.2:FuzzyQuery.getEnum(reader)  
57.                 |--return new FuzzyTermEnum(reader, getTerm(), minimumSimilarity, prefixLength);  
58.                       |--this.text = searchTerm.text().substring(realPrefixLength);    |获取前缀及text文本内容  
59.                     |--this.prefix = searchTerm.text().substring(0, realPrefixLength);  
60.                     |--initializeMaxDistances();     |计算初始最大距离  
61.                     |--setEnum(reader.terms(new Term(searchTerm.field(), prefix))); |计算差距值  
62.                       ｜--termCompare(Term term)  
63.                                     |--final String target = term.text().substring(prefix.length());  
64.                                     |--this.similarity = similarity(target);  
65.                                     |--return (similarity > minimumSimilarity);  
66.   
67.   
68. 5.weight.sumOfSquaredWeights() |--计算合值  
69.         |--BooleanWeight  |计算后出现二种情况，Boolean及单个weight树，以BooleanWeight为准进行分析  
70.              |--for (int i = 0 ; i < weights.size(); i++)   |逐一单个的Weight进行计算  
71.                         |--float s = w.sumOfSquaredWeights()  
72.                         |--sum += s;  
73.              |--sum *= getBoost() * getBoost();   
74.                
75.         |--TermWeight  ｜以TermWeight为例  
76.          |--queryWeight = idf * getBoost();     
77.          |--return queryWeight * queryWeight;  |开平方  
78.            
79.   
80. 6.float norm = getSimilarity(searcher).queryNorm(sum);  |计算标准因子，默认为DefaultSimilarity  
81.         |-- return (float)(1.0 / Math.sqrt(sumOfSquaredWeights));  
82.           
83.           
84. 7.weight.normalize(norm);  |标准化norm因子,以BooleanWeight为例  
85.         |--norm *= getBoost();  
86.         |-- for (Iterator iter = weights.iterator(); iter.hasNext();)   
87.              |--w.normalize(norm);  |逐个标准化  
88.           
89.         |--TermWeight.normalize(norm)    |以TermWeight为例  
90.                 |--queryWeight *= queryNorm;  
91.           |--value = queryWeight * idf  
92.           |--实际值value = (idf * getBoost())*(idf * getBoost())*queryNorm*idf; 
    

1.在大规模的应用中，Lucene更适合用于狭义的“搜索”，而不应当负责数据的存储。我们看看Lucene的源代码也可以知道，Document和 Field的存储效率是不够好看的。手机之家的团队也发现了这一点，他们的办法是，用Lucene存放索引，用Memcache + Berkeley DB(Java Edition)负责存储。这样有两个好处，一是减小了Lucene的数据规模，提高了程序的效率；另一方面，这套系统也可以提供某些类似SQL的查询功 能。实际上，Lucene Project自己似乎也注意到了这个问题，在Store中新增了一个db选项，其实也是利用的Berkeley DB。如果仅仅用Lucene存放索引，而不存放Document，并且合理配置，一台机器可以支持几十G甚至上百G的索引。

2.在大规模应用中，Cache是非常重要的。PPT中也提到，可以在程序提供服务之前，进行几次”预热“搜索，填充Searcher的Cache。据我们（银杏搜索）的经验，也可以在应用程序中，再提供针对Document的Cache，这样对性能有较大的改善（同一个JVM内部的Cache，速度更快一些）。Lucene自己似乎也注意到了这个问题，在2.4版本中提供了Cache，并提供了一个LRU Cache实现。 不过据我们测试，在极端情况下，这个Cache可能会突破大小限制，一路膨胀最后吃光内存，甚至从网络上找的许多LRU Cache实现在极端条件下都有可能出现这样的问题（这也是我们百思不得其解的地方：反复检查程序的逻辑都没有问题），最终自己写了一个LRU Cache，并修改多次，目前来看是稳定的。

“开-闭”的意思是：对扩展开放，对修改关闭。（Software entities should be open for extension, but closed for modification. ）

这个原则讲的是，在设计一个模块的时候，应当使这个模块可以在不被修改的前提下被扩展，也就是说，可以在不修改原有代码的情况下改变这个模块的行为。

如何遵循开闭原则？

抽象化是关键。将公共方法属性等抽象化到接口或抽象类中，使得扩展时抽象层不需要改变，从而满足对修改关闭的原则。

2、 里氏代换原则（LSP）

里氏代换原则的意思是，在使用基类的地方，一定可以使用其子类。

里氏代换原则是继承复用的基石。

3、 依赖倒转原则（DIP）

依赖倒转原则的意思是，要依赖于抽象，而不能依赖于具体，也就是我们常说的要针对接口编程，而不能针对实现编程。

4、接口隔离原则（ISP）

接口隔离原则的意思是，使用多个专门的接口比使用单一的总接口要好，也就是说，从一个客户类的角度来讲，一个类对另外一个类的依赖性应该是建立在最小的接口上的。

过于臃肿的接口是对接口的污染。

准确而恰当的划分角色以及角色所对应的接口，是面向对象设计的一个重要的组成部分。

5、组合/聚合复用原则（CARP，或合成复用原则CRP）

合成复用原则是指在一个新的对象里面使用一些已有的对象，使之成为新对象的一部分；新的对象通过向这些对象的委派达到复用已有功能的目的。

6、 迪米特法则（LoD）

迪米特法则又叫最少知识原则（Least Knowledge Principle，LKP），意思是说，一个对象应该对其他对象有尽可能少的了解，也就是只能跟直接对象通信，“不能跟陌生人说话”。

可考虑将聚集索引用于：

• 包含数量有限的唯一值的列，如 state 列只包含 50 个唯一的州代码。
• 使用下列运算符返回一个范围值的查询：BETWEEN、>、>=、< 和 <=。
• 返回大结果集的查询。
  
  索引是在数据库表或者视图上创建的对象，目的是为了加快对表或视图的查询的速度
  
  按照存储方式分为：聚集与非聚集索引
  按照维护与管理索引角度分为：唯一索引、复合索引和系统自动创建的索引
  
  索引的结构是由：根节点--->非叶节点--->非叶节点--->叶节点
  
  
  1、聚集索引:表中存储的数据按照索引的顺序存储,检索效率比普通索引高,但对数据新增/修改/删除的影响比较大
  特点：
  　
  　 (1) 一个表可以最多可以创建249个索引
  　 (2) 先建聚集索引才能创建非聚集索引
      (3) 非聚集索引数据与索引不同序
      (4) 数据与索引在不同位置
      (5) 索引在叶节点上存储,在叶节点上有一个＂指针＂直接指向要查询的数据区域
      (6) 数据不会根据索引键的顺序重新排列数据
     
  　创建聚集索引的语法：
     create CLUSTERED INDEX idximpID ON EMP(empID)
  ２、非聚集索引:不影响表中的数据存储顺序,检索效率比聚集索引低,对数据新增/修改/删除的影响很少
  特点：
     (1) 无索引，数据无序
     (2) 有索引，数据与索引同序
     (3) 数据会根据索引键的顺序重新排列数据
     (4) 一个表可以有多个非聚集索引
     (5) 叶节点的指针指向的数据也在同一位置存储
  语法：
  create NONCLUSTERED INDEX idxempID on emp(empID)
  ３、惟一索引：惟一索引可以确保索引列不包含重复的值.
  可以用多个列，但是索引可以确保索引列中每个值组合都是唯一的
  姓   名
  李   二
  张   三
  王   五
  语法： create unique index idxempid on emp(姓，名)也也是非聚集索引

4、复合索引：如果在两上以上的列上创建一个索引，则称为复合索引。
那么，不可能有两行的姓和名是重复的
语法：
create index indxfullname on addressbook(firstname,lastname)

5、系统自建的索引:在使用T_sql语句创建表的时候使用PRIMARY KEY或UNIQUE约束时，会在表上自动创建一个惟一索引
自动创建的索引是无法删除的
语法：
create table ABc
( empID int primary key,
   firstname varchar(50)UNIQUE,
   lastname   varchar(50)UNIQUE,
)
这样的结果就出来了三个索引，但只有一个聚集索引（建表时primary Key表示建了聚集索引 ）


实验的流程：
1、先创建一个表，然后查看一下他的占用资源情况及select * from 表
     看一下排序
2、然后创建索引，在观看一下占用资源的情况，及排序情况，看看聚集与非聚集的排序是
　　否用变化
　答案是：聚集的有变化，非聚集的排序与未创建索引之前一样

•   
•   
•   

• 聚集索引和非聚集索引的区别(sql server索引结构及其使用)

  一、深入浅出理解索引结构
  
  　　实际上，您可以把索引理解为一种特殊的目录。微软的SQL SERVER提供了两种索引：聚集索引（clustered index，也称聚类索引、簇集索引）和非聚集索引（nonclustered index，也称非聚类索引、非簇集索引）。下面，我们举例来说明一下聚集索引和非聚集索引的区别：
  　　其实，我们的汉语字典的正文本身就是一个聚集索引。比如，我们要查“安”字，就会很自然地翻开字典的前几页，因为“安”的拼音是“an”，而按照拼音 排序汉字的字典是以英文字母“a”开头并以“z”结尾的，那么“安”字就自然地排在字典的前部。如果您翻完了所有以“a”开头的部分仍然找不到这个字，那 么就说明您的字典中没有这个字；同样的，如果查“张”字，那您也会将您的字典翻到最后部分，因为“张”的拼音是“zhang”。也就是说，字典的正文部分 本身就是一个目录，您不需要再去查其他目录来找到您需要找的内容。我们把这种正文内容本身就是一种按照一定规则排列的目录称为“聚集索引”。
  　　如果您认识某个字，您可以快速地从自动中查到这个字。但您也可能会遇到您不认识的字，不知道它的发音，这时候，您就不能按照刚才的方法找到您要查的 字，而需要去根据“偏旁部首”查到您要找的字，然后根据这个字后的页码直接翻到某页来找到您要找的字。但您结合“部首目录”和“检字表”而查到的字的排序 并不是真正的正文的排序方法，比如您查“张”字，我们可以看到在查部首之后的检字表中“张”的页码是672页，检字表中“张”的上面是“驰”字，但页码却 是63页，“张”的下面是“弩”字，页面是390页。很显然，这些字并不是真正的分别位于“张”字的上下方，现在您看到的连续的“驰、张、弩”三字实际上 就是他们在非聚集索引中的排序，是字典正文中的字在非聚集索引中的映射。我们可以通过这种方式来找到您所需要的字，但它需要两个过程，先找到目录中的结 果，然后再翻到您所需要的页码。我们把这种目录纯粹是目录，正文纯粹是正文的排序方式称为“非聚集索引”。
  　　通过以上例子，我们可以理解到什么是“聚集索引”和“非聚集索引”。进一步引申一下，我们可以很容易的理解：每个表只能有一个聚集索引，因为目录只能按照一种方法进行排序。
  
  二、何时使用聚集索引或非聚集索引
  
  下面的表总结了何时使用聚集索引或非聚集索引（很重要）：

  动作描述	使用聚集索引	使用非聚集索引
  列经常被分组排序	应	应
  返回某范围内的数据	应	不应
  一个或极少不同值	不应	不应
  小数目的不同值	应	不应
  大数目的不同值	不应	应
  频繁更新的列	不应	应
  外键列	应	应
  主键列	应	应
  频繁修改索引列	不应	应

  　　事实上，我们可以通过前面聚集索引和非聚集索引的定义的例子来理解上表。如：返回某范围内的数据一项。比如您的某个表有一个时间列，恰 好您把聚合索引建立在了该列，这时您查询2004年1月1日至2004年10月1日之间的全部数据时，这个速度就将是很快的，因为您的这本字典正文是按日 期进行排序的，聚类索引只需要找到要检索的所有数据中的开头和结尾数据即可；而不像非聚集索引，必须先查到目录中查到每一项数据对应的页码，然后再根据页 码查到具体内容。
  
  三、结合实际，谈索引使用的误区
  
  　　理论的目的是应用。虽然我们刚才列出了何时应使用聚集索引或非聚集索引，但在实践中以上规则却很容易被忽视或不能根据实际情况进行综合分析。下面我们将根据在实践中遇到的实际问题来谈一下索引使用的误区，以便于大家掌握索引建立的方法。
  
  1、主键就是聚集索引
  　　这种想法笔者认为是极端错误的，是对聚集索引的一种浪费。虽然SQL SERVER默认是在主键上建立聚集索引的。
  　　通常，我们会在每个表中都建立一个ID列，以区分每条数据，并且这个ID列是自动增大的，步长一般为1。我们的这个办公自动化的实例中的列Gid就是 如此。此时，如果我们将这个列设为主键，SQL SERVER会将此列默认为聚集索引。这样做有好处，就是可以让您的数据在数据库中按照ID进行物理排序，但笔者认为这样做意义不大。
  　　显而易见，聚集索引的优势是很明显的，而每个表中只能有一个聚集索引的规则，这使得聚集索引变得更加珍贵。
  　　从我们前面谈到的聚集索引的定义我们可以看出，使用聚集索引的最大好处就是能够根据查询要求，迅速缩小查询范围，避免全表扫描。在实际应用中，因为 ID号是自动生成的，我们并不知道每条记录的ID号，所以我们很难在实践中用ID号来进行查询。这就使让ID号这个主键作为聚集索引成为一种资源浪费。其 次，让每个ID号都不同的字段作为聚集索引也不符合“大数目的不同值情况下不应建立聚合索引”规则；当然，这种情况只是针对用户经常修改记录内容，特别是 索引项的时候会负作用，但对于查询速度并没有影响。
  　　在办公自动化系统中，无论是系统首页显示的需要用户签收的文件、会议还是用户进行文件查询等任何情况下进行数据查询都离不开字段的是“日期”还有用户本身的“用户名”。
  　　通常，办公自动化的首页会显示每个用户尚未签收的文件或会议。虽然我们的where语句可以仅仅限制当前用户尚未签收的情况，但如果您的系统已建立了 很长时间，并且数据量很大，那么，每次每个用户打开首页的时候都进行一次全表扫描，这样做意义是不大的，绝大多数的用户1个月前的文件都已经浏览过了，这 样做只能徒增数据库的开销而已。事实上，我们完全可以让用户打开系统首页时，数据库仅仅查询这个用户近3个月来未阅览的文件，通过“日期”这个字段来限制 表扫描，提高查询速度。如果您的办公自动化系统已经建立的2年，那么您的首页显示速度理论上将是原来速度8倍，甚至更快。
  　　在这里之所以提到“理论上”三字，是因为如果您的聚集索引还是盲目地建在ID这个主键上时，您的查询速度是没有这么高的，即使您在“日期”这个字段上 建立的索引（非聚合索引）。下面我们就来看一下在1000万条数据量的情况下各种查询的速度表现（3个月内的数据为25万条）：
  
  （1）仅在主键上建立聚集索引，并且不划分时间段：

  Select gid,fariqi,neibuyonghu,title from tgongwen

  用时：128470毫秒（即：128秒）
  
  （2）在主键上建立聚集索引，在fariq上建立非聚集索引：

  select gid,fariqi,neibuyonghu,title from Tgongwen
  where fariqi> dateadd(day,-90,getdate())

  用时：53763毫秒（54秒）
  
  （3）将聚合索引建立在日期列（fariqi）上：

  select gid,fariqi,neibuyonghu,title from Tgongwen
  where fariqi> dateadd(day,-90,getdate())

  用时：2423毫秒（2秒）
  
  　　虽然每条语句提取出来的都是25万条数据，各种情况的差异却是巨大的，特别是将聚集索引建立在日期列时的差异。事实上，如果您的数据库真的有1000 万容量的话，把主键建立在ID列上，就像以上的第1、2种情况，在网页上的表现就是超时，根本就无法显示。这也是我摒弃ID列作为聚集索引的一个最重要的 因素。得出以上速度的方法是：在各个select语句前加：

  declare @d datetime
  set @d=getdate()

  并在select语句后加：

  select [语句执行花费时间(毫秒)]=datediff(ms,@d,getdate())

  2、只要建立索引就能显著提高查询速度
  　　事实上，我们可以发现上面的例子中，第2、3条语句完全相同，且建立索引的字段也相同；不同的仅是前者在fariqi字段上建立的是非聚合索引，后者 在此字段上建立的是聚合索引，但查询速度却有着天壤之别。所以，并非是在任何字段上简单地建立索引就能提高查询速度。
  　　从建表的语句中，我们可以看到这个有着1000万数据的表中fariqi字段有5003个不同记录。在此字段上建立聚合索引是再合适不过了。在现实 中，我们每天都会发几个文件，这几个文件的发文日期就相同，这完全符合建立聚集索引要求的：“既不能绝大多数都相同，又不能只有极少数相同”的规则。由此 看来，我们建立“适当”的聚合索引对于我们提高查询速度是非常重要的。
  
  3、把所有需要提高查询速度的字段都加进聚集索引，以提高查询速度
  　　上面已经谈到：在进行数据查询时都离不开字段的是“日期”还有用户本身的“用户名”。既然这两个字段都是如此的重要，我们可以把他们合并起来，建立一个复合索引（compound index）。
  　　很多人认为只要把任何字段加进聚集索引，就能提高查询速度，也有人感到迷惑：如果把复合的聚集索引字段分开查询，那么查询速度会减慢吗？带着这个问 题，我们来看一下以下的查询速度（结果集都是25万条数据）：（日期列fariqi首先排在复合聚集索引的起始列，用户名neibuyonghu排在后 列）：

  （1）select gid,fariqi,neibuyonghu,title from Tgongwen where fariqi>''2004-5-5''

  查询速度：2513毫秒

  （2）select gid,fariqi,neibuyonghu,title from Tgongwen 
  　　　　　　　　　　　　where fariqi>''2004-5-5'' and neibuyonghu=''办公室''

  查询速度：2516毫秒

  （3）select gid,fariqi,neibuyonghu,title from Tgongwen where neibuyonghu=''办公室''

  查询速度：60280毫秒
  
  　　从以上试验中，我们可以看到如果仅用聚集索引的起始列作为查询条件和同时用到复合聚集索引的全部列的查询速度是几乎一样的，甚至比用上全部的复合索引 列还要略快（在查询结果集数目一样的情况下）；而如果仅用复合聚集索引的非起始列作为查询条件的话，这个索引是不起任何作用的。当然，语句1、2的查询速 度一样是因为查询的条目数一样，如果复合索引的所有列都用上，而且查询结果少的话，这样就会形成“索引覆盖”，因而性能可以达到最优。同时，请记住：无论 您是否经常使用聚合索引的其他列，但其前导列一定要是使用最频繁的列。
  
  四、其他书上没有的索引使用经验总结
  
  1、用聚合索引比用不是聚合索引的主键速度快
  　　下面是实例语句：（都是提取25万条数据）

  select gid,fariqi,neibuyonghu,reader,title from Tgongwen where fariqi=''2004-9-16''

  使用时间：3326毫秒

  select gid,fariqi,neibuyonghu,reader,title from Tgongwen where gid<=250000

  使用时间：4470毫秒
  
  这里，用聚合索引比用不是聚合索引的主键速度快了近1/4。
  
  2、用聚合索引比用一般的主键作order by时速度快，特别是在小数据量情况下

  select gid,fariqi,neibuyonghu,reader,title from Tgongwen order by fariqi

  用时：12936

  select gid,fariqi,neibuyonghu,reader,title from Tgongwen order by gid

  用时：18843
  
  　　这里，用聚合索引比用一般的主键作order by时，速度快了3/10。事实上，如果数据量很小的话，用聚集索引作为排序列要比使用非聚集索引速度快得明显的多；而数据量如果很大的话，如10万以上，则二者的速度差别不明显。
  
  3、使用聚合索引内的时间段，搜索时间会按数据占整个数据表的百分比成比例减少，而无论聚合索引使用了多少个：

  select gid,fariqi,neibuyonghu,reader,title from Tgongwen where fariqi>''2004-1-1''

  用时：6343毫秒（提取100万条）

  select gid,fariqi,neibuyonghu,reader,title from Tgongwen where fariqi>''2004-6-6''

  用时：3170毫秒（提取50万条）

  select gid,fariqi,neibuyonghu,reader,title from Tgongwen where fariqi=''2004-9-16''

  用时：3326毫秒（和上句的结果一模一样。如果采集的数量一样，那么用大于号和等于号是一样的）

  select gid,fariqi,neibuyonghu,reader,title from Tgongwen 
  　　　　　　　　　　　　where fariqi>''2004-1-1'' and fariqi<''2004-6-6''

  用时：3280毫秒
  
  4、日期列不会因为有分秒的输入而减慢查询速度
  　　下面的例子中，共有100万条数据，2004年1月1日以后的数据有50万条，但只有两个不同的日期，日期精确到日；之前有数据50万条，有5000个不同的日期，日期精确到秒。

  select gid,fariqi,neibuyonghu,reader,title from Tgongwen 
  　　　　　　　　　　where fariqi>''2004-1-1'' order by fariqi

  用时：6390毫秒

  select gid,fariqi,neibuyonghu,reader,title from Tgongwen 
  　　　　　　　　　　　　where fariqi<''2004-1-1'' order by fariqi

  用时：6453毫秒
  
  五、其他注意事项
  
  　　“水可载舟，亦可覆舟”，索引也一样。索引有助于提高检索性能，但过多或不当的索引也会导致系统低效。因为用户在表中每加进一个索引，数据库就要做更多的工作。过多的索引甚至会导致索引碎片。
  　　所以说，我们要建立一个“适当”的索引体系，特别是对聚合索引的创建，更应精益求精，以使您的数据库能得到高性能的发挥。
  　　当然，在实践中，作为一个尽职的数据库管理员，您还要多测试一些方案，找出哪种方案效率最高、最为有效