oracle-索引
索引，为了提高查询速率//作用类似“书的目录”
索引的结果一般为二叉树，也有位图索引。
建立PK时，自动为PK建一个索引
一旦建立了索引， Oracle就自动地维护索引。
创建索引时，下列准则将帮助用户做出决定：
1) 索引应该在SQL语句的"where"或"and"部分涉及的表列(也称谓词)被建立
2)用户应该索引具有一定范围的表列，假如表中列的值占该表中行的2 0 %以上，该表列不适合于一个索引。
3)单列索引(建立在单一表列上)或复合索引
使用注意事项：
1，避免改变索引列的类型.
当比较不同数据类型的数据时, ORACLE自动对列进行简单的类型转换. 优先转换数值类型到字符类型.
SELECT … FROM EMP WHERE TO_NUMBER(EMP_TYPE)=123
因为内部发生的类型转换, 这个索引将不会被用到!
2，需要当心的WHERE子句
‘!=' ，'+'数学函数，‘||'是字符函数. 就象其他函数那样, 索引不会被用到!
3，假如一定要/*建立基于函数的索引*/
CREATE INDEX EMP_I ON EMP (UPPER(ename)); /*建立基于函数的索引*/
SELECT * FROM emp WHERE UPPER(ename) = ‘BLACKSNAIL'; /*将使用索引*/
4，怎样监控无用的索引
Oracle 9i以上，可以监控索引的使用情况，假如一段时间内没有使用的索引，一般就是无用的索引 语法为：
开始监控：alter index index_name monitoring usage;
检查使用状态：select * from v$object_usage;
停止监控：alter index index_name nomonitoring usage;
sysdate-to_date//以天数为单位
日期格式：2009-5-22 17:10:13
select sysdate, to_date('2009-5-21 17','yyyy-mm-dd hh24:mi:ss') chae from dual//yyyy-mm-dd hh24:mi:ss最好固定
select to_char(sysdate,'YYYY/MM/DD') ,to_char(sysdate,'YYYY-MM/DD HH24:MI:SS') from dual
2009/05/22【】2009-05/22 17:13:18
系统自带的表
nls_session_parameters
指定默认格式：ALTER SESSION SET NLS_DATE_FORMAT = 'MMDDYY';
daul
索引基于二叉树（已排序），不易修改
触发器：特殊的存储过程，当满足条件时自动执行。
sql是面向结果而不是面向过程的查询语言
速度慢可能是：
1、有事务正在运行，在某中程度上对表资源加了锁
2、服务器进程在忙
从软件的角度：
1、根据查询的条件建立相应的索引
2、考虑使用数据仓库
基于查询成本的优化器，一条sql查询语句可以有多种执行策略，
优化器将估计出全部执行方法中所需时间最少的所谓成本最低的那一种方法
尽量不要使用表达式，因它在编绎时是无法得到的//?????
where salary > 3000;
在此语句中若salary是float类型的，则优化器很难对其进行优化，因为3000是个整数，
我们应在编程时使用3000.0而不要等运行时让dbms进行转化
在非群集索引下，数据在物理上随机存放在数据页上
在群集索引下，数据在物理上按顺序在数据页上，重复值也排列在一起，因而在范
围查找时，可以先找到这个范围的起末点，且只在这个范围内扫描数据页
在date，place，amount上的组合索引
select count(*) from record where date > 19991201 and date < 19991214 and amount > 2000(< 1秒)
select date,sum(amount) from record group by date
select count(*) from record where date > 19990901 and place in (bj,sh)
---- 分析：
---- 这是一个合理的组合索引。它将date作为前导列，使每个sql都可以利用索引，并
且在第一和第三个sql中形成了索引覆盖，因而性能达到了最优
缺省情况下建立的索引是非群集索引
①.有大量重复值、且经常有范围查询 和order by 、group by发生的列，可考虑建立群集索引；
②.经常同时存取多列，且每列都含有重复值可考虑建立组合索引；
③.组合索引要尽量使关键查询形成索引覆盖，其前导列一定是使用最频繁的列。
ORDER BY posi.posilevel asc,dept.deptname asc;
按2个字段排序
索引，
创建递归触发器，声明一个变量来记录个数，当条件满足触发器，声明的变量就自动加一，最后就就会得到要求的记录的个数。
触发器：特殊的存储过程，当满足条件时自动执行
创建存储过程吧，他是在服务器上进行编译，比单个SQL语句来的快
最近在搞SQL，按照某位兄弟发布的ip数据库，写一个Web Services。
建立一个好的索引的确可以将速度提高很多
2007-12-24 13:53速度慢可能是：
1、有事务正在运行，在某中程度上对表资源加了锁
2、服务器进程在忙
从软件的角度：
1、根据查询的条件建立相应的索引
2、考虑使用数据仓库
发表者：smaze
建立一个好的索引的确可以将速度提高很多。
发表者：750906
建全文索引
发表者：silversands
如何提高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、避免使用 != 或 <> 等这样的操作符，因为它会使系统无法使用索引，而只能直接搜索表中的数据。
发表者：ldcr520
如何让你的sql运行得更快(转贴)
---- 人们在使用sql时往往会陷入一个误区，即太关注于所得的结果是否正确，而忽略
了不同的实现方法之间可能存在的性能差异，这种性能差异在大型的或是复杂的数据库
环境中中表现得尤为明显。笔者在工作实践
中发现，不良的sql往往来自于不恰当的索引设计、不充份的连接条件和不可优化的whe
re子句。在对它们进行适当的优化后，其运行速度有了明显地提高！下面我将从这三个
方面分别进行总结：
---- 为了更直观地说明问题，所有实例中的sql运行时间均经过测试，不超过１秒的均
表示为。
---- 测试环境--
---- 主机：hp lh ii
---- 主频：330mhz
---- 内存：128兆
---- 操作系统：operserver5.0.4
----数据库：sybase11.0.3
一、不合理的索引设计
----例：表record有620000行，试看在不同的索引下，下面几个 sql的运行情况：
---- 1.在date上建有一非个群集索引
select count(*) from record where date >
19991201 and date < 19991214and amount >
2000 (25秒)
select date,sum(amount) from record group by date
(55秒)
select count(*) from record where date >
19990901 and place in (bj,sh) (27秒)
---- 分析：
----date上有大量的重复值，在非群集索引下，数据在物理上随机存放在数据页上，在
范围查找时，必须执行一次表扫描才能找到这一范围内的全部行。
---- 2.在date上的一个群集索引
select count(*) from record where date >
19991201 and date < 19991214 and amount >
2000
select date,sum(amount) from record group by date
select count(*) from record where date >
19990901 and place in (bj,sh)
---- 分析：
---- 在群集索引下，数据在物理上按顺序在数据页上，重复值也排列在一起，因而在范
围查找时，可以先找到这个范围的起末点，且只在这个范围内扫描数据页，避免了大范
围扫描，提高了查询速度。
---- 3.在place，date，amount上的组合索引
select count(*) from record where date >
19991201 and date < 19991214 and amount >
2000
select date,sum(amount) from record group by date
select count(*) from record where date >
19990901 and place in (bj, sh)
---- 分析：
---- 这是一个不很合理的组合索引，因为它的前导列是place，第一和第二条sql没有引
用place，因此也没有利用上索引；第三个sql使用了place，且引用的所有列都包含在组
合索引中，形成了索引覆盖，所以它的速度是非常快的。
---- 4.在date，place，amount上的组合索引
select count(*) from record where date >
19991201 and date < 19991214 and amount >
2000(< 1秒)
select date,sum(amount) from record group by date
select count(*) from record where date >
19990901 and place in (bj,sh)
---- 分析：
---- 这是一个合理的组合索引。它将date作为前导列，使每个sql都可以利用索引，并
且在第一和第三个sql中形成了索引覆盖，因而性能达到了最优。
---- 5.总结：
---- 缺省情况下建立的索引是非群集索引，但有时它并不是最佳的；合理的索引设计要
建立在对各种查询的分析和预测上。一般来说：
---- ①.有大量重复值、且经常有范围查询
和order by
、group by发生的列，可考虑建立群集索引；
---- ②.经常同时存取多列，且每列都含有重复值可考虑建立组合索引；
---- ③.组合索引要尽量使关键查询形成索引覆盖，其前导列一定是使用最频繁的列。
二、不充份的连接条件：
---- 例：表card有7896行，在card_no上有一个非聚集索引，表account有191122行，在
account_no上有一个非聚集索引，试看在不同的表连接条件下，两个sql的执行情况：
select sum(a.amount) from account a,
card b where a.card_no = b.card_no
---- 将sql改为：
select sum(a.amount) from account a,
card b where a.card_no = b.card_no and a.
account_no=b.account_no
---- 分析：
---- 在第一个连接条件下，最佳查询方案是将account作外层表，card作内层表，利用
card上的索引，其i/o次数可由以下公式估算为：
---- 外层表account上的22541页+=595907次i/o
---- 在第二个连接条件下，最佳查询方案是将card作外层表，account作内层表，利用
account上的索引，其i/o次数可由以下公式估算为：
---- 外层表card上的1944页+= 33528次i/o
---- 可见，只有充份的连接条件，真正的最佳方案才会被执行。
---- 总结：
---- 1.多表操作在被实际执行前，查询优化器会根据连接条件，列出几组可能的连接方
案并从中找出系统开销最小的最佳方案。连接条件要充份考虑带有索引的表、行数多的
表；内外表的选择可由公式：外层表中的匹配行数*内层表中每一次查找的次数确定，乘
积最小为最佳方案。
---- 2.查看执行方案的方法-- 用set showplanon，打开showplan选项，就可以看到连
接顺序、使用何种索引的信息；想看更详细的信息，需用sa角色执行dbcc(3604,310,30
2)。
三、不可优化的where子句
---- 1.例：下列sql条件语句中的列都建有恰当的索引，但执行速度却非常慢：
select * from record where
substring(card_no,1,4)=5378(13秒)
select * from record where
amount/30< 1000
select * from record where
convert(char(10),date,112)=19991201
---- 分析：
---- where子句中对列的任何操作结果都是在sql运行时逐列计算得到的，因此它不得不
进行表搜索，而没有使用该列上面的索引；如果这些结果在查询编译时就能得到，那么
就可以被sql优化器优化，使用索引，避免表搜索，因此将sql重写成下面这样：
select * from record where card_no like
5378%
select * from record where amount
< 1000*30
select * from record where date= 1999/12/01
---- 你会发现sql明显快起来！
---- 2.例：表stuff有200000行，id_no上有非群集索引，请看下面这个sql：
select count(*) from stuff where id_no in(0,1)
---- 分析：
---- where条件中的in在逻辑上相当于or，所以语法分析器会将in (0,1)转化
为id_no =0 or id_no=1来执行。我们期望它会根据每个or子句分别查找，再将结果
相加，这样可以利用id_no上的索引；但实际上,它却采用了"or策略"
，即先取出满足每个or子句的行，存入临时数据库的工作表中，再建立唯一索引以去掉
重复行，最后从这个临时表中计算结果。因此，实际过程没有利用id_no上索引，并且完
成时间还要受tempdb数据库性能的影响。
---- 实践证明，表的行数越多，工作表的性能就越差，当stuff有620000行时，执行时
间竟达到220秒！还不如将or子句分开：
select count(*) from stuff where id_no=0
select count(*) from stuff where id_no=1
---- 得到两个结果，再作一次加法合算。因为每句都使用了索引，执行时间只有3秒，
在620000行下，时间也只有4秒。或者，用更好的方法，写一个简单的存储过程：
create proc count_stuff as
declare @a int
declare @b int
declare @c int
declare @d char(10)
begin
select @a=count(*) from stuff where id_no=0
select @b=count(*) from stuff where id_no=1
end
select @c=@a+@b
select @d=convert(char(10),@c)
print @d
---- 直接算出结果，执行时间同上面一样快！
---- 总结：
---- 可见，所谓优化即where子句利用了索引，不可优化即发生了表扫描或额外开销。
---- 1.任何对列的操作都将导致表扫描，它包括数据库函数、计算表达式等等，查询时
要尽可能将操作移至等号右边。
---- 2.in、or子句常会使用工作表，使索引失效；如果不产生大量重复值，可以考虑把
子句拆开；拆开的子句中应该包含索引。
---- 3.要善于使用存储过程，它使sql变得更加灵活和高效。
---- 从以上这些例子可以看出，sql优化的实质就是在结果正确的前提下，用优化器可
以识别的语句，充份利用索引，减少表扫描的i/o次数，尽量避免表搜索的发生。其实s
ql的性能优化是一个复杂的过程，上述这些只是在应用层次的一种体现，深入研究还会
涉及数据库层的资源配置、网络层的流量控制以及操作系统层的总体设计。
文/交通银行长春分行电脑部 任亮 摘自计算机日报
发表者：xiaogugu
建索引
发表者：hawaiileo
1. 合理创建索引，对where子句进行索引覆盖。
2. 优化查询语句
3. 对数据比较多的表进行安时间分割成多个表。
发表者：homeness
在群集索引下，数据在物理上按顺序在数据页上，重复值也排列在一起，因而在范
围查找时，可以先找到这个范围的起末点，且只在这个范围内扫描数据页，避免了大范
围扫描，提高了查询速度。
---- 3.在place，date，amount上的组合索引
select count(*) from record where date >
19991201 and date < 19991214 and amount >
2000
select date,sum(amount) from record group by date
select count(*) from record where date >
19990901 and place in (bj, sh)
---- 分析：
---- 这是一个不很合理的组合索引，因为它的前导列是place，第一和第二条sql没有引
用place，因此也没有利用上索引；第三个sql使用了place，且引用的所有列都包含在组
合索引中，形成了索引覆盖，所以它的速度是非常快的。
---- 4.在date，place，amount上的组合索引
select count(*) from record where date >
19991201 and date < 19991214 and amount >
2000(< 1秒)
select date,sum(amount) from record group by date
select count(*) from record where date >
19990901 and place in (bj,sh)
---- 分析：
---- 这是一个合理的组合索引。它将date作为前导列，使每个sql都可以利用索引，并
且在第一和第三个sql中形成了索引覆盖，因而性能达到了最优。
---- 5.总结：
---- 缺省情况下建立的索引是非群集索引，但有时它并不是最佳的；合理的索引设计要
建立在对各种查询的分析和预测上。一般来说：
---- ①.有大量重复值、且经常有范围查询
和order by
、group by发生的列，可考虑建立群集索引；
---- ②.经常同时存取多列，且每列都含有重复值可考虑建立组合索引；
---- ③.组合索引要尽量使关键查询形成索引覆盖，其前导列一定是使用最频繁的列
2007-12-24 13:53速度慢可能是：
1、有事务正在运行，在某中程度上对表资源加了锁
2、服务器进程在忙
从软件的角度：
1、根据查询的条件建立相应的索引
2、考虑使用数据仓库
发表者：smaze
建立一个好的索引的确可以将速度提高很多。
发表者：750906
建全文索引
发表者：silversands
如何提高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、避免使用 != 或 <> 等这样的操作符，因为它会使系统无法使用索引，而只能直接搜索表中的数据。
发表者：ldcr520
如何让你的sql运行得更快(转贴)
---- 人们在使用sql时往往会陷入一个误区，即太关注于所得的结果是否正确，而忽略
了不同的实现方法之间可能存在的性能差异，这种性能差异在大型的或是复杂的数据库
环境中中表现得尤为明显。笔者在工作实践
中发现，不良的sql往往来自于不恰当的索引设计、不充份的连接条件和不可优化的whe
re子句。在对它们进行适当的优化后，其运行速度有了明显地提高！下面我将从这三个
方面分别进行总结：
---- 为了更直观地说明问题，所有实例中的sql运行时间均经过测试，不超过１秒的均
表示为。
---- 测试环境--
---- 主机：hp lh ii
---- 主频：330mhz
---- 内存：128兆
---- 操作系统：operserver5.0.4
----数据库：sybase11.0.3
一、不合理的索引设计
----例：表record有620000行，试看在不同的索引下，下面几个 sql的运行情况：
---- 1.在date上建有一非个群集索引
select count(*) from record where date >
19991201 and date < 19991214and amount >
2000 (25秒)
select date,sum(amount) from record group by date
(55秒)
select count(*) from record where date >
19990901 and place in (bj,sh) (27秒)
---- 分析：
----date上有大量的重复值，在非群集索引下，数据在物理上随机存放在数据页上，在
范围查找时，必须执行一次表扫描才能找到这一范围内的全部行。
---- 2.在date上的一个群集索引
select count(*) from record where date >
19991201 and date < 19991214 and amount >
2000
select date,sum(amount) from record group by date
select count(*) from record where date >
19990901 and place in (bj,sh)
---- 分析：
---- 在群集索引下，数据在物理上按顺序在数据页上，重复值也排列在一起，因而在范
围查找时，可以先找到这个范围的起末点，且只在这个范围内扫描数据页，避免了大范
围扫描，提高了查询速度。
---- 3.在place，date，amount上的组合索引
select count(*) from record where date >
19991201 and date < 19991214 and amount >
2000
select date,sum(amount) from record group by date
select count(*) from record where date >
19990901 and place in (bj, sh)
---- 分析：
---- 这是一个不很合理的组合索引，因为它的前导列是place，第一和第二条sql没有引
用place，因此也没有利用上索引；第三个sql使用了place，且引用的所有列都包含在组
合索引中，形成了索引覆盖，所以它的速度是非常快的。
---- 4.在date，place，amount上的组合索引
select count(*) from record where date >
19991201 and date < 19991214 and amount >
2000(< 1秒)
select date,sum(amount) from record group by date
select count(*) from record where date >
19990901 and place in (bj,sh)
---- 分析：
---- 这是一个合理的组合索引。它将date作为前导列，使每个sql都可以利用索引，并
且在第一和第三个sql中形成了索引覆盖，因而性能达到了最优。
---- 5.总结：
---- 缺省情况下建立的索引是非群集索引，但有时它并不是最佳的；合理的索引设计要
建立在对各种查询的分析和预测上。一般来说：
---- ①.有大量重复值、且经常有范围查询
和order by
、group by发生的列，可考虑建立群集索引；
---- ②.经常同时存取多列，且每列都含有重复值可考虑建立组合索引；
---- ③.组合索引要尽量使关键查询形成索引覆盖，其前导列一定是使用最频繁的列。
二、不充份的连接条件：
---- 例：表card有7896行，在card_no上有一个非聚集索引，表account有191122行，在
account_no上有一个非聚集索引，试看在不同的表连接条件下，两个sql的执行情况：
select sum(a.amount) from account a,
card b where a.card_no = b.card_no
---- 将sql改为：
select sum(a.amount) from account a,
card b where a.card_no = b.card_no and a.
account_no=b.account_no
---- 分析：
---- 在第一个连接条件下，最佳查询方案是将account作外层表，card作内层表，利用
card上的索引，其i/o次数可由以下公式估算为：
---- 外层表account上的22541页+=595907次i/o
---- 在第二个连接条件下，最佳查询方案是将card作外层表，account作内层表，利用
account上的索引，其i/o次数可由以下公式估算为：
---- 外层表card上的1944页+= 33528次i/o
---- 可见，只有充份的连接条件，真正的最佳方案才会被执行。
---- 总结：
---- 1.多表操作在被实际执行前，查询优化器会根据连接条件，列出几组可能的连接方
案并从中找出系统开销最小的最佳方案。连接条件要充份考虑带有索引的表、行数多的
表；内外表的选择可由公式：外层表中的匹配行数*内层表中每一次查找的次数确定，乘
积最小为最佳方案。
---- 2.查看执行方案的方法-- 用set showplanon，打开showplan选项，就可以看到连
接顺序、使用何种索引的信息；想看更详细的信息，需用sa角色执行dbcc(3604,310,30
2)。
三、不可优化的where子句
---- 1.例：下列sql条件语句中的列都建有恰当的索引，但执行速度却非常慢：
select * from record where
substring(card_no,1,4)=5378(13秒)
select * from record where
amount/30< 1000
select * from record where
convert(char(10),date,112)=19991201
---- 分析：
---- where子句中对列的任何操作结果都是在sql运行时逐列计算得到的，因此它不得不
进行表搜索，而没有使用该列上面的索引；如果这些结果在查询编译时就能得到，那么
就可以被sql优化器优化，使用索引，避免表搜索，因此将sql重写成下面这样：
select * from record where card_no like
5378%
select * from record where amount
< 1000*30
select * from record where date= 1999/12/01
---- 你会发现sql明显快起来！
---- 2.例：表stuff有200000行，id_no上有非群集索引，请看下面这个sql：
select count(*) from stuff where id_no in(0,1)
---- 分析：
---- where条件中的in在逻辑上相当于or，所以语法分析器会将in (0,1)转化
为id_no =0 or id_no=1来执行。我们期望它会根据每个or子句分别查找，再将结果
相加，这样可以利用id_no上的索引；但实际上,它却采用了"or策略"
，即先取出满足每个or子句的行，存入临时数据库的工作表中，再建立唯一索引以去掉
重复行，最后从这个临时表中计算结果。因此，实际过程没有利用id_no上索引，并且完
成时间还要受tempdb数据库性能的影响。
---- 实践证明，表的行数越多，工作表的性能就越差，当stuff有620000行时，执行时
间竟达到220秒！还不如将or子句分开：
select count(*) from stuff where id_no=0
select count(*) from stuff where id_no=1
---- 得到两个结果，再作一次加法合算。因为每句都使用了索引，执行时间只有3秒，
在620000行下，时间也只有4秒。或者，用更好的方法，写一个简单的存储过程：
create proc count_stuff as
declare @a int
declare @b int
declare @c int
declare @d char(10)
begin
select @a=count(*) from stuff where id_no=0
select @b=count(*) from stuff where id_no=1
end
select @c=@a+@b
select @d=convert(char(10),@c)
print @d
---- 直接算出结果，执行时间同上面一样快！
---- 总结：
---- 可见，所谓优化即where子句利用了索引，不可优化即发生了表扫描或额外开销。
---- 1.任何对列的操作都将导致表扫描，它包括数据库函数、计算表达式等等，查询时
要尽可能将操作移至等号右边。
---- 2.in、or子句常会使用工作表，使索引失效；如果不产生大量重复值，可以考虑把
子句拆开；拆开的子句中应该包含索引。
---- 3.要善于使用存储过程，它使sql变得更加灵活和高效。
---- 从以上这些例子可以看出，sql优化的实质就是在结果正确的前提下，用优化器可
以识别的语句，充份利用索引，减少表扫描的i/o次数，尽量避免表搜索的发生。其实s
ql的性能优化是一个复杂的过程，上述这些只是在应用层次的一种体现，深入研究还会
涉及数据库层的资源配置、网络层的流量控制以及操作系统层的总体设计。
文/交通银行长春分行电脑部 任亮 摘自计算机日报
发表者：xiaogugu
建索引
发表者：hawaiileo
1. 合理创建索引，对where子句进行索引覆盖。
2. 优化查询语句
3. 对数据比较多的表进行安时间分割成多个表。
发表者：homeness
在群集索引下，数据在物理上按顺序在数据页上，重复值也排列在一起，因而在范
围查找时，可以先找到这个范围的起末点，且只在这个范围内扫描数据页，避免了大范
围扫描，提高了查询速度。
---- 3.在place，date，amount上的组合索引
select count(*) from record where date >
19991201 and date < 19991214 and amount >
2000
select date,sum(amount) from record group by date
select count(*) from record where date >
19990901 and place in (bj, sh)
---- 分析：
---- 这是一个不很合理的组合索引，因为它的前导列是place，第一和第二条sql没有引
用place，因此也没有利用上索引；第三个sql使用了place，且引用的所有列都包含在组
合索引中，形成了索引覆盖，所以它的速度是非常快的。
---- 4.在date，place，amount上的组合索引
select count(*) from record where date >
19991201 and date < 19991214 and amount >
2000(< 1秒)
select date,sum(amount) from record group by date
select count(*) from record where date >
19990901 and place in (bj,sh)
---- 分析：
---- 这是一个合理的组合索引。它将date作为前导列，使每个sql都可以利用索引，并
且在第一和第三个sql中形成了索引覆盖，因而性能达到了最优。
---- 5.总结：
---- 缺省情况下建立的索引是非群集索引，但有时它并不是最佳的；合理的索引设计要
建立在对各种查询的分析和预测上。一般来说：
---- ①.有大量重复值、且经常有范围查询
和order by
、group by发生的列，可考虑建立群集索引；
---- ②.经常同时存取多列，且每列都含有重复值可考虑建立组合索引；
---- ③.组合索引要尽量使关键查询形成索引覆盖，其前导列一定是使用最频繁的列