如何提高SQL语言的查询效率！

如何提高SQL语言的查询效率?
由于SQL是面向结果而不是面向过程的查询语言，所以一般支持SQL语言的大型关系型数据库都使用一个基于查询成本的优化器，为即时查询提供一个最佳的执行策略。对于优化器，输入是一条查询语句，输出是一个执行策略。
    一条SQL查询语句可以有多种执行策略，优化器将估计出全部执行方法中所需时间最少的所谓成本最低的那一种方法。所有优化都是基于用记所使用的查询语句中的where子句，优化器对where子句中的优化主要用搜索参数(Serach Argument)。
    搜索参数的核心思想就是数据库使用表中字段的索引来查询数据，而不必直接查询记录中的数据。
    带有 =、<、<=、>、>= 等操作符的条件语句可以直接使用索引，如下列是搜索参数：
    emp_id = "10001" 或 salary > 3000 或  a =1 and c = 7
    而下列则不是搜索参数：
    salary = emp_salary 或 dep_id != 10 或 salary * 12 >= 3000 或 a=1 or c=7
    应当尽可能提供一些冗余的搜索参数，使优化器有更多的选择余地。请看以下3种方法：
    第一种方法：
    select employee.emp_name,department.dep_name from department,employee where (employee.dep_id = department.dep_id) and (department.dep_code='01') and (employee.dep_code='01');
    它的搜索分析结果如下：
    Estimate 2 I/O operations
    Scan department using primary key
    for rows where dep_code equals '01'
    Estimate getting here 1 times
    Scan employee sequentially
    Estimate getting here 5 times
    第二种方法：
    select employee.emp_name,department.dep_name from department,employee where (employee.dep_id = department.dep_id) and (department.dep_code='01');
    它的搜索分析结果如下：
    Estimate 2 I/O operations
    Scan department using primary key
    for rows where dep_code equals '01'
    Estimate getting here 1 times
    Scan employee sequentially
    Estimate getting here 5 times
    第一种方法与第二种运行效率相同，但第一种方法最好，因为它为优化器提供了更多的选择机会。
    第三种方法：
    select employee.emp_name,department.dep_name from department,employee where (employee.dep_id = department.dep_id) and (employee.dep_code='01');
    这种方法最不好，因为它无法使用索引，也就是无法优化……
使用SQL语句时应注意以下几点：
    1、避免使用不兼容的数据类型。例如，Float和Integer，Char和Varchar，Binary和Long Binary不兼容的。数据类型的不兼容可能使优化器无法执行一些本可以进行的优化操作。例如：
    select emp_name form employee where salary > 3000;
    在此语句中若salary是Float类型的，则优化器很难对其进行优化，因为3000是个整数，我们应在编程时使用3000.0而不要等运行时让DBMS进行转化。
    2、尽量不要使用表达式，因它在编绎时是无法得到的，所以SQL只能使用其平均密度来估计将要命中的记录数。
    3、避免对搜索参数使用其他的数学操作符。如：
       select emp_name from employee where salary * 12 > 3000;
       应改为：
       select emp_name from employee where salary  > 250;
    4、避免使用 != 或 <> 等这样的操作符，因为它会使系统无法使用索引，而只能直接搜索表中的数据。

  目前,几乎所有的应用程序都要和数据库打交道。通过查询数据库可很容易地获得想要的数据。但是,令人不满意的是:某些查询时间长,响应速度慢。究其原因,一是硬件设备(如CPU、磁盘)的存取速度跟不上,内存容量不够大,这需要计算机制造商的努力;另一方面是没有进行查询优化。本文就查询优化问题,谈点实践体会。
分解查询
这种方法是把查询分解执行,根据付出开销的多少来决定如何分解,如何执行。为方便叙述,先给出一个例子。
关系:SUPPLIER(S#,SNAME,CITY) :S(关键字)
PARTS　 (P#,PNAME,SIZE)　    :P(关键字)
PROJECT (J#,JNAME,COLOR)     :J(关键字)
INVENTORY(S#,P#,QO)          :V(关键字)
SUPPLY(S#,J#,P#,QU)          :Y(关键字)
其中,QO:现有数量  QU:要用的数量
这个查询是找出某城市能提供黑色轿车,且供应量大于1000的供应商名单。
1. 一般查询方法
(1) 形成卡氏积 S×P×J×V×Y;
(2) 从卡氏积中选择出满足条件的元组;
(3) 在S.SNAME上投影。
这是个5元查询。当查询涉及到卡氏积时,卡氏积的元组数将组合性增长,这样不仅需要大量的存储空间,而且执行查询时间很长。
2. 优化查询方法
该方法是把查询分解处理。这里介绍两种方法:
(1) 一元子查询提取任一N元查询Q(X1,X2......Xn)被替换为一个一元查询Q1和一个在其后执行的Q2,即Q→(Q1,Q2)。
(2) 化简  Q被替换为两个查询Q1和Q2,Q2在Q1执行后执行,它们只有一个变化,即Q1(X1,X2......Xm), Q2(Xm,Xm+1......Xn)。
例如上例的查询可以分成两个一元查询
SELECT　P#
FROM　P
WHERE　P.PNAME=‘轿车’ AND P.COLOR=‘黑色’
和 SELECT　S#,J#,P#,QO
FROM　Y
WHERE　V.QO>1000
另一部分查询为:
SELECT　S.SNAME
FROM　S,P,J,V,Y
WHERE (S.S#=V.S# AND S.S#=Y.S# AND
　 S.CITY=J.CITY AND P.P#=V.P# AND
　 T.P#=V.P# AND J.J#=Y.J#)
上面例子的查询也很容易化简化为一个涉及(P,V)的查询和在其后执行的涉及(S,J,Y,V)的查询:
SELECT　S.SNAME
FORM　S,J,V,Y
WHERE　S.CITY=J.CITY AND S.S#=Y.S# AND
　 J.J#=Y.J# AND V.QO>1000 AND P.#=Y.P#
AND V.S#=Y.S# AND
　V.P#=(SELECT V.P#
　 FROM　 V,P
WHERE V.P#=P P#AND P.PNAME=‘轿车’ AND　P.COLOR=‘黑色’)
3. 综上所述
    一元子查询提取几乎总会得到好处,因为在关系运算之前尽可能减少关系的体积对减少相应的系统开销起很大的作用;·通常会得到期待的优化结果,但也并不绝对如此。
选择最优存取路径
    在计算查询表达式值时要充分考虑索引、数据的存储分布等存取路径,以进一步提高查询效率。例如,选择字段、连接字段上是否有索引,利用索引和HASHING算法可快速地存取包含索引属性特定值的记录。建立索引,用户可按顺序读文件中的记录,依照接近于物理顺序的顺序读文件中的记录是非常有效的。这种接近的物理顺序读取文件中记录的索引称为聚簇索引。聚簇索引使我们可利用存储块中的记录物理聚簇的优点,加快查询速度。下面具体谈一点实践体会。
    前不久,笔者参加了一个在国内开发的国外数据库应用系统的编程工作。该系统后台使用Oracle 7.3数据库,Oracle的DBMS处理SQL执    行语句的顺序如下:
(1) 根据WHERE子句选择行;
(2) 根据GROUP BY子句对这些行进行聚合;
(3) 对每一分组用组函数计算结果;
(4) 根据HAVING子句选择和排除分组;
(5) 根据ORDER BY子句中的组函数所得的结果对组进行排序。
    这是一个体现查询优化思路的执行顺序,它对查询的性能具有直接影响。一般来说,被WHERE子句滤去的记录越多,查询速度就越快。因为减少了在GROUP BY运算中必须处理的行数量。在这次工作中笔者的体会如下。
1. 尽量避免连接
例如:
    PowerBuilder 5.0数据窗口在选择库表时自动把各个表中的相同属性名(域也相同)连接起来。这种自动连接多数情况下是有益的,但有些情况却需要取消连接。如查询条件为P2000、P3000、P4000的有效区分都为1,这时有两种方法:
(1) WHERE(P2000.有效区分=P3000.有效区分
　 P3000.有效区分=P4000.有效区分
    P2000.有效区分=1
(2) WHERE(P2000.有效区分=1
    P3000.有效区分=1
    P4000.有效区分=1
    第一种方法在自动生成的基础上添加P2000.有效区分=1就可以了,第二种方法先要取消连接,然后再重新写WHERE语句。表面看,第一种方法简单,其实第一种方法大大降低了执行效率,因为它有不必要的连接。所以笔者在这里提醒使用者,不要为了一时省事而降低了系统的效率。
2. 选择最佳的解决方案
    解决同一问题的方法固然很多,但应用中应该选择最佳的解决方法。例如,对某一问题的数据库查询有两种方法,执行结果一样,效率却不同。
    查询要求是:如果在程序运行界面上输入了负责人代码(放到code中),那么将查询P2000表中负责人代码等于code的负责人名;如果没有输入负责人代码,那么查询P2000表中所有负责人名。负责人代码的取值范围是0～9999,两种解决方法分别是:
(1) IF 没有输入负责人代码 THEN
code1=0
code2=9999
ELSE
code1=code2=负责人代码
END IF
执行SQL语句为:
SELECT 负责人名
FROM P2000
WHERE 负责人代码>=:code1 AND负责人代码
　 <=:code2
(2) IF 没有输入负责人代码 THEN
　 执行SQL语句为:
　SELECT 负责人名
FROM P2000
ELSE
code= 负责人代码
执行SQL语句为:
SELECT 负责人代码
FROM P2000
WHERE 负责人代码=:code
END IF
    第一种方法只用了一条SQL语句,第二种方法用了两条SQL语句。在没有输入负责人代码时,第二种方法显然比第一种方法执行效率高,因为它没有限制条件;在输入了负责人代码时,第二种方法仍然比第一种方法效率高,不仅是少了一个限制条件,还因相等运算是最
快的查询运算。分析到这里,读者优劣自明。
    此外,Oracle提供存储过程功能,它是编译好、优化过、且存储在数据库中的SQL语句和控制流语言的集合,如果利用好存储过程,可极大地增强SQL语言的功能、效率和灵活性。
    以上着重从实现的角度讨论了查询优化,实际上要想根本解决查询优化问题,还需从设计上进行优化,如尽量使用大的内存,数据可适度冗余,库结构优化,对于频繁使用的表建立索引,面向对象的数据库设计方法等等。

数据库的查询优化技术(1)
转载
    数据库系统是管理信息系统的核心，基于数据库的联机事务处理（OLTP）以及联机分析处理(OLAP)是银行、企业、政府等部门最为重要的计算机应用之一。从大多数系统的应用实例来看，查询操作在各种数据库操作中所占据的比重最大，而查询操作所基于的SELECT语句在SQL语句中又是代价最大的语句。举例来说，如果数据的量积累到一定的程度，比如一个银行的账户数据库表信息积累到上百万甚至上千万条记录，全表扫描一次往往需要数十分钟，甚至数小时。如果采用比全表扫描更好的查询策略，往往可以使查询时间降为几分钟，由此可见查询优化技术的重要性。 
    笔者在应用项目的实施中发现，许多程序员在利用一些前端数据库开发工具（如PowerBuilder、Delphi等）开发数据库应用程序时，只注重用户界面的华丽，并不重视查询语句的效率问题，导致所开发出来的应用系统效率低下，资源浪费严重。因此，如何设计高效合理的查询语句就显得非常重要。本文以应用实例为基础，结合数据库理论，介绍查询优化技术在现实系统中的运用。 
分析问题 
    许多程序员认为查询优化是DBMS（数据库管理系统）的任务，与程序员所编写的SQL语句关系不大，这是错误的。一个好的查询计划往往可以使程序性能提高数十倍。查询计划是用户所提交的SQL语句的集合，查询规划是经过优化处理之后所产生的语句集合。DBMS处理查询计划的过程是这样的：在做完查询语句的词法、语法检查之后，将语句提交给DBMS的查询优化器，优化器做完代数优化和存取路径的优化之后，由预编译模块对语句进行处理并生成查询规划，然后在合适的时间提交给系统处理执行，最后将执行结果返回给用户。在实际的数据库产品(如Oracle、Sybase等)的高版本中都是采用基于代价的优化方法，这种优化能根据从系统字典表所得到的信息来估计不同的查询规划的代价，然后选择一个较优的规划。虽然现在的数据库产品在查询优化方面已经做得越来越好，但由用户提交的SQL语句是系统优化的基础，很难设想一个原本糟糕的查询计划经过系统的优化之后会变得高效，因此用户所写语句的优劣至关重要。系统所做查询优化我们暂不讨论，下面重点说明改善用户查询计划的解决方案。  
解决问题 
    下面以关系数据库系统Informix为例，介绍改善用户查询计划的方法。 
1．合理使用索引 
    索引是数据库中重要的数据结构，它的根本目的就是为了提高查询效率。现在大多数的数据库产品都采用IBM最先提出的ISAM索引结构。索引的使用要恰到好处，其使用原则如下： 
●在经常进行连接，但是没有指定为外键的列上建立索引，而不经常连接的字段则由优化器自动生成索引。 
●在频繁进行排序或分组（即进行group by或order by操作）的列上建立索引。 
●在条件表达式中经常用到的不同值较多的列上建立检索，在不同值少的列上不要建立索引。比如在雇员表的“性别”列上只有“男”与“女”两个不同值，因此就无必要建立索引。如果建立索引不但不会提高查询效率，反而会严重降低更新速度。 
●如果待排序的列有多个，可以在这些列上建立复合索引（compound index）。 
●使用系统工具。如Informix数据库有一个tbcheck工具，可以在可疑的索引上进行检查。在一些数据库服务器上，索引可能失效或者因为频繁操作而使得读取效率降低，如果一个使用索引的查询不明不白地慢下来，可以试着用tbcheck工具检查索引的完整性，必要时进行修复。另外，当数据库表更新大量数据后，删除并重建索引可以提高查询速度。 
2．避免或简化排序 
应当简化或避免对大型表进行重复的排序。当能够利用索引自动以适当的次序产生输出时，优化器就避免了排序的步骤。以下是一些影响因素： 
●索引中不包括一个或几个待排序的列； 
●group by或order by子句中列的次序与索引的次序不一样； 
●排序的列来自不同的表。 
为了避免不必要的排序，就要正确地增建索引，合理地合并数据库表（尽管有时可能影响表的规范化，但相对于效率的提高是值得的）。如果排序不可避免，那么应当试图简化它，如缩小排序的列的范围等。 
3．消除对大型表行数据的顺序存取 
在嵌套查询中，对表的顺序存取对查询效率可能产生致命的影响。比如采用顺序存取策略，一个嵌套3层的查询，如果每层都查询1000行，那么这个查询就要查询10亿行数据。避免这种情况的主要方法就是对连接的列进行索引。例如，两个表：学生表（学号、姓名、年龄……）和选课表（学号、课程号、成绩）。如果两个表要做连接，就要在“学号”这个连接字段上建立索引。 
还可以使用并集来避免顺序存取。尽管在所有的检查列上都有索引，但某些形式的where子句强迫优化器使用顺序存取。下面的查询将强迫对orders表执行顺序操作： 
SELECT ＊ FROM orders WHERE (customer_num=104 AND order_num>1001) OR order_num=1008 
虽然在customer_num和order_num上建有索引，但是在上面的语句中优化器还是使用顺序存取路径扫描整个表。因为这个语句要检索的是分离的行的集合，所以应该改为如下语句： 
SELECT ＊ FROM orders WHERE customer_num=104 AND order_num>1001 
UNION 
SELECT ＊ FROM orders WHERE order_num=1008 
这样就能利用索引路径处理查询。 
4．避免相关子查询 
一个列的标签同时在主查询和where子句中的查询中出现，那么很可能当主查询中的列值改变之后，子查询必须重新查询一次。查询嵌套层次越多，效率越低，因此应当尽量避免子查询。如果子查询不可避免，那么要在子查询中过滤掉尽可能多的行。 
5．避免困难的正规表达式 
MATCHES和LIKE关键字支持通配符匹配，技术上叫正规表达式。但这种匹配特别耗费时间。例如：SELECT ＊ FROM customer WHERE zipcode LIKE “98_ _ _” 
即使在zipcode字段上建立了索引，在这种情况下也还是采用顺序扫描的方式。如果把语句改为SELECT ＊ FROM customer WHERE zipcode >“98000”，在执行查询时就会利用索引来查询，显然会大大提高速度。 
另外，还要避免非开始的子串。例如语句：SELECT ＊ FROM customer WHERE zipcode[2，3] >“80”，在where子句中采用了非开始子串，因而这个语句也不会使用索引。 

 

6．使用临时表加速查询 
把表的一个子集进行排序并创建临时表，有时能加速查询。它有助于避免多重排序操作，而且在其他方面还能简化优化器的工作。例如： 
SELECT cust.name，rcvbles.balance，……other columns 
FROM cust，rcvbles 
WHERE cust.customer_id = rcvlbes.customer_id 
AND rcvblls.balance>0 
AND cust.postcode>“98000” 
ORDER BY cust.name 
如果这个查询要被执行多次而不止一次，可以把所有未付款的客户找出来放在一个临时文件中，并按客户的名字进行排序： 
SELECT cust.name，rcvbles.balance，……other columns 
FROM cust，rcvbles 
WHERE cust.customer_id = rcvlbes.customer_id 
AND rcvblls.balance>0 
ORDER BY cust.name 
INTO TEMP cust_with_balance 
然后以下面的方式在临时表中查询： 
SELECT ＊ FROM cust_with_balance 
WHERE postcode>“98000” 
临时表中的行要比主表中的行少，而且物理顺序就是所要求的顺序，减少了磁盘I/O，所以查询工作量可以得到大幅减少。 
注意：临时表创建后不会反映主表的修改。在主表中数据频繁修改的情况下，注意不要丢失数据。 
7．用排序来取代非顺序存取 
非顺序磁盘存取是最慢的操作，表现在磁盘存取臂的来回移动。SQL语句隐藏了这一情况，使得我们在写应用程序时很容易写出要求存取大量非顺序页的查询。 
有些时候，用数据库的排序能力来替代非顺序的存取能改进查询。

数据库的查询优化技术(2)
无际
实例分析 
下面我们举一个制造公司的例子来说明如何进行查询优化。制造公司数据库中包括3个表，模式如下所示： 
1．part表 
零件号 零件描述 其他列 
（part_num） （part_desc） （other column） 
102，032 Seageat 30G disk …… 
500，049 Novel 10M network card …… 
…… 
2．vendor表 
厂商号 厂商名 其他列 
（vendor _num） （vendor_name） （other column） 
910，257 Seageat Corp …… 
523，045 IBM Corp …… 
…… 
3．parven表 
零件号 厂商号 零件数量 
（part_num） （vendor_num） （part_amount） 
102，032 910，257 3,450,000 
234，423 321，001 4，000，000 
…… 
下面的查询将在这些表上定期运行，并产生关于所有零件数量的报表： 
SELECT part_desc，vendor_name，part_amount 
FROM part，vendor，parven 
WHERE part.part_num=parven.part_num 
AND parven.vendor_num = vendor.vendor_num 
ORDER BY part.part_num 
如果不建立索引，上述查询代码的开销将十分巨大。为此，我们在零件号和厂商号上建立索引。索引的建立避免了在嵌套中反复扫描。关于表与索引的统计信息如下： 
表 行尺寸 行数量 每页行数量 数据页数量 
（table） (row size) （Row count） （Rows/Pages） （Data Pages） 
part 150 10，000 25 400 
Vendor 150 1，000 25 40 
Parven 13 15，000 300 50 
索引 键尺寸 每页键数量 页面数量 
（Indexes） (Key Size) （Keys/Page) (Leaf Pages） 
part 4 500 20 
Vendor 4 500 2 
Parven 8 250 60 
看起来是个相对简单的3表连接，但是其查询开销是很大的。通过查看系统表可以看到，在part_num上和vendor_num上有簇索引，因此索引是按照物理顺序存放的。parven表没有特定的存放次序。这些表的大小说明从缓冲页中非顺序存取的成功率很小。此语句的优化查询规划是：首先从part中顺序读取400页，然后再对parven表非顺序存取1万次，每次2页（一个索引页、一个数据页），总计2万个磁盘页，最后对vendor表非顺序存取1.5万次，合3万个磁盘页。可以看出在这个索引好的连接上花费的磁盘存取为5.04万次。 
实际上，我们可以通过使用临时表分3个步骤来提高查询效率： 
1．从parven表中按vendor_num的次序读数据： 
SELECT part_num，vendor_num，price 
FROM parven 
ORDER BY vendor_num 
INTO temp pv_by_vn 
这个语句顺序读parven（50页），写一个临时表（50页），并排序。假定排序的开销为200页，总共是300页。 
2．把临时表和vendor表连接，把结果输出到一个临时表，并按part_num排序： 
SELECT pv_by_vn，＊ vendor.vendor_num 
FROM pv_by_vn，vendor 
WHERE pv_by_vn.vendor_num=vendor.vendor_num 
ORDER BY pv_by_vn.part_num 
INTO TMP pvvn_by_pn 
DROP TABLE pv_by_vn 
这个查询读取pv_by_vn(50页)，它通过索引存取vendor表1.5万次，但由于按vendor_num次序排列，实际上只是通过索引顺序地读vendor表（40＋2=42页），输出的表每页约95行，共160页。写并存取这些页引发5＊160=800次的读写，索引共读写892页。 
3．把输出和part连接得到最后的结果： 
SELECT pvvn_by_pn.＊，part.part_desc 
FROM pvvn_by_pn，part 
WHERE pvvn_by_pn.part_num=part.part_num 
DROP TABLE pvvn_by_pn 
这样，查询顺序地读pvvn_by_pn(160页)，通过索引读part表1.5万次，由于建有索引，所以实际上进行1772次磁盘读写，优化比例为30∶1。笔者在Informix Dynamic Sever上做同样的实验，发现在时间耗费上的优化比例为5∶1(如果增加数据量，比例可能会更大)。 
小 结 
20％的代码用去了80％的时间，这是程序设计中的一个著名定律，在数据库应用程序中也同样如此。我们的优化要抓住关键问题，对于数据库应用程序来说，重点在于SQL的执行效率。查询优化的重点环节是使得数据库服务器少从磁盘中读数据以及顺序读页而不是非顺序读页。

转载
SQL语句性能调整原则
石骁騑 
SQL语句性能调整原则
一、问题的提出
在应用系统开发初期，由于开发数据库数据比较少，对于查询SQL语句，复杂视图的的编写等体会不出SQL语句各种写法的性能优劣，但是如果将应用系统提交实际应用后，随着数据库中数据的增加，系统的响应速度就成为目前系统需要解决的最主要的问题之一。系统优化中一个很重要的方面就是SQL语句的优化。对于海量数据，劣质SQL语句和优质SQL语句之间的速度差别可以达到上百倍，可见对于一个系统不是简单地能实现其功能就可，而是要写出高质量的SQL语句，提高系统的可用性。
在多数情况下，Oracle使用索引来更快地遍历表，优化器主要根据定义的索引来提高性能。但是，如果在SQL语句的where子句中写的SQL代码不合理，就会造成优化器删去索引而使用全表扫描，一般就这种SQL语句就是所谓的劣质SQL语句。在编写SQL语句时我们应清楚优化器根据何种原则来删除索引，这有助于写出高性能的SQL语句。
二、SQL语句编写注意问题
下面就某些SQL语句的where子句编写中需要注意的问题作详细介绍。在这些where子句中，即使某些列存在索引，但是由于编写了劣质的SQL，系统在运行该SQL语句时也不能使用该索引，而同样使用全表扫描，这就造成了响应速度的极大降低。
1. IS NULL 与 IS NOT NULL
不能用null作索引，任何包含null值的列都将不会被包含在索引中。即使索引有多列这样的情况下，只要这些列中有一列含有null，该列就会从索引中排除。也就是说如果某列存在空值，即使对该列建索引也不会提高性能。
任何在where子句中使用is null或is not null的语句优化器是不允许使用索引的。
2. 联接列
对于有联接的列，即使最后的联接值为一个静态值，优化器是不会使用索引的。我们一起来看一个例子，假定有一个职工表（employee），对于一个职工的姓和名分成两列存放（FIRST_NAME和LAST_NAME），现在要查询一个叫比尔.克林顿（Bill Cliton）的职工。
下面是一个采用联接查询的SQL语句，
select * from employss
where
first_name||''||last_name ='Beill Cliton';
上面这条语句完全可以查询出是否有Bill Cliton这个员工，但是这里需要注意，系统优化器对基于last_name创建的索引没有使用。
当采用下面这种SQL语句的编写，Oracle系统就可以采用基于last_name创建的索引。
Select * from employee
where
first_name ='Beill' and last_name ='Cliton';
遇到下面这种情况又如何处理呢？如果一个变量（name）中存放着Bill Cliton这个员工的姓名，对于这种情况我们又如何避免全程遍历，使用索引呢？可以使用一个函数，将变量name中的姓和名分开就可以了，但是有一点需要注意，这个函数是不能作用在索引列上。下面是SQL查询脚本：
select * from employee
where
first_name = SUBSTR('&&name',1,INSTR('&&name',' ')-1)
and
last_name = SUBSTR('&&name',INSTR('&&name’,' ')+1)
3. 带通配符（%）的like语句
同样以上面的例子来看这种情况。目前的需求是这样的，要求在职工表中查询名字中包含cliton的人。可以采用如下的查询SQL语句：
select * from employee where last_name like '%cliton%';
这里由于通配符（%）在搜寻词首出现，所以Oracle系统不使用last_name的索引。在很多情况下可能无法避免这种情况，但是一定要心中有底，通配符如此使用会降低查询速度。然而当通配符出现在字符串其他位置时，优化器就能利用索引。在下面的查询中索引得到了使用：
select * from employee where last_name like 'c%';
4. Order by语句
ORDER BY语句决定了Oracle如何将返回的查询结果排序。Order by语句对要排序的列没有什么特别的限制，也可以将函数加入列中（象联接或者附加等）。任何在Order by语句的非索引项或者有计算表达式都将降低查询速度。
仔细检查order by语句以找出非索引项或者表达式，它们会降低性能。解决这个问题的办法就是重写order by语句以使用索引，也可以为所使用的列建立另外一个索引，同时应绝对避免在order by子句中使用表达式。
5. NOT
我们在查询时经常在where子句使用一些逻辑表达式，如大于、小于、等于以及不等于等等，也可以使用and（与）、or（或）以及not（非）。NOT可用来对任何逻辑运算符号取反。下面是一个NOT子句的例子：
... where not (status ='VALID')
如果要使用NOT，则应在取反的短语前面加上括号，并在短语前面加上NOT运算符。NOT运算符包含在另外一个逻辑运算符中，这就是不等于（<>）运算符。换句话说，即使不在查询where子句中显式地加入NOT词，NOT仍在运算符中，见下例：
... where status <>'INVALID';
再看下面这个例子：
select * from employee where  salary<>3000;
对这个查询，可以改写为不使用NOT：
select * from employee where  salary<3000 or salary>3000;
虽然这两种查询的结果一样，但是第二种查询方案会比第一种查询方案更快些。第二种查询允许Oracle对salary列使用索引，而第一种查询则不能使用索引。
6.  IN和EXISTS
有时候会将一列和一系列值相比较。最简单的办法就是在where子句中使用子查询。在where子句中可以使用两种格式的子查询。
第一种格式是使用IN操作符：
... where column in(select * from ... where ...);
第二种格式是使用EXIST操作符：
... where exists (select 'X' from ...where ...);
我相信绝大多数人会使用第一种格式，因为它比较容易编写，而实际上第二种格式要远比第一种格式的效率高。在Oracle中可以几乎将所有的IN操作符子查询改写为使用EXISTS的子查询。
第二种格式中，子查询以‘select 'X'开始。运用EXISTS子句不管子查询从表中抽取什么数据它只查看where子句。这样优化器就不必遍历整个表而仅根据索引就可完成工作（这里假定在where语句中使用的列存在索引）。相对于IN子句来说，EXISTS使用相连子查询，构造起来要比IN子查询困难一些。
通过使用EXIST，Oracle系统会首先检查主查询，然后运行子查询直到它找到第一个匹配项，这就节省了时间。Oracle系统在执行IN子查询时，首先执行子查询，并将获得的结果列表存放在在一个加了索引的临时表中。在执行子查询之前，系统先将主查询挂起，待子查询执行完毕，存放在临时表中以后再执行主查询。这也就是使用EXISTS比使用IN通常查询速度快的原因。
同时应尽可能使用NOT EXISTS来代替NOT IN，尽管二者都使用了NOT（不能使用索引而降低速度），NOT EXISTS要比NOT IN查询效率更高。

●查询速度慢的原因很多，常见如下几种：
1、没有索引或者没有用到索引
2、I/O吞吐量小，形成瓶颈效应。
3、没有创建计算列导致查询不优化或者计算列失效了
4、内存不足
5、网络速度慢
6、查询出的数据量过大
7、锁或者死锁
8、一个服务器同时存在OLTP和OLAP查询
9、返回了不必要的列
10、查询语句不好，没有优化
●可以通过如下方法来优化查询 :
1、把数据、日志、索引放到不同的I/O设备上，增加读取速度，Tempdb应放在RAID0上。数据量（尺寸）越大，提高I/O越重要.
2、纵向、横向分割表，减少表的尺寸
3、升级硬件
4、根据查询条件,建立索引,优化索引、优化访问方式，限制结果集的数据量。注意填充因子要适当。索引应该尽量小，使用字节数小的列建索引好（参照索引的创建）,不要对有限的几个值的字段建单一索引如性别字段
5、提高网速;
6、扩大服务器的内存,Windows 2000和SQL server 2000能支持4-8G的内存。
7、增加服务器CPU个数;
8、如果是使用like进行查询的话，简单的使用index是不行的，但是全文索引，耗空间。
like 'a%' 使用索引
like '%a' 不使用索引
用 like '%a%' 查询时，查询耗时和字段值总长度成正比,所以不能用CHAR类型，而是VARCHAR。对于字段的值很长的建全文索引。
9、DB Server 和APPLication Server 分离；
10、分布式分区视图可用于实现数据库服务器联合体。联合体是一组分开管理的服务器，但它们相互协作分担系统的处理负荷。这种通过分区数据形成数据库服务器联合体的机制能够扩大一组服务器，以支持大型的多层 Web 站点的处理需要。有关更多信息，参见设计联合数据库服务器。（参照SQL帮助文件'分区视图'）
    a、在实现分区视图之前，必须先水平分区表
b、在创建成员表后，在每个成员服务器上定义一个分布式分区视图，并且每个视图具有相同的名称。这样，引用分布式分区视图名的查询可以在任何一个成员服务器上运行。系统操作如同每个成员服务器上都有一个原始表的复本一样，但其实每个服务器上只有一个成员表和一个分布式分区视图。数据的位置对应用程序是透明的。
11、重建索引 DBCC REINDEX ,DBCC INDEXDEFRAG,收缩数据和日志 DBCC SHRINKDB,DBCC SHRINKFILE.
    设置自动收缩日志.
●在T-sql的写法上有很大的讲究，下面列出常见的要点：
13、在查询Select语句中用Where字句限制返回的行数,避免表扫描,如果返回不必要的数据，浪费了服务器的I/O资源，加重了网络的负担降低性能。如果表很大，在表扫描的期间将表锁住，禁止其他的联接访问表,后果严重。
14、SQL的注释申明对执行没有任何影响
15、尽可能不使用光标，它占用大量的资源。如果需要row-by-row地执行，尽量采用非光标技术,如：在客户端执行，用临时表，Table变量，用子查询，用Case语句等等。
16、用Profiler来跟踪查询，得到查询所需的时间，找出SQL的问题所在;用索引优化器优化索引
17、注意UNion和UNion all 的区别。UNION all好
18、注意使用DISTINCT，在没有必要时不要用，它同UNION一样会使查询变慢。重复的记录在查询里是没有问题的
19、查询时不要返回不需要的列
20、用sp_configure 'query governor cost limit'或者SET QUERY_GOVERNOR_COST_LIMIT来限制查询消耗的资源。当评估查询消耗的资源超出限制时，服务器自动取消查询,在查询之前就扼杀掉。SET LOCKTIME设置锁的时间
21、用select top 100 / 10 Percent 来限制用户返回的行数或者SET ROWCOUNT来限制操作的行
22、一般不要用如下的字句: "IS NULL", "<>", "!=", "!>", "!<", "NOT", "NOT EXISTS", "NOT IN", "NOT LIKE",  and "LIKE '%500'"，因为他们不走索引全是表扫描,但是like '500%'走索引。也不要在WHere字句中的列名加函数，如Convert，substring等,如果必须用函数的时候，创建计算列再创建索引来替代.还可以变通写法：WHERE SUBSTRING(firstname,1,1) = 'm'改为WHERE firstname like 'm%'（索引扫描），一定要将函数和列名分开。并且索引不能建得太多和太大。NOT IN会多次扫描表，使用EXISTS、NOT EXISTS ，IN , LEFT OUTER JOIN 来替代，特别是左连接,而Exists比IN更快，最慢的是NOT操作
23、使用Query Analyzer，查看SQL语句的查询计划和评估分析是否是优化的SQL。
24、如果使用了IN或者OR等时发现查询没有走索引，使用显示申明指定索引：
    SELECT * FROM table (INDEX = IX_ProcessID) WHERE processid IN (8,32,45)
25、将需要查询的结果预先计算好放在表中，查询的时候再SELECT
26、MIN() 和 MAX()能使用到合适的索引
27、数据库有一个原则是代码离数据越近越好，所以优先选择Default,依次为Rules,triggers, a constraint.
28、如果要插入大的二进制值到Image列，使用存储过程，千万不要用内嵌INsert来插入(不知JAVA是否)。因为这样应用程序首先将二进制值转换成字符串（尺寸是它的两倍），服务器受到字符后又将他转换成二进制值.存储过程就没有这些动作。
29、Between比IN速度更快,Between能够很快地根据索引找到范围。
30、在必要是对全局或者局部临时表创建索引
31、不要建没有作用的事物例如产生报表时，浪费资源
32、用OR的字句可以分解成多个查询，并且通过UNION 连接多个查询。他们的速度只同是否使用到索引有关,如果查询需要用到联合索引，用UNION all执行的效率更高.多个OR的字句没有用到索引，改写成UNION的形式再试图与索引匹配
33、尽量少用视图，它的效率低。对视图操作比直接对表操作慢,可以用stored procedure来代替她。特别的是不要用视图嵌套,嵌套视图增加了寻找原始资料的难度。
34、没有必要时不要用DISTINCT和ORDER BY，这些动作可以改在客户端执行。它们增加了额外的开销
35、在IN后面值的列表中，将出现最频繁的值放在最前面，出现得最少的放在最后面
36、当用SELECT INTO时，它会锁住系统表，阻塞其他的连接的存取。创建临时表时用显示申明语句，而不是select INTO.
37、一般在GROUP BY 个HAVING字句之前就能剔除多余的行，所以尽量不要用它们来做剔除行的工作。他们的执行顺序应该如下最优：select 的Where字句选择所有合适的行，Group By用来分组个统计行，Having字句用来剔除多余的分组。这样Group By 个Having的开销小，查询快.对于大的数据行进行分组和Having十分消耗资源
38、对单个表检索数据时，不要使用指向多个表的视图，直接从表检索或者仅仅包含这个表的视图上读，否则增加了不必要的开销,查询受到干扰.
39、如果有使用'%m%'的查询，使用FULL-TEXT searchers，能加快速度.
40、如果Group BY的目的不包括计算，只是分组，那么用Distinct更快
41、一次更新多条记录比分多次更新每次一条快,就是说批处理好
42、少用临时表，尽量用结果集和Table类性的变量来代替它,Table 类型的变量比临时表好
43、在SQL2000下，计算字段是可以索引的，需要满足的条件如下：
a、计算字段的表达是确定的
b、不能用在TEXT,Ntext，Image数据类型
c、必须配制如下选项
ANSI_NULLS = ON, ANSI_PADDINGS = ON, ANSI_WARNINGS = ON, ARITHABORT = ON, CONCAT_NULL_YIELDS_NULL = ON, QUOTED_IDENTIFIER = ON, NUMERIC_ROUNDABORT = OFF.
44、尽量将数据的处理工作放在服务器上，减少网络的开销，如使用存储过程。以前由于SQL SERVER对复杂的数学计算不支持，所以不得不将这个工作放在其他的层上而增加网络的开销。SQL2000支持UDFs,现在支持复杂的数学计算，函数的返回值不要太大，这样的开销很大。用户自定义函数象光标一样执行的消耗大量的资源，如果返回大的结果采用存储过程
45、不要在一句话里再三的使用相同的函数，浪费资源,将结果放在变量里再调用更快
46、SELECT COUNT(*)的效率教低，尽量变通他的写法，而EXISTS快.
47、当服务器的内存够多时，配制线程数量 = 最大连接数+5，这样能发挥最大的效率；
否则使用 配制线程数量<最大连接数启用SQL SERVER的线程池来解决,如果还是
数量 = 最大连接数+5严重的损害服务器的性能。
48、按照一定的次序来访问你的表。如果你先锁住表A，再锁住表B，那么在所有的存储过程中都要按照这个顺序来锁定它们。如果你（不经意的）某个存储过程中先锁定表B，再锁定表A，这可能就会导致一个死锁。如果锁定顺序没有被预先详细的设计好，死锁是不太容易被发现的
49、通过SQL Server Performance Monitor监视相应硬件的负载
Memory: Page Faults / sec计数器
如果该值偶尔走高，表明当时有线程竞争内存。如果持续很高，则内存可能是瓶颈。Process: Working Set计数器
SQL Server的该参数应该非常接近分配给SQL Server的内存值。在SQL Server设定中，如果将"set working set size"置为0, 则Windows NT会决定SQL Server的工作集的大小。如果将"set working set size"置为1，则强制工作集大小为SQLServer的分配内存大小。一般情况下，最好不要改变"set working set size"的缺省值。
Process:%Processor Time计数器
　　如果该参数值持续超过95%，表明瓶颈是CPU。可以考虑增加一个处理器或换一个更快的处理器。
Processor:%Privileged Time计数器
如果该参数值和"Physical Disk"参数值一直很高，表明I/O有问题。可考虑更换更快的硬盘系统。另外设置Tempdb in RAM，减低"max async IO"，"max lazy writer IO"等措施都会降低该值。
Processor:%User Time计数器　　
　　表示耗费CPU的数据库操作，如排序，执行aggregate functions等。如果该值很高，可考虑增加索引，尽量使用简单的表联接，水平分割大表格等方法来降低该值。
Physical Disk:Avg.Disk Queue Length计数器
该值应不超过磁盘数的1.5~2倍。要提高性能，可增加磁盘。
　　注意：一个Raid Disk实际有多个磁盘。
SQLServer:Cache Hit Ratio计数器
该值越高越好。如果持续低于80%，应考虑增加内存。 注意该参数值是从SQL Server启动后，就一直累加记数，所以运行经过一段时间后，该值将不能反映系统当前值。