整合营销服务商

电脑端+手机端+微信端=数据同步管理

免费咨询热线:

全网最全的 MySQL 索引优化方案

一、分页查询优化

很多时候我们业务系统实现分页功能可能会用如下sql实现:

select * from employees limit 10000,10;

表示从表 中取出从 10001 行开始的 10 行记录。看似只查询了 10 条记录,实际这条 SQL 是先读取 10010条记录,然后抛弃前 10000 条记录,然后读到后面 10 条想要的数据。因此要查询一张大表比较靠后的数据,执行效率是非常低的。这是典型的深度分页问题。

分页场景优化技巧 1、根据自增且连续的主键排序的分页查询

首先来看一个根据自增且连续主键排序的分页查询的例子:

select * from employees limit 90000,5;

fbf16e83e9d66189be26d0a0a04acad2.png

该 SQL 表示查询从第 90001开始的五行数据,没添加单独 order by,表示通过主键排序。我们再看表 ,因为主键是自增并且连续的,所以可以改写成按照主键去查询从第 90001开始的五行数据,如下:

select * from employees where id > 90000 limit 5;

cd30d85f8108bbac470a1a6d706d1fd8.png

查询的结果是一致的。我们再对比一下执行计划:

EXPLAIN select * from employees limit 90000,5;

EXPLAIN select * from employees where id > 90000 limit 5;

显然改写后的 SQL 走了索引,而且扫描的行数大大减少,执行效率更高。

但是,这条改写的SQL 在很多场景并不实用,因为表中可能某些记录被删后,主键空缺,导致结果不一致,如下图试验所示(先删除一条前面的记录,然后再测试原 SQL 和优化后的 SQL):

88c8a5c1c32d0a92ab950c00804e0ca9.png

f5638d0e7c9894507a822d395f696ff5.png

两条 SQL 的结果并不一样,因此,如果主键不连续,不能使用上面描述的优化方法。

另外如果原 SQL 是 order by 非主键的字段,按照上面说的方法改写会导致两条 SQL 的结果不一致。所以这种改写得满足以下两个条件:

2、根据非主键字段排序的分页查询

再看一个根据非主键字段排序的分页查询,SQL 如下:

select * from employees ORDER BY name limit 90000,5;

a32cf89a621622fde1580aa905e18d5f.png

EXPLAIN select * from employees ORDER BY name limit 90000,5;

a5518324a29e48fa79e17c8eb0d09eff.png

发现并没有使用 name 字段的索引(key 字段对应的值为 null),具体原因是:扫描整个索引并查找到没索引的行(可能要遍历多个索引树)的成本比扫描全表的成本更高,所以优化器放弃使用索引。

知道不走索引的原因,那么怎么优化呢?

其实关键是让排序时返回的字段尽可能少,即考虑使用覆盖索引进行优化,所以可以让排序和分页操作先查出主键,然后根据主键查到对应的记录,SQL改写如下:

select * from employees e inner join (select id from employees order by name limit 90000,5) ed on e.id = ed.id;

ff091eb8d96d2296a4b798426776ee13.png

需要的结果与原 SQL 一致,执行时间减少了一半以上,此时查询和排序都是在覆盖索引树上进行的,所以效率较高。我们再对比优化前后sql的执行计划:

fcbca794db8702ed91dc39cb7c26488e.png

原 SQL 使用的是 file sort 排序,而优化后的 SQL 使用的是索引排序。

二、Join关联查询优化

示例表:

‐‐ 示例表:
 CREATE TABLE `t1` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `a` int(11) DEFAULT NULL,
 `b` int(11) DEFAULT NULL,
 PRIMARY KEY (`id`),
 KEY `idx_a` (`a`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
 create table t2 like t1;
 ‐‐ 插入一些示例数据
 ‐‐ 往t1表插入1万行记录
 drop procedure if exists insert_t1;
 delimiter ;;
 create procedure insert_t1()
 begin
 declare i int;
 set i=1;
 while(i<=10000)do
 insert into t1(a,b) values(i,i);
 set i=i+1;
 end while;
 end;;
 delimiter ;
 call insert_t1();
 
 ‐‐ 往t2表插入100行记录
 drop procedure if exists insert_t2;

常见的数据库优化手段_数据库优化有哪些方法_数据库优化方案

 delimiter ;;  create procedure insert_t2()  begin  declare i int;  set i=1;  while(i<=100)do  insert into t2(a,b) values(i,i);  set i=i+1;  end while;  end;;  delimiter ;  call insert_t2();

mysql的表关联常见有两种算法

1、 嵌套循环连接 Nested-Loop Join(NLJ) 算法

一次一行循环地从第一张表(称为驱动表)中读取行,在这行数据中取到关联字段,根据关联字段在另一张表(被驱动表)里取出满足条件的行,然后取出两张表的结果合集。

EXPLAIN select * from t1 inner join t2 on t1.a= t2.a;  -- // a字段有索引

489180c9bc8bb5480654efc79107009d.png

从执行计划中可以看到这些信息:

上面sql的大致流程如下:

整个过程会读取 t2 表的所有数据(扫描100行),然后遍历这每行数据中字段 a 的值,根据 t2 表中 a 的值索引扫描 t1 表中的对应行(扫描100次 t1 表的索引,1次扫描可以认为最终只扫描 t1 表一行完整数据,也就是总共 t1 表也扫描了100行)。因此整个过程扫描了 200 行。

2、 基于块的嵌套循环连接 Block Nested-Loop Join(BNL)算法

把驱动表的数据读入到 中,然后扫描被驱动表,把被驱动表每一行取出来跟 中的数据做对比。

EXPLAIN select * from t1 inner join t2 on t1.b= t2.b; -- // b字段没有索引

b70cd4a2c2cfd44e35fb94df393a24b0.png

Extra 中 的Using join buffer (Block Nested Loop)说明该关联查询使用的是 BNL 算法。

上面sql的大致流程如下:

整个过程对表 t1 和 t2 都做了一次全表扫描,因此扫描的总行数为10000(表 t1 的数据总量) + 100(表 t2 的数据总量) =10100。并且 里的数据是无序的,因此对表 t1 中的每一行,都要做 100 次判断,所以内存中的判断次数是100 * 10000= 100 万次。

这个例子里表 t2 才 100 行,要是表 t2 是一个大表, 放不下怎么办呢?

的大小是由参数 设定的,默认值是 256k。如果放不下表 t2 的所有数据话,策略很简单,就是分段放。

比如 t2 表有1000行记录, 一次只能放800行数据,那么执行过程就是先往 里放800行记录,然后从 t1 表里取数据跟 中数据对比得到部分结果,然后清空 ,再放入 t2 表剩余200行记录,再次从 t1 表里取数据跟 中数据对比。所以就多扫了一次 t1 表。

被驱动表的关联字段没索引为什么要选择使用 BNL 算法而不使用 Nested-Loop Join 呢?

如果上面第二条sql使用 Nested-Loop Join,那么扫描行数为 100 * 10000 = 100万次,这个是磁盘扫描。

很显然,用BNL磁盘扫描次数少很多,相比于磁盘扫描,BNL的内存计算会快得多。因此MySQL对于被驱动表的关联字段没索引的关联查询,一般都会使用 BNL 算法。如果有索引一般选择 NLJ 算法,有索引的情况下 NLJ 算法比 BNL算法性能更高.

对于关联sql的优化

解释:功能同join类似,但能让左边的表来驱动右边的表,能改表优化器对于联表查询的执行顺序。

比如:select * from t2 t1 on t2.a = t1.a; 代表指定mysql选着 t2 表作为驱动表。

对于小表定义的明确:

在决定哪个表做驱动表的时候,应该是两个表按照各自的条件过滤,过滤完成之后,计算参与 join 的各个字段的总数据量,数据量小的那个表,就是“小表”,应该作为驱动表。

三、in和exsits优化

原则:小表驱动大表,即小的数据集驱动大的数据集。

In是In后的表先执行(适用于B表小于A表):

select * from A where id in ( select id from B)

Exists是Exists前面的表先执行(适用于A表小于B表):

select * from A where id in ( select id from B)

in:当B表的数据集小于A表的数据集时,in优于exists

select * from A where id in (select id from B)
// #等价于:
 for(select id from B){
 select * from A where A.id = B.id
 }

exists:当A表的数据集小于B表的数据集时,exists优于in

将主查询A的数据,放到子查询B中做条件验证,根据验证结果(true或false)来决定主查询的数据是否保留.

select * from A where exists (select 1 from B where B.id = A.id)
 // # 等价于:
 for(select * from A){
 select * from B where B.id = A.id
 }
 // # A表与B表的ID字段应建立索引

总结:

1、EXISTS ()只返回TRUE或FALSE,因此子查询中的SELECT * 也可以用SELECT 1替换,官方说法是实际执行时会忽略SELECT清单,因此没有区别

2、EXISTS子查询的实际执行过程可能经过了优化而不是我们理解上的逐条对比

3、EXISTS子查询往往也可以用JOIN来代替,何种最优需要具体问题具体分析

四、count(*)查询优化

常见的数据库优化手段_数据库优化方案_数据库优化有哪些方法

-- 临时关闭mysql查询缓存,为了查看sql多次执行的真实时间
 set global query_cache_size=0;
 set global query_cache_type=0;
 EXPLAIN select count(1) from employees;
 EXPLAIN select count(id) from employees;
 EXPLAIN select count(name) from employees;
 EXPLAIN select count(*) from employees;
 -- 注意:以上4条sql只有根据某个字段count不会统计字段

经过测试发现:四个sql的执行计划一样,说明这四个sql执行效率应该差不多

1、字段有索引: count(*)≈count(1)>count(字段)>count(主键 id)

字段有索引,count(字段)统计走二级索引,二级索引存储数据比主键索引少,所以count(字段)>count(主键 id)

2、字段无索引: count(*)≈count(1)>count(主键 id)>count(字段)

字段没有索引count(字段)统计走不了索引,count(主键 id)还可以走主键索引,所以count(主键 id)>count(字段)

count(1) 跟 count(字段) 执行过程类似,不过count(1)不需要取出字段统计,就用常量1做统计,count(字段)还需要取出字段,所以理论上count(1)比count(字段)会快一点。

count(*) 是例外,mysql并不会把全部字段取出来,而是专门做了优化(5.7版本),不取值,按行累加,效率很高,所以不需要用count(列名)或count(常量)来替代 count(*)。

为什么对于count(id),mysql最终选择辅助索引而不是主键聚集索引?因为二级索引相对主键索引存储数据更少,检索性能应该更高,mysql内部做了点优化(应该是在5.7版本才优化)。

常见优化方法

当表中数据量非常大的时候,count这种通过计算统计的都会很慢,所以需要一些优化手段。

1、查询mysql自己维护的总行数

对于myisam存储引擎的表做不带where条件的count查询性能是很高的,因为myisam存储引擎的表的总行数会被mysql存储在磁盘上,查询不需要计算.

03c9929a5b9dd2d231cb77d195ae728c.png

对于innodb存储引擎的表mysql不会存储表的总记录行数(因为有MVCC机制,后面会讲),查询count需要实时计算.

2、show table status

如果只需要知道表总行数的估计值可以用如下sql查询,性能很高

e13f6e5b29c91d2769a683b6ecfeb3c7.png

3、将总数维护到Redis里

插入或删除表数据行的时候同时维护redis里的表总行数key的计数值(用incr或decr命令),但是这种方式可能不准,很难保证表操作和redis操作的事务一致性.

4、增加数据库计数表

插入或删除表数据行的时候同时维护计数表,让他们在同一个事务里操作

五、阿里MySQL规范解读 (一) 建表规约

255cf2b42cf502b094f8ec58b6fe8032.png

(二) 索引规约 (三) SQL语句 (四) ORM映射

正例:

Map map = new HashMap<>();
map.put(“start”, start);
map.put(“size”, size);

六、MySQL数据类型选择

在MySQL中,选择正确的数据类型,对于性能至关重要。一般应该遵循下面两步:

在MySQL数据类型设置方面,尽量用更小的数据类型,因为它们通常有更好的性能,花费更少的硬件资源。并且,尽量 把字段定义为NOT NULL,避免使用NULL.

1、数值类型

31adfbcecbcbe4ddd16592c3090fc9d3.png

ffe135f501392c21103ffd1f47381ab1.png

优化建议:

2、日期和时间

d63fd51323565c3a5431c02835caaf31.png

优化建议:

3、字符串

8d0ec83f97a86522214569cf3aad03d3.png

5ce0b04aa4714a412de8dc0f841cee70.png

优化建议:

PS:INT显示宽度

我们经常会使用命令来创建数据表,而且同时会指定一个长度,如下。但是,这里的长度并非是TINYINT类型存储的最大长度,而是显示的最大长度。

CREATE TABLE `user`(
 `id` TINYINT(2) UNSIGNED
);

这里表示user表的id字段的类型是TINYINT,可以存储的最大数值是255。所以,在存储数据时,如果存入值小于等于255,如200,虽然超过2位,但是没有超出TINYINT类型长度,所以可以正常保存;如果存入值大于255,如500,那么MySQL会自动保存为TINYINT类型的最大值255。

在查询数据时,不管查询结果为何值,都按实际输出。这里TINYINT(2)中2的作用就是,当需要在查询结果前填充0时,命令中加上就可以实现,如:

`id` TINYINT(2) UNSIGNED ZEROFILL

这样,查询结果如果是5,那输出就是05。如果指定TINYINT(5),那输出就是00005,其实实际存储的值还是5,而且存 储的数据不会超过255,只是MySQL输出数据时在前面填充了0。

换句话说,在MySQL命令中,字段的类型长度TINYINT(2)、INT(11)不会影响数据的插入,只会在使用时有 用,让查询结果前填充0。

来源://article/ details/

推荐:

主流Java进阶技术(学习资料分享)

5367d73a74288863eb9524ab1ba7b234.png

PS:因为公众号平台更改了推送规则,如果不想错过内容,记得读完点一下“在看”,加个“星标”,这样每次新文章推送才会第一时间出现在你的订阅列表里。点“在看”支持我们吧!

MySQL 性能优化,索引和查询优化

mysql查询按时间排序_mysql排序查询语句_数据库查询按时间排序

要知道为什么使用索引,要知道如何去使用好索引,使自己的查询达到最优性能,需要先了解索引的数据结构和磁盘的存取原理

1. 不使用顺序查找,因为顺序查找比较慢,通过特定数据结构的特点来提升查询速度,这种数据结构就是可以理解成索引。

mysql排序查询语句_数据库查询按时间排序_mysql查询按时间排序

2. 索引一般以文件形式存储在磁盘上,索引检索需要磁盘I/O操作,为了尽量减少磁盘I/O。磁盘往往不是严格按需读取,而是每次都会预读,而且主存和磁盘以页为单位交换数据,所以在读取的数据不在主存中时,会从磁盘中读取一批数据(页)到主存中。

mysql排序查询语句_数据库查询按时间排序_mysql查询按时间排序

3. 不管在哪种程序优化上,要想快速挺高性能,直接将常用的、少变更的数据直接读取到内存中,使用的时候就直接在内存上读取,而不去磁盘上读取,减少I/O操作,这样就能使程序快上10倍以上。但由于内存容量的限制,也不可能将所有的数据都放内存中。

mysql查询按时间排序_数据库查询按时间排序_mysql排序查询语句

MySQL索引分类

普通索引:最基本的索引,没有任何限制。

唯一索引:与”普通索引”类似,不同的就是:索引列的值必须唯一,但允许有空值。

主键索引:它是一种特殊的唯一索引,不允许有空值。

全文索引:仅可用于 MyISAM 表,针对较大的数据,生成全文索引很耗时好空间。

组合索引:为了更多的提高mysql效率可建立组合索引,遵循”最左前缀“原则。

覆盖索引( Indexes):就是直接走的索引,直接在内存中就拿到值,不需要查询数据库。如分页就要走覆盖索引,因为性能比较高。

聚簇索引( Indexes):主键就是聚集索引。聚簇索引保证关键字的值相近的元组存储的物理位置也相同(所以字符串类型不宜建立聚簇索引,特别是随机字符串,会使得系统进行大量的移动操作),且一个表只能有一个聚簇索引。因为由存储引擎实现索引,所以,并不是所有的引擎都支持聚簇索引。目前,只有solidDB和InnoDB支持。

非聚簇索引:二级索引叶子节点保存的不是指行的物理位置的指针,而是行的主键值。这意味着通过二级索引查找行。

InnoDB对主键建立聚簇索引。如果你不指定主键,InnoDB会用一个具有唯一且非空值的索引来代替。如果不存在这样的索引,InnoDB会定义一个隐藏的主键,然后对其建立聚簇索引。一般来说,DBMS都会以聚簇索引的形式来存储实际的数据,它是其二级索引的基础。

优化要注意的一些事(重点)

1. 索引其实就是一种归类方式,当某一个字段属性都不能归类,建立索引后是没什么效果的,或归类就二种(0和1),且各自都数据对半分,建立索引后的效果也不怎么强。

2. 主键的索引是不一样的,要区别理解。

3. 当时间存储为时间戳保存的可以建立前缀索引。

4. 在什么是字段上建立索引,需要根据查询条件而定,不要一上来就建立索引,浪费内存还有可能用不到。

5. 大字段(blob)不要建立索引,查询也不会走索引。

6. 常用建立索引的地方:

1)主键的聚集索引

2)外键索引

3)类别只有0和1就不要建索引了,没有意义,对性能没有提升,还影响写入性能

4)用模糊其实是可以走前缀索引

7. 唯一索引一定要小心使用,它带有唯一约束,由于前期需求不明等情况下,可能造成我们对于唯一列的误判。

8. 由于我们建立索引并想让索引能达到最高性能,这个时候我们应当充分考虑该列是否适合建立索引,可以根据列的区分度来判断,区分度太低的情况下可以不考虑建立索引,区分度越高效率越高。

9. 写入比较频繁的时候,不能开启MySQL的查询缓存,因为在每一次写入的时候不光要写入磁盘还的更新缓存中的数据。

10. 建索引的目的:

1)加快查询速度,使用索引后查询有迹可循。

2)减少I/O操作,通过索引的路径来检索数据,不是在磁盘中随机检索。

3)消除磁盘排序,索引是排序的,走完索引就排序完成。

11. 其实建索引的原理就是将磁盘I/O操作的最小化,不在磁盘中排序,而是在内存中排好序,通过排序的规则去指定磁盘读取就行,也不需要在磁盘上随机读取。

12. 由于磁盘整理磁盘碎片,所有有的时候我们也可以通过建立聚集索引来减少这一类的问题。

13. 当一个表中有100万数据,而经常用到的数据只有40万或40万以下,是不用考虑建立索引的,没什么性能提升。

14. 什么时候不适合建立索引:

1)频繁更新的字段不适合建立索引

mysql查询按时间排序_mysql排序查询语句_数据库查询按时间排序

2)where条件中用不到的字段不适合建立索引,都用不到建立索引没有意义还浪费空间

3)表数据可以确定比较少的不需要建索引

4)数据重复且发布比较均匀的的字段不适合建索引(唯一性太差的字段不适合建立索引),例如性别,真假值

5)参与列计算的列不适合建索引,如:

select * from table where amount+100>1000,-- 这样是不走索引的,可以改造为:select * from table where amount>1000-100。

15. 使用count统计数据量的时候建议使用count(*)而不是count(列),因为count(*)MySQL是做了优化的。

16. 二次SQL查询区别不大的时候,不能按照二次执行的时间来判断优化结果,没准第一次查询后又保存缓存数据,导致第二次查询速度比第二次快,很多时候我们看到的都是假象。

17. 什么时候开MySQL的查询缓存,交易系统(写多、读少)、SQL优化测试,建议关闭查询缓存,论坛文章类系统(写少、读多),建议开启查询缓存。

18. Explain 执行计划只能解释SELECT操作。

19. 查询优化可以考虑让查询走索引,走索引能提升查询速度,索引覆盖是最快的,如下就是让分页走覆盖索引提高查询速度。

20. 子查询比join快,虽然规律不绝对,但对大表多数有效

21. 复杂SQL语句优化的思路:

1)首先考虑在一个表中能不能取到有关的信息,尽量少关联表

2)关联条件争取都走主键或外键查询条件,能走到对应的索引

3)争取在满足业务上走小集合数据查找

4)INNER JOIN 和子查询哪个更快,场景不一致速度也不同

22. where条件多条件一定要按照小结果集排大结果集前面

23. 尽量避免大事务操作,提高系统并发能力,有时无法避免,改用定时器延迟处理。

24. 什么情况不走索引:

SELECT ` famount ` FROM ` ` WHERE ` famount `+10=30;-- 不会使用索引,因为所有索引列参与了计算

SELECT `famount` FROM `` WHERE LEFT(``,4)

SELECT * FROM ` fuser` WHERE `` LIKE‘138%' -- 走索引

SELECT * FROM ` fuser ` WHERE ` ` LIKE "%7488%" -- 不走索引 -- 正则表达式不使用索引,这应该很好理解,所以为什么在SQL中很难看到regexp关键字的原因 -- 字符串与数字比较不使用索引;

EXPLAIN SELECT * FROM `a` WHERE `a`=1 -- 不走索引

select * from fuser where ='xxx' or femail='xx' or fstatus=1 --如果条件中有or,即使其中有条件带索引也不会使用。换言之,就是要求使用的所有字段,都必须建立索引, 我们建议大家尽量避免使用or 关键字

25. 如果MySQL估计使用全表扫描要比使用索引快,则不使用索引。

26. 使用UNION ALL 替换OR多条件查询并集。

27. 在大数据表删除也是一个问题,避免删除过程数据库奔溃,可以考虑分配删除,一次删1000条,删完后等一会继续删除

28. 大数据表优化:

1)建立汇总表

2)建立流水表

3)分库分表

29. 建立汇总表,首先不用考虑分库分表,使用定时器定时去汇总。

30. 分表,可以按水平或垂直切分。垂直分表其实就是将经常使用的数据和很少使用的数据进行垂直的切分,切分到不同的库,提高单库的数据容量,如:前3个月之前的交易记录就可以放另一个库中。

31. 建立流水表,数据冗余,有这个表记录流水变更就不用去写复杂SQL计算流水。

32. 分库,多数据库相同库结构,分发处理并发能力,但同时带来了数据同步问题,也可以使用分库做主备分离

32. SQL优化顺序:

1)尽量少作计算。

2)尽量少 join。

mysql排序查询语句_mysql查询按时间排序_数据库查询按时间排序

3)尽量少排序。

4)尽量避免 select *。

5)尽量用 join 代替子查询。

6)尽量少 or。

7)尽量用 union all 代替 union。

8)尽量早过滤。

9)避免类型转换。

10)优先优化高并发的 SQL,而不是执行频率低某些“大”SQL。

11)从全局出发优化,而不是片面调整。

12)尽可能对每一条运行在数据库中的SQL进行 Explain。

33. 如下是30条大数据表优化要点:

1)对查询进行优化,应尽量避免全表扫描,首先应考虑在 where 及 order by 涉及的列上建立索引。

2)应尽量避免在 where 子句中对字段进行 null 值判断,否则将导致引擎放弃使用索引而进行全表扫描,如:select id from t where num is null可以在num上设置默认值0,确保表中num列没有null值,然后这样查询:select id from t where num=0

3)应尽量避免在 where 子句中使用!=或操作符,否则引擎将放弃使用索引而进行全表扫描。

4)应尽量避免在 where 子句中使用or 来连接条件,否则将导致引擎放弃使用索引而进行全表扫描,如:select id from t where num=10 or num=20可以这样查询:select id from t where num=10 union all select id from t where num=20

5)in 和 not in 也要慎用,否则会导致全表扫描,如:select id from t where num in(1,2,3) 对于连续的数值,能用 between 就不要用 in 了:select id from t where num between 1 and 3

6)下面的查询也将导致全表扫描:select id from t where name like '李%'若要提高效率,可以考虑全文检索。

7)如果在 where 子句中使用参数,也会导致全表扫描。因为SQL只有在运行时才会解析局部变量,但优化程序不能将访问计划的选择推迟到运行时;它必须在编译时进行选择。然 而,如果在编译时建立访问计划,变量的值还是未知的,因而无法作为索引选择的输入项。如下面语句将进行全表扫描:select id from t where num=@num可以改为强制查询使用索引:select id from t with(index(索引名)) where num=@num

8)应尽量避免在 where 子句中对字段进行表达式操作,这将导致引擎放弃使用索引而进行全表扫描。如:select id from t where num/2=100应改为:select id from t where num=100*2

9)应尽量避免在where子句中对字段进行函数操作,这将导致引擎放弃使用索引而进行全表扫描。如:select id from t where (name,1,3)='abc' ,name以abc开头的id 应改为: select id from t where name like 'abc%'

10)不要在 where 子句中的“=”左边进行函数、算术运算或其他表达式运算,否则系统将可能无法正确使用索引。

11)在使用索引字段作为条件时,如果该索引是复合索引,那么必须使用到该索引中的第一个字段作为条件时才能保证系统使用该索引,否则该索引将不会被使用,并且应尽可能的让字段顺序与索引顺序相一致。

12)不要写一些没有意义的查询,如需要生成一个空表结构:select col1,col2 into #t from t where 1=0 这类代码不会返回任何结果集,但是会消耗系统资源的,应改成这样:create table #t(...)

13)很多时候用 exists 代替 in 是一个好的选择:select num from a where num in(select num from b) 用下面的语句替换:select num from a where exists(select 1 from b where num=a.num)

14)并不是所有索引对查询都有效,SQL是根据表中数据来进行查询优化的,当索引列有大量数据重复时,SQL查询可能不会去利用索引,如一表中有字段sex,male、female几乎各一半,那么即使在sex上建了索引也对查询效率起不了作用。

15)索引并不是越多越好,索引固然可 以提高相应的 select 的效率,但同时也降低了 insert 及 update 的效率,因为 insert 或 update 时有可能会重建索引,所以怎样建索引需要慎重考虑,视具体情况而定。一个表的索引数最好不要超过6个,若太多则应考虑一些不常使用到的列上建的索引是否有 必要。

16)应尽可能的避免更新 索引数据列,因为 索引数据列的顺序就是表记录的物理存储顺序,一旦该列值改变将导致整个表记录的顺序的调整,会耗费相当大的资源。若应用系统需要频繁更新 索引数据列,那么需要考虑是否应将该索引建为 索引。

17)尽量使用数字型字段,若只含数值信息的字段尽量不要设计为字符型,这会降低查询和连接的性能,并会增加存储开销。这是因为引擎在处理查询和连接时会逐个比较字符串中每一个字符,而对于数字型而言只需要比较一次就够了。

18)尽可能的使用 varchar/ 代替 char/nchar ,因为首先变长字段存储空间小,可以节省存储空间,其次对于查询来说,在一个相对较小的字段内搜索效率显然要高些。

19)任何地方都不要使用 select * from t ,用具体的字段列表代替“*”,不要返回用不到的任何字段。

20)尽量使用表变量来代替临时表。如果表变量包含大量数据,请注意索引非常有限(只有主键索引)。

21)避免频繁创建和删除临时表,以减少系统表资源的消耗。

22)临时表并不是不可使用,适当地使用它们可以使某些例程更有效,例如,当需要重复引用大型表或常用表中的某个数据集时。但是,对于一次性事件,最好使用导出表。

23)在新建临时表时,如果一次性插入数据量很大,那么可以使用 select into 代替 create table,避免造成大量 log ,以提高速度;如果数据量不大,为了缓和系统表的资源,应先create table,然后insert。

24)如果使用到了临时表,在存储过程的最后务必将所有的临时表显式删除,先 table ,然后 drop table ,这样可以避免系统表的较长时间锁定。

25)尽量避免使用游标,因为游标的效率较差,如果游标操作的数据超过1万行,那么就应该考虑改写。

26)使用基于游标的方法或临时表方法之前,应先寻找基于集的解决方案来解决问题,基于集的方法通常更有效。

27)与临时表一样,游标并不是不可使 用。对小型数据集使用 游标通常要优于其他逐行处理方法,尤其是在必须引用几个表才能获得所需的数据时。在结果集中包括“合计”的例程通常要比使用游标执行的速度快。如果开发时 间允许,基于游标的方法和基于集的方法都可以尝试一下,看哪一种方法的效果更好。

28)在所有的存储过程和触发器的开始处设置 SET NOCOUNT ON ,在结束时设置 SET NOCOUNT OFF 。无需在执行存储过程和触发器的每个语句后向客户端发送 消息。

29)尽量避免大事务操作,提高系统并发能力。

30)尽量避免向客户端返回大数据量,若数据量过大,应该考虑相应需求是否合理。