sql server 提升procedure性能如何提高sql性能

转载

码海探险先锋 2024-03-08 11:49:39

文章标签 SQL 数据字段 文章分类 SQL Server 数据库

总结：

1.书写问题

2.表连接方式

3.索引的抉择

4.执行计划之参数嗅探

5.子查询与表连接的效率

6.临时表、CTE、表变量的选择

7.常用sp与select的缓存命中

8.锁（善用nolock，注意跳读与重复读）与事务（显示与隐式以及自动）

9.索引碎片与填充因子

10.慢查询处理

在程序开发中怎样写SQL语句可以提高数据库的性能

一、sql角度

1、首先要搞明白什么叫执行计划？

执行计划是数据库根据SQL语句和相关表的统计信息作出的一个查询方案，这个方案是由查询优化器自动分析产生的，比如一条SQL语句如果用来从一个10万条记录的表中查1条记录，那查询优化器会选择“索引查找”方式，如果该表进行了归档，当前只剩下5000条记录了，那查询优化器就会改变方案，采用“全表扫描”方式。

可见，执行计划并不是固定的，它是“个性化的”。产生一个正确的“执行计划”有两点很重要：

(1) SQL语句是否清晰地告诉查询优化器它想干什么？

(2) 查询优化器得到的数据库统计信息是否是最新的、正确的？

2、统一SQL语句的写法

对于以下两句SQL语句，程序员认为是相同的，数据库查询优化器认为是不同的。

select * from dual

Select * From dual

其实就是大小写不同，查询分析器就认为是两句不同的SQL语句，必须进行两次解析。生成2个执行计划。所以作为程序员，应该保证相同的查询语句在任何地方都一致，多一个空格都不行！

3、不要把SQL语句写得太复杂

我经常看到，从数据库中捕捉到的一条SQL语句打印出来有2张A4纸这么长。一般来说这么复杂的语句通常都是有问题的。我拿着这2页长的SQL语句去请教原作者，结果他说时间太长，他一时也看不懂了。可想而知，连原作者都有可能看糊涂的SQL语句，数据库也一样会看糊涂。

一般，将一个Select语句的结果作为子集，然后从该子集中再进行查询，这种一层嵌套语句还是比较常见的，但是根据经验，超过3层嵌套，查询优化器就很容易给出错误的执行计划。因为它被绕晕了。像这种类似人工智能的东西，终究比人的分辨力要差些，如果人都看晕了，我可以保证数据库也会晕的。

另外，执行计划是可以被重用的，越简单的SQL语句被重用的可能性越高。而复杂的SQL语句只要有一个字符发生变化就必须重新解析，然后再把这一大堆垃圾塞在内存里。可想而知，数据库的效率会何等低下。

4、使用“临时表”暂存中间结果

简化SQL语句的重要方法就是采用临时表暂存中间结果，但是，临时表的好处远远不止这些，将临时结果暂存在临时表，后面的查询就在tempdb中了，这可以避免程序中多次扫描主表，也大大减少了程序执行中“共享锁”阻塞“更新锁”，减少了阻塞，提高了并发性能。

5、 OLTP系统SQL语句必须采用绑定变量

select * from orderheader where changetime > ‘2010-10-20 00:00:01’
select * from orderheader where changetime > ‘2010-09-22 00:00:01’

以上两句语句，查询优化器认为是不同的SQL语句，需要解析两次。如果采用绑定变量

select * from orderheader where changetime > @chgtime

@chgtime变量可以传入任何值，这样大量的类似查询可以重用该执行计划了，这可以大大降低数据库解析SQL语句的负担。一次解析，多次重用，是提高数据库效率的原则。

6、绑定变量窥测（参数嗅探）

事物都存在两面性，绑定变量对大多数OLTP处理是适用的，但是也有例外。比如在where条件中的字段是“倾斜字段”的时候。

“倾斜字段”指该列中的绝大多数的值都是相同的，比如一张人口调查表，其中“民族”这列，90%以上都是汉族。那么如果一个SQL语句要查询30岁的汉族人口有多少，那“民族”这列必然要被放在where条件中。这个时候如果采用绑定变量@nation会存在很大问题。

试想如果@nation传入的第一个值是“汉族”，那整个执行计划必然会选择表扫描。然后，第二个值传入的是“布依族”，按理说“布依族”占的比例可能只有万分之一，应该采用索引查找。但是，由于重用了第一次解析的“汉族”的那个执行计划，那么第二次也将采用表扫描方式。这个问题就是著名的“绑定变量窥测”，建议对于“倾斜字段”不要采用绑定变量。

7、只在必要的情况下才使用begin tran

SQL Server中一句SQL语句默认就是一个事务，在该语句执行完成后也是默认commit的。其实，这就是begin tran的一个最小化的形式，好比在每句语句开头隐含了一个begin tran，结束时隐含了一个commit。

有些情况下，我们需要显式声明begin tran，比如做“插、删、改”操作需要同时修改几个表，要求要么几个表都修改成功，要么都不成功。begin tran 可以起到这样的作用，它可以把若干SQL语句套在一起执行，最后再一起commit。好处是保证了数据的一致性，但任何事情都不是完美无缺的。Begin tran付出的代价是在提交之前，所有SQL语句锁住的资源都不能释放，直到commit掉。

可见，如果Begin tran套住的SQL语句太多，那数据库的性能就糟糕了。在该大事务提交之前，必然会阻塞别的语句，造成block很多。

Begin tran使用的原则是，在保证数据一致性的前提下，begin tran 套住的SQL语句越少越好！有些情况下可以采用触发器同步数据，不一定要用begin tran。

8、一些SQL查询语句应加上nolock

在SQL语句中加nolock是提高SQL Server并发性能的重要手段，在oracle中并不需要这样做，因为oracle的结构更为合理，有undo表空间保存“数据前影”，该数据如果在修改中还未commit，那么你读到的是它修改之前的副本，该副本放在undo表空间中。这样，oracle的读、写可以做到互不影响，这也是oracle广受称赞的地方。SQL Server 的读、写是会相互阻塞的，为了提高并发性能，对于一些查询，可以加上nolock，这样读的时候可以允许写，但缺点是可能读到未提交的脏数据。使用nolock有3条原则。

(1) 查询的结果用于“插、删、改”的不能加nolock ！

(2) 查询的表属于频繁发生页分裂的，慎用nolock ！

(3) 使用临时表一样可以保存“数据前影”，起到类似oracle的undo表空间的功能，

能采用临时表提高并发性能的，不要用nolock 。

9、聚集索引没有建在表的顺序字段上，该表容易发生页分裂

比如订单表，有订单编号orderid，也有客户编号contactid，那么聚集索引应该加在哪个字段上呢？对于该表，订单编号是顺序添加的，如果在orderid上加聚集索引，新增的行都是添加在末尾，这样不容易经常产生页分裂。然而，由于大多数查询都是根据客户编号来查的，因此，将聚集索引加在contactid上才有意义。而contactid对于订单表而言，并非顺序字段。

比如“张三”的“contactid”是001，那么“张三”的订单信息必须都放在这张表的第一个数据页上，如果今天“张三”新下了一个订单，那该订单信息不能放在表的最后一页，而是第一页！如果第一页放满了呢？很抱歉，该表所有数据都要往后移动为这条记录腾地方。

SQL Server的索引和Oracle的索引是不同的，SQL Server的聚集索引实际上是对表按照聚集索引字段的顺序进行了排序，相当于oracle的索引组织表。SQL Server的聚集索引就是表本身的一种组织形式，所以它的效率是非常高的。也正因为此，插入一条记录，它的位置不是随便放的，而是要按照顺序放在该放的数据页，如果那个数据页没有空间了，就引起了页分裂。所以很显然，聚集索引没有建在表的顺序字段上，该表容易发生页分裂。

曾经碰到过一个情况，一位哥们的某张表重建索引后，插入的效率大幅下降了。估计情况大概是这样的。该表的聚集索引可能没有建在表的顺序字段上，该表经常被归档，所以该表的数据是以一种稀疏状态存在的。比如张三下过20张订单，而最近3个月的订单只有5张，归档策略是保留3个月数据，那么张三过去的15张订单已经被归档，留下15个空位，可以在insert发生时重新被利用。在这种情况下由于有空位可以利用，就不会发生页分裂。但是查询性能会比较低，因为查询时必须扫描那些没有数据的空位。

重建聚集索引后情况改变了，因为重建聚集索引就是把表中的数据重新排列一遍，原来的空位没有了，而页的填充率又很高，插入数据经常要发生页分裂，所以性能大幅下降。

对于聚集索引没有建在顺序字段上的表，是否要给与比较低的页填充率？是否要避免重建聚集索引？是一个值得考虑的问题！

10、加nolock后查询经常发生页分裂的表，容易产生跳读或重复读

加nolock后可以在“插、删、改”的同时进行查询，但是由于同时发生“插、删、改”，在某些情况下，一旦该数据页满了，那么页分裂不可避免，而此时nolock的查询正在发生，比如在第100页已经读过的记录，可能会因为页分裂而分到第101页，这有可能使得nolock查询在读101页时重复读到该条数据，产生“重复读”。同理，如果在100页上的数据还没被读到就分到99页去了，那nolock查询有可能会漏过该记录，产生“跳读”。

上面提到的哥们，在加了nolock后一些操作出现报错，估计有可能因为nolock查询产生了重复读，2条相同的记录去插入别的表，当然会发生主键冲突。

11、使用like进行模糊查询时应注意

有的时候会需要进行一些模糊查询比如

Select * from contact where username like ‘%yue%’

关键词%yue%，由于yue前面用到了“%”，因此该查询必然走全表扫描，除非必要，否则不要在关键词前加%，

12、数据类型的隐式转换对查询效率的影响

sql server2000的数据库，我们的程序在提交sql语句的时候，没有使用强类型提交这个字段的值，由sql server 2000自动转换数据类型，会导致传入的参数与主键字段类型不一致，这个时候sql server 2000可能就会使用全表扫描。Sql2005上没有发现这种问题，但是还是应该注意一下。

13、SQL Server 表连接的三种方式

(1) Merge Join

(2) Nested Loop Join

(3) Hash Join

SQL Server 2000只有一种join方式——Nested Loop Join，如果A结果集较小，那就默认作为外表，A中每条记录都要去B中扫描一遍，实际扫过的行数相当于A结果集行数x B结果集行数。所以如果两个结果集都很大，那Join的结果很糟糕。

SQL Server 2005新增了Merge Join，如果A表和B表的连接字段正好是聚集索引所在字段，那么表的顺序已经排好，只要两边拼上去就行了，这种join的开销相当于A表的结果集行数加上B表的结果集行数，一个是加，一个是乘，可见merge join 的效果要比Nested Loop Join好多了。

如果连接的字段上没有索引，那SQL2000的效率是相当低的，而SQL2005提供了Hash join，相当于临时给A，B表的结果集加上索引，因此SQL2005的效率比SQL2000有很大提高，我认为，这是一个重要的原因。

总结一下，在表连接时要注意以下几点：

(1) 连接字段尽量选择聚集索引所在的字段

(2) 仔细考虑where条件，尽量减小A、B表的结果集

(3) 如果很多join的连接字段都缺少索引，而你还在用SQL2000，干紧升级吧.

二、书写注意

DBA必备的SQL好习惯带来一笔大财富

标签： SQL Server

　　【IT168 评论】我们做软件开发的，大部分人都离不开跟数据库打交道，特别是erp开发的，跟数据库打交道更是频繁，存储过程动不动就是上千行，如果数据量大，人员流动大，那么我么还能保证下一段时间系统还能流畅的运行吗?那么还能保证下一个人能看懂我么的存储过程吗?那么我结合公司平时的培训和平时个人工作经验和大家分享一下，希望对大家有帮助。

　　要知道sql语句，我想我们有必要知道sqlserver查询分析器怎么执行我么sql语句的，我么很多人会看执行计划，或者用profile来监视和调优查询语句或者存储过程慢的原因，但是如果我们知道查询分析器的执行逻辑顺序，下手的时候就胸有成竹，那么下手是不是有把握点呢?

　　一：查询的逻辑执行顺序

(1) FROM < left_table>
　　(2) ON < join_condition>
　　(3) < join_type> JOIN < right_table>
　　(4) WHERE < where_condition>
　　(5) GROUP BY < group_by_list>
　　(6) WITH {cube | rollup}
　　(7) HAVING < having_condition>
　　(8) SELECT (9) DISTINCT (11) < top_specification> < select_list>
　　(10) ORDER BY < order_by_list>

　　标准的SQL 的解析顺序为:

　　(1).FROM 子句组装来自不同数据源的数据

　　(2).WHERE 子句基于指定的条件对记录进行筛选

　　(3).GROUP BY 子句将数据划分为多个分组

　　(4).使用聚合函数进行计算

　　(5).使用HAVING子句筛选分组

　　(6).计算所有的表达式

　　(7).使用ORDER BY对结果集进行排序

　　二执行顺序：

　　1.FROM：对FROM子句中前两个表执行笛卡尔积生成虚拟表vt1

　　2.ON:对vt1表应用ON筛选器只有满足< join_condition> 为真的行才被插入vt2

　　3.OUTER(join)：如果指定了 OUTER JOIN保留表(preserved table)中未找到的行将行作为外部行添加到vt2 生成vt3如果from包含两个以上表则对上一个联结生成的结果表和下一个表重复执行步骤和步骤直接结束

　　4.WHERE：对vt3应用 WHERE 筛选器只有使< where_condition> 为true的行才被插入vt4

　　5.GROUP BY：按GROUP BY子句中的列列表对vt4中的行分组生成vt5

　　6.CUBE|ROLLUP：把超组(supergroups)插入vt6 生成vt6

　　7.HAVING：对vt6应用HAVING筛选器只有使< having_condition> 为true的组才插入vt7

　　8.SELECT：处理select列表产生vt8

　　9.DISTINCT：将重复的行从vt8中去除产生vt9

　　10.ORDER BY：将vt9的行按order by子句中的列列表排序生成一个游标vc10

　　11.TOP：从vc10的开始处选择指定数量或比例的行生成vt11 并返回调用者

　　看到这里，那么用过linqtosql的语法有点相似啊?如果我们我们了解了sqlserver执行顺序，那么我们就接下来进一步养成日常sql好习惯，也就是在实现功能同时有考虑性能的思想，数据库是能进行集合运算的工具，我们应该尽量的利用这个工具，所谓集合运算实际就是批量运算，就是尽量减少在客户端进行大数据量的循环操作，而用SQL语句或者存储过程代替。

　　三、只返回需要的数据

　　返回数据到客户端至少需要数据库提取数据、网络传输数据、客户端接收数据以及客户端处理数据等环节，如果返回不需要的数据，就会增加服务器、网络和客户端的无效劳动，其害处是显而易见的，避免这类事件需要注意：

　　A、横向来看：

　　(1)不要写SELECT *的语句，而是选择你需要的字段。

　　(2)当在SQL语句中连接多个表时, 请使用表的别名并把别名前缀于每个Column上.这样一来,就可以减少解析的时间并减少那些由Column歧义引起的语法错误。

　　如有表table1(ID,col1)和table2

(ID,col2) Select A.ID, A.col1, B.col2
　　-- Select A.ID, col1, col2 –不要这么写，不利于将来程序扩展
　　from table1 A inner join table2 B on A.ID=B.ID Where …

　　B、纵向来看：

　　(1)合理写WHERE子句，不要写没有WHERE的SQL语句。

　　(2) SELECT TOP N * --没有WHERE条件的用此替代

　　四：尽量少做重复的工作

　　A、控制同一语句的多次执行，特别是一些基础数据的多次执行是很多程序员很少注意的。

　　B、减少多次的数据转换，也许需要数据转换是设计的问题，但是减少次数是程序员可以做到的。

　　C、杜绝不必要的子查询和连接表，子查询在执行计划一般解释成外连接，多余的连接表带来额外的开销。

　　D、合并对同一表同一条件的多次UPDATE，比如：

UPDATE EMPLOYEE SET FNAME='HAIWER'

WHERE EMP_ID=' VPA30890F' UPDATE EMPLOYEE SET LNAME='YANG' 

WHERE EMP_ID=' VPA30890F'

　　这两个语句应该合并成以下一个语句

UPDATE EMPLOYEE SET
FNAME='HAIWER',LNAME='YANG' WHERE EMP_ID=' VPA30890F'

　　E、UPDATE操作不要拆成DELETE操作+INSERT操作的形式，虽然功能相同，但是性能差别是很大的。

　　五、注意临时表和表变量的用法

　　在复杂系统中，临时表和表变量很难避免，关于临时表和表变量的用法，需要注意：

　　A、如果语句很复杂，连接太多，可以考虑用临时表和表变量分步完成。

　　B、如果需要多次用到一个大表的同一部分数据，考虑用临时表和表变量暂存这部分数据。

　　C、如果需要综合多个表的数据，形成一个结果，可以考虑用临时表和表变量分步汇总这多个表的数据。

　　D、其他情况下，应该控制临时表和表变量的使用。

　　E、关于临时表和表变量的选择，很多说法是表变量在内存，速度快，应该首选表变量，但是在实际使用中发现，

　　(1)主要考虑需要放在临时表的数据量，在数据量较多的情况下，临时表的速度反而更快。

　　(2)执行时间段与预计执行时间(多长)

　　F、关于临时表产生使用SELECT INTO和CREATE TABLE + INSERT INTO的选择，一般情况下，

　　SELECT INTO会比CREATE TABLE + INSERT INTO的方法快很多，

　　但是SELECT INTO会锁定TEMPDB的系统表SYSOBJECTS、SYSINDEXES、SYSCOLUMNS，在多用户并发环境下，容易阻塞其他进程，

　　所以我的建议是，在并发系统中，尽量使用CREATE TABLE + INSERT INTO，而大数据量的单个语句使用中，使用SELECT INTO。

　　六、子查询的用法

　　子查询是一个 SELECT 查询，它嵌套在 SELECT、INSERT、UPDATE、DELETE 语句或其它子查询中。

　　任何允许使用表达式的地方都可以使用子查询，子查询可以使我们的编程灵活多样，可以用来实现一些特殊的功能。但是在性能上，

　　往往一个不合适的子查询用法会形成一个性能瓶颈。如果子查询的条件中使用了其外层的表的字段，这种子查询就叫作相关子查询。

　　相关子查询可以用IN、NOT IN、EXISTS、NOT EXISTS引入。关于相关子查询，应该注意：

　　(1)

　　A、NOT IN、NOT EXISTS的相关子查询可以改用LEFT JOIN代替写法。

比如： 
SELECT PUB_NAME FROM PUBLISHERS 

WHERE PUB_ID NOT IN (SELECT PUB_ID FROM TITLES 

WHERE TYPE = 'BUSINESS') 可以改写成：
SELECT A.PUB_NAME FROM PUBLISHERS A LEFT 

JOIN TITLES B ON B.TYPE = 'BUSINESS' AND A.PUB_ID=B. PUB_ID 

WHERE B.PUB_ID IS NULL　　(2)
SELECT TITLE FROM TITLES 

WHERE NOT EXISTS (SELECT TITLE_ID FROM SALES 

WHERE TITLE_ID = TITLES.TITLE_ID)　　可以改写成：
SELECT TITLE FROM TITLES LEFT JOIN SALES ON SALES.TITLE_ID = TITLES.TITLE_ID 

WHERE SALES.TITLE_ID IS NULL　　B、 如果保证子查询没有重复 ，IN、EXISTS的相关子查询可以用INNER JOIN 代替。比如：
SELECT PUB_NAME FROM PUBLISHERS 

WHERE PUB_ID IN (SELECT PUB_ID FROM TITLES 

WHERE TYPE = 'BUSINESS')　　可以改写成：
SELECT A.PUB_NAME --SELECT DISTINCT A.PUB_NAME 

FROM PUBLISHERS A INNER JOIN TITLES B ON B.TYPE = 'BUSINESS' AND A.PUB_ID=B. PUB_ID　　(3)
　　C、 IN的相关子查询用EXISTS代替，比如
SELECT PUB_NAME FROM PUBLISHERS 

WHERE PUB_ID IN (SELECT PUB_ID FROM TITLES 

WHERE TYPE = 'BUSINESS')　　可以用下面语句代替：
SELECT PUB_NAME FROM PUBLISHERS 

WHERE EXISTS (SELECT 1 FROM TITLES 

WHERE TYPE = 'BUSINESS' AND PUB_ID= PUBLISHERS.PUB_ID)　　D、不要用COUNT(*)的子查询判断是否存在记录，最好用LEFT JOIN或者EXISTS，比如有人写这样的语句：
SELECT JOB_DESC FROM JOBS 

WHERE (SELECT COUNT(*) FROM EMPLOYEE

WHERE JOB_ID=JOBS.JOB_ID)=0　　应该改成：
SELECT JOBS.JOB_DESC FROM JOBS 

LEFT JOIN EMPLOYEE ON EMPLOYEE.JOB_ID=JOBS.JOB_ID 

WHERE EMPLOYEE.EMP_ID IS NULL 

SELECT JOB_DESC FROM JOBS 

WHERE (SELECT COUNT(*) FROM EMPLOYEE

WHERE JOB_ID=JOBS.JOB_ID)<>0　　应该改成：
SELECT JOB_DESC FROM JOBS 

WHERE EXISTS (SELECT 1 FROM EMPLOYEE WHERE JOB_ID=JOBS.JOB_ID)

　　七：尽量使用索引

　　建立索引后，并不是每个查询都会使用索引，在使用索引的情况下，索引的使用效率也会有很大的差别。只要我们在查询语句中没有强制指定索引，

　　索引的选择和使用方法是SQLSERVER的优化器自动作的选择，而它选择的根据是查询语句的条件以及相关表的统计信息，这就要求我们在写SQL

　　语句的时候尽量使得优化器可以使用索引。为了使得优化器能高效使用索引，写语句的时候应该注意：

　　A、不要对索引字段进行运算，而要想办法做变换，比如

SELECT ID FROM T WHERE NUM/2=100
　　应改为:
　　SELECT ID FROM T WHERE NUM=100*2
　　-------------------------------------------------------
　　SELECT ID FROM T WHERE NUM/2=NUM1
　　如果NUM有索引应改为:
　　SELECT ID FROM T WHERE NUM=NUM1*2

　　如果NUM1有索引则不应该改。

　　--------------------------------------------------------------------

　　发现过这样的语句：

SELECT 年,月,金额 FROM 结余表 WHERE 100*年+月=2010*100+10
　　应该改为：
　　SELECT 年,月,金额 FROM 结余表 WHERE 年=2010 AND月=10
　　B、 不要对索引字段进行格式转换
　　日期字段的例子：
　　WHERE CONVERT(VARCHAR(10), 日期字段,120)='2010-07-15'
　　应该改为
　　WHERE日期字段〉='2010-07-15'
AND 日期字段<'2010-07-16'
　　ISNULL转换的例子：
　　WHERE ISNULL(字段,'')<>''应改为:WHERE字段<>''
　　WHERE ISNULL(字段,'')=''不应修改
　　WHERE ISNULL(字段,'F') ='T'应改为: WHERE字段='T'
　　WHERE ISNULL(字段,'F')<>'T'不应修改
　　C、 不要对索引字段使用函数
　　WHERE LEFT(NAME, 3)='ABC' 或者WHERE SUBSTRING(NAME,1, 3)='ABC'
　　应改为: WHERE NAME LIKE 'ABC%'
　　日期查询的例子：
　　WHERE DATEDIFF(DAY, 日期,'2010-06-30')=0
　　应改为:WHERE 日期>='2010-06-30'
AND 日期 <'2010-07-01'
　　WHERE DATEDIFF(DAY, 日期,'2010-06-30')>0
　　应改为:WHERE 日期 <'2010-06-30'
　　WHERE DATEDIFF(DAY, 日期,'2010-06-30')>=0
　　应改为:WHERE 日期
<'2010-07-01'
　　WHERE DATEDIFF(DAY, 日期,'2010-06-30')<0
　　应改为:WHERE 日期>='2010-07-01'
　　WHERE DATEDIFF(DAY, 日期,'2010-06-30')<=0
　　应改为:WHERE 日期>='2010-06-30'
　　D、不要对索引字段进行多字段连接
　　比如：
　　WHERE FAME+ '. '+LNAME='HAIWEI.YANG'
　　应改为:
　　WHERE FNAME='HAIWEI' AND LNAME='YANG'

　　八：多表连接的连接条件对索引的选择有着重要的意义，所以我们在写连接条件条件的时候需要特别注意。

　　A、多表连接的时候，连接条件必须写全，宁可重复，不要缺漏。

　　B、连接条件尽量使用聚集索引

　　C、注意ON、WHERE和HAVING部分条件的区别

　　ON是最先执行， WHERE次之，HAVING最后，因为ON是先把不符合条件的记录过滤后才进行统计，它就可以减少中间运算要处理的数据，按理说应该速度是最快的，WHERE也应该比 HAVING快点的，因为它过滤数据后才进行SUM，在两个表联接时才用ON的，所以在一个表的时候，就剩下WHERE跟HAVING比较了

　　1考虑联接优先顺序：

2INNER JOIN
　　3LEFT JOIN (注：RIGHT JOIN 用 LEFT JOIN 替代)
　　4CROSS JOIN

　　其它注意和了解的地方有：

　　A、在IN后面值的列表中，将出现最频繁的值放在最前面，出现得最少的放在最后面，减少判断的次数

　　B、注意UNION和UNION ALL的区别。--允许重复数据用UNION ALL好

　　C、注意使用DISTINCT，在没有必要时不要用

　　D、TRUNCATE TABLE 与 DELETE 区别

　　E、减少访问数据库的次数

　　还有就是我们写存储过程，如果比较长的话，最后用标记符标开，因为这样可读性很好，即使语句写的不怎么样但是语句工整，C# 有region

　　sql我比较喜欢用的就是

　　--startof 查询在职人数 sql语句 --end of

　　正式机器上我们一般不能随便调试程序，但是很多时候程序在我们本机上没问题，但是进正式系统就有问题，但是我们又不能随便在正式机器上操作，那么怎么办呢?我们可以用回滚来调试我们的存储过程或者是sql语句，从而排错。

　　BEGIN TRAN UPDATE a SET 字段='' ROLLBACK

　　作业存储过程我一般会加上下面这段，这样检查错误可以放在存储过程，如果执行错误回滚操作，但是如果程序里面已经有了事务回滚，那么存储过程就不要写事务了，这样会导致事务回滚嵌套降低执行效率，但是我们很多时候可以把检查放在存储过程里，这样有利于我们解读这个存储过程，和排错。

BEGIN TRANSACTION
--事务回滚开始
--检查报错

IF ( @@ERROR > 0 )

          BEGIN

         --回滚操作

                  ROLLBACK TRANSACTION

                 RAISERROR('删除工作报告错误', 16, 3)

                  RETURN

         END --结束事务

  COMMIT TRANSACTION

　　好久没有写博文了，工作项目一个接一个，再加上公司人员流动，新人很多事情接不下来，加班成了家常便饭，仓促写下这些希望对大家有帮助，不对的也欢迎指点，交流互相提高。

　　有错误的地方欢迎大家拍砖,希望交流和共享。

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。