博客园_MR_ke

查看sql修改痕迹（SQL Change Tracking on Table）

2012-03-02T06:23:00Z

申明本博客转至http://www.codeproject.com/Articles/338724/SQL-Change-Tracking-on-Table

在阅读这篇博客之前，我想告诉你我并不是经常写博客，这只是一个尝试，如果写的不好请见谅，我仅仅想告诉你们一些sql内在机制。

凭经验，很多时候我们都人事为触发器不是最好查找一个表修改痕迹的方法，触发器跟插入修改删除等动作紧紧的联系再一次，可能在我们

未来的修改发布中产生很多问题。那我现在告诉你一个及时查看修改表记录的方法。

1.修改数据库配置，允许数据库进行修改跟踪。

Alter Database RDCC
set change_tracking = on
(change_retention = 2 days, auto_cleanup = on);

数据库修改跟踪权限开启了，不是所有表的跟踪权限都开启了，每个表还必须单独开启。

2.首先我们建一个简单的表然后插入几条记录。

Create table Employee
(
EmployeeID nvarchar(10) primary key,
FirstName nvarchar(100),
LastName nvarchar(100),
Phone1 nvarchar(10)
)

insert into Employee (EmployeeID,FirstName,LastName,Phone1) Values ('E001','Santosh','Poojari','1111111111')
insert into Employee (EmployeeID,FirstName,LastName,Phone1) Values ('E002','Karan','Shah','2222222222')
insert into Employee (EmployeeID,FirstName,LastName,Phone1) Values ('E003','Vineesh','Padmanabhan','3333333333')
insert into Employee (EmployeeID,FirstName,LastName,Phone1) Values ('E004','Gautam','Sharma','4444444444')

在数据库允许跟踪之后，我们还必须把把表设置成可跟踪。

ALTER TABLE Employee ENABLE CHANGE_TRACKING WITH (TRACK_COLUMNS_UPDATED = ON);

那么现在我们开始跟踪表的修改

update employee set Phone1 ='12121212' where EmployeeID ='E001'
update employee set Phone1 ='21212121' where EmployeeID ='E002'

然后我们查看修改记录：

SELECT ISNUll(pn.EmployeeID,0) as EmployeeID
from changetable(changes employee, 1) as ct
INNER JOIN employee pn on pn.EmployeeID = CT.EmployeeID
WHERE SYS_CHANGE_VERSION > 1 and CT.Sys_Change_Operation <>'D'

我们看到的是employee表修改过的EmployeeID对应的行值。

下面我们看看整个修改记录：

SELECT *
from changetable(changes employee, 1) as ct
INNER JOIN employee pn on pn.EmployeeID = CT.EmployeeID
WHERE SYS_CHANGE_VERSION > 1 and CT.Sys_Change_Operation <> 'D'

列SYS_CHANGE_OPERATION显示的是操作类型，那么我们再做一条插入操作并查看结果：

insert into Employee (EmployeeID,FirstName,LastName,Phone1) Values ('E006','S','G','555555')

GO

SELECT *
from changetable(changes employee, 1) as ct
INNER JOIN employee pn on pn.EmployeeID = CT.EmployeeID
WHERE SYS_CHANGE_VERSION > 1 and CT.Sys_Change_Operation <> 'D'

那么我们看到SYS_CHANGE_OPERATION多了一条插入记录类型为I.那么数据库表的任意改动我们都可以通过代码跟踪到。而且一个修改记录的即（sys_change_version）从创建开始，会在系统表里保存两天。

本文链接

sql server复灾你懂了吗？

2011-06-12T08:34:00Z

很多时候我们不小心错误delete了一下，或者update一下怎么办，或者直接把数据库删除了，怎么办呢，是不是就一定没有办法呢？下面让我来教大家我现学现卖的两招。
当我们不小心删除表怎么办？

做之前我们要设置数据库恢复模式：

设置成完整，不要是简单模式。

首先我们创建一个表：插入几条数据

CREATE DATABASE test1

CREATE TABLE A1

(

ID INT PRIMARY KEY

)

INSERT INTO dbo.A1 ( ID )

VALUES ( 0 )

INSERT INTO dbo.A1( ID )

VALUES ( 2)

INSERT INTO dbo.A1( ID )

VALUES ( 3)

INSERT INTO dbo.A1 ( ID )

VALUES ( 4 )

INSERT INTO dbo.A1( ID )

VALUES ( 5 )

SELECT * FROM dbo.A1
我们现在有五条数据了，我们对数据做一个备份

做任何差异备份，和日志之前，一定要做一个完整备份。

我们再插入一条数据

INSERT INTO dbo.A1

( ID )

VALUES ( 6)

SELECT * FROM dbo.A1我们看看现在有六条数据了。

关键来了：不小心

数据删除了，一条也没有了怎么办？

不要慌赶快备份啊。备份数据之后，我们开始来恢复，记住一定要备份在恢复之前哦。这里要做的是日志备份，做完日志备份再恢复数据。

这里要注意时间，我们要选择恢复时间，也就是在你删除的前一刻，然后我们看看6条数据又回来了。

3. 我们删除表数据可以恢复，万一你把数据库服务down掉，然后删除了数据库文件没了呢？

先建表插入数据如下：

现在有五条数据，然后完整备份，再插入一条数据。

现在有6条数据，做个日志备份

再插入一条数据

然后把数据库服务停掉，然后我们把数据库文件移除掉。

然后把数据库文件放到一个新建的文件夹里面去,但是日志文件还在的，如果日志文件也没有了，那就求苍天保佑吧，这也是我们把数据文件和日志文件分开的好处之一。

然后我们再启动服务

这个时候test1数据库在，但是你打开的时候一定会报错的。

那么恢复之前我们需要做一个日志尾备份，因为数据库不能用，所以我们要用。

backup log test1 to disk='c:\test1.bak' with no_truncate;

我们查看一下我们的备份。

恢复之前要做一下查看。

检查备份完整性

restore verifyonly from disk='c:\test1.bak' ;

查看备份文件数目

restore filelistonly from disk='c:\test1.bak' ;

查看备份记录次数

restore headeronly from disk='c:\test1.bak' ;

我们会发现这里的备份次数比备份文件夹多了一个记录，这是为什么呢？

是因为我们做了一个日志尾备份。

好了我们来恢复数据吧。

然后我们恢复一个数据库test2出来了，然后查询数据

这里我们只有六条数据了，而不是七条数据，有数据丢失了怎么办呢？

原因在：我们可以看到上面我们后台查出的是三条备份次数，但是结果只有两个备份文件记录，那是不是我们最后的日志尾没有了呢？

不是的这时候我们要手动备份了

RESTORE DATABASE [test2] FROM DISK = N'C:\test1.bak' WITH FILE = 1, NORECOVERY, replace

RESTORE LOG [test2] FROM DISK = N'C:\test1.bak' WITH FILE = 2, NORECOVERY

RESTORE LOG [test2] FROM DISK = N'C:\test1.bak' WITH FILE = 3, NORECOVERY

注意：

restore headeronly from disk='c:\test1.bak' ;

上面file=1里的1是和我们查出来的 1 2 3 对应的。

诶，怎么test2还在还原呢？

哦，原来最后一个是NOrecovery我们改成Recovery

RESTORE DATABASE [test2] FROM DISK = N'C:\test1.bak' WITH FILE = 1, NORECOVERY, replace

RESTORE LOG [test2] FROM DISK = N'C:\test1.bak' WITH FILE = 2, NORECOVERY

RESTORE LOG [test2] FROM DISK = N'C:\test1.bak' WITH FILE = 3, RECOVERY

哦，数据回来了，看看有七条了。

看到这里你是否有收获呢？

最后我们看一份数据

这个数据是不是很有规律啊？

我们可以看到日志备份databasebackuplsn字段数据都是第一份完整备份的checkpoitlsn的数据。

如果这个数值对不上，我们自求多福吧，恢复不了了。。。。

本文链接

sql server管理这些你懂吗？

2011-06-12T07:19:00Z

1. 数据库文件有.mdf .ndf .ldf三种文件，mfd为主数据库文件，ndf为从数据库文件，ldf为日志数据库文件，每个数据库mdf文件只有一个，ndf文件可以有多个。

2. 数据页大小为8k，sql数据库最大一个特性是数据无跨页，比如一条数据3k，那么5条数据需要3页存储，而不是两页。数据库扩展页是8页，也就是如果一张表存储空间不够了，我们要插入一条3k的数据，数据库不是分配一页，而是8页，也就是64k空间，这个我们windows系统也是，我们见一个文本文件，然后输入一个a，那么这时候系统为我们文件分配的内存不是2个字节，而是1k空间。

如果一个数据页大小只有8k，那么像txt，image这些数据怎么存储呢？

那么我们这时系统存储的是txt，image的堆地址，她们的数据存储在堆里，那么他们地址最多不会超过8字节。

3. 数据库内存，我们读取一条数据是先在内存里找，如果内存没有，我们就会在数据库里面找，然后把数据读到内存里面来。那么我们更新一条数据呢？

我们更新（增、删、改）一条数据不是commit的时候数据就写到数据库里了，而是数据库会有一个chekpoints，在checkpoints的时候数据库，会一页一页的把数据往数据库里写。这个在sql2005里的时间大概是15分钟只需一次，那么没有交易的数据在哪里呢？那么可能存在两个地方，一个是在temptdb里面，一个是在buffercahce里面。

4. 对大的系统数据库应注意几个问题，我们都知道数据库瓶颈是磁盘阵列有I/O瓶颈，如果我们数据库超作频繁，这样我们数据库日志文件增大比较快，如果我们把数据库文件和日志文件放在一个磁盘里那么，会导致越来操作数据库的数据越慢，那么我们可以把日志文件和数据文件放在不同的磁盘里，一个磁盘两个通道，如果放在不同磁盘那么写数据和日志可以并行超作了，还有我们每天最好6个小时做一次日志备份，这样我们可以减小我们的日志文件大小，因为日志文件备份后就从日志里面删除了。

5. 数据库文件组的利用，如果我们数据库设计很大，我们还可以设计数据库文件组，把不同的数据放在不同的文件组，不同文件组放在不同磁盘，如果表大，我们还可以把一个表放在不同文件组，很多时候我们把一个表放在不同文件组，可能比放在一个文件组快，因为放在不同文件组是并行访问的，但是放在一个文件组需要顺序访问，一般没有必要的情况下，还是建议大家做表分区。

6. 建数据库的时候我们需要注意，我们数据文件放在磁盘的格式fat32的允许数据库文件最大为2g如果我们建立好数据库后再发现这个问题就麻烦了，要不停的加数据库文件，所以建议放在NTFs格式磁盘上，数据库最大容量修改规则，能改大不能该小，那么有没有把数据库改小的办法呢？有的压缩数据库。

这里我们可以压缩数据大小。

7. 备份数据库注意事项：

1.一定要选上下面那两个勾，这样保证我们备份成功。

我们备份数据库（特别是做维护计划的时候）的最好步骤一般用

1. 检查数据库的完整性

2. 日志尾备份（后面我们复灾的时候会讲到）

3. 备份

最好这几个是有顺序来自。

我们备份一周备份最好是周末完整备份，1-5差异备份，6小时做一次日志备份

8. 数据库性能监视打开方法：

比如我们监视应用程序引起的sqlserver死锁添加监视：

我们可以看到如下：

都是0诶没有死锁，那么证明我们系统很健康啊。。。，但是监视一般是在服务器闲的时候监视，因为这个也是占用资源的。

本文链接

Sql养成一个好习惯是一笔财富

2011-05-29T06:20:00Z

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

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

一：查询的逻辑执行顺序

(1) FROM < left_table>

(3) < join_type> JOIN < right_table> (2) ON < join_condition>

(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 生成t3如果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。

六、子查询的用法（1）

子查询是一个 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

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

（1

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有索引则不应该改。

(2)

发现过这样的语句：
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'不应修改

(3)

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)INNER JOIN
(2)LEFT JOIN (注：RIGHT JOIN 用 LEFT JOIN 替代)
(3)CROSS 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

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

本文链接

sql 2005性能调优

2010-08-25T01:54:00Z

SQL Server在运行一段时间，随着数据的积累，SQL运行效率会逐步降低，为了使用业务系统正常动作，经常IT部门需要花高价请SQL调优专家来解决。其实调优也不复杂，主要是找到影响效率的SQL，然后对症下药，这里给出几个技巧，相信对大家非常实用。
1、检查SQL阻塞原因

select blocking_session_id, wait_duration_ms, session_id
from sys.dm_os_waiting_tasks
where blocking_session_id is not null

2、检查前10个等待资源的SQL语句

select top 10 *
from sys.dm_os_wait_stats
order by wait_time_ms desc

3、查询显示 CPU 平均占用率最高的前50个SQL 语句

SELECT TOP 50 total_worker_time/execution_count AS [Avg CPU Time],
(SELECT SUBSTRING(text,statement_start_offset/2,(CASE WHEN statement_end_offset = -1 then LEN(CONVERT(nvarchar(max), text)) * 2 ELSE statement_end_offset end -statement_start_offset)/2) FROM sys.dm_exec_sql_text(sql_handle)) AS query_text, *
FROM sys.dm_exec_query_stats
ORDER BY [Avg CPU Time] DESC

4、CPU 瓶颈通常由以下原因引起：查询计划并非最优、配置不当、设计因素不良或硬件资源不足。下面的常用查询可帮助您确定导致CPU瓶颈的原因。下面的查询使您能够深入了解当前缓存的哪些批处理或过程占用了大部分CPU资源。

SELECT TOP 50
SUM(qs.total_worker_time) AS total_cpu_time,
SUM(qs.execution_count) AS total_execution_count,
COUNT(*) AS number_of_statements,
qs.sql_handle
FROM sys.dm_exec_query_stats AS qs
GROUP BY qs.sql_handle
ORDER BY SUM(qs.total_worker_time) DESC

5、下面的查询显示缓存计划所占用的CPU总使用率（带 SQL 文本）。

SELECT
total_cpu_time,
total_execution_count,
number_of_statements,
s2.text
ROM
(SELECT TOP 50
SUM(qs.total_worker_time) AS total_cpu_time,
SUM(qs.execution_count) AS total_execution_count,
COUNT(*) AS number_of_statements,
qs.sql_handle
FROM
sys.dm_exec_query_stats AS qs
GROUP BY qs.sql_handle
ORDER BY SUM(qs.total_worker_time) DESC) AS stats
CROSS APPLY sys.dm_exec_sql_text(stats.sql_handle) AS s2

6、下面的示例查询显示已重新编译的前 25 个存储过程。plan_generation_num 指示该查询已重新编译的次数。

select top 25
sql_text.text,
sql_handle,
plan_generation_num,
execution_count,
dbid,
objectid
from sys.dm_exec_query_stats a
cross apply sys.dm_exec_sql_text(sql_handle) as sql_text
where plan_generation_num > 1
order by plan_generation_num desc

7、效率较低的查询计划可能增大 CPU 占用率。下面的查询显示哪个查询占用了最多的 CPU 累计使用率。

SELECT
highest_cpu_queries.plan_handle, highest_cpu_queries.total_worker_time, q.dbid, q.objectid, q.number, q.encrypted, q.[text]
from
(select top 50 qs.plan_handle, qs.total_worker_time from sys.dm_exec_query_stats qs order by qs.total_worker_time desc) as highest_cpu_queries
cross apply sys.dm_exec_sql_text(plan_handle) as q
order by highest_cpu_queries.total_worker_time desc

8、下面的查询显示一些可能占用大量 CPU 使用率的运算符（例如 ‘%Hash Match%’、‘%Sort%’）以找出可疑对象。

select *
from
sys.dm_exec_cached_plans
cross apply sys.dm_exec_query_plan(plan_handle)
where
cast(query_plan as nvarchar(max)) like '%Sort%'
or cast(query_plan as nvarchar(max)) like '%Hash Match%'

9、如果已检测到效率低下并导致 CPU 占用率较高的查询计划，请对该查询中涉及的表运行 UPDATE STATISTICS 以查看该问题是否仍然存在。然后，收集相关数据并将此问题报告给 PerformancePoint Planning 支持人员。如果您的系统存在过多的编译和重新编译，可能会导致系统出现与 CPU 相关的性能问题。您可以运行下面的 DMV 查询来找出过多的编译/重新编译。

select * from sys.dm_exec_query_optimizer_info
where counter = 'optimizations' or counter = 'elapsed time'

本文链接

SqlServer 2005处理xml格式

2010-08-23T07:06:00Z

今天，在csdn上看到一则处理xml的问题，以前也有写过xml的查询，下面是问题

declare @x xml,@y xml
set @x='<item>
<id>1 </id>
<title>姓名 </title>
<value> </value>
</item>
<item>
<id>2 </id>
<title>年龄 </title>
<value> </value>
</item>
'
set @y='<item>
<id>1 </id>
<value>张三 </value>
</item>
<item>
<id>2 </id>
<value>20 </value>
</item>
'有连个变量如上所示：
现在要求得到下面的格式：
/*
<item>
<id>1</id>
<title>姓名 </title>
<value>张三 </value>
</item>
<item>
<id>2</id>
<title>年龄 </title>
<value>20 </value>
</item>
*/

下面是xml操作的答案：

select
D.x.value('./id[1]','int') AS id,
D.x.value('./title[1]','nvarchar(100)') AS title,
D.x.value('./value[1]','nvarchar(100)') AS [value]
from @x.nodes('/*') as D(x)

;with t1
as(
select
D.x.value('./id[1]','int') AS id,
D.x.value('./title[1]','nvarchar(100)') AS title,
D.x.value('./value[1]','nvarchar(100)') AS [value]
from @x.nodes('/*') as D(x)),
t2
as(
select
D.x.value('./id[1]','int') AS id,
D.x.value('./value[1]','nvarchar(100)') AS [value]
from @y.nodes('/*') as D(x))
select a.id,title,b.[value]
from t1 as a
left join t2 as b on a.id = b.id
for xml path('item')

随着标准化的执行，我相信以后sql里会有更多对xml的操作。

下面解读一下上面的sql：

WITH AS短语，也叫做子查询部分（subquery factoring），可以让你做很多事情，定义一个SQL片断，该SQL片断会被整个SQL语句所用到。有的时候，是为了让SQL语句的可读性更高些，也有可能是在UNION ALL的不同部分，作为提供数据的部分。
特别对于UNION ALL比较有用。因为UNION ALL的每个部分可能相同，但是如果每个部分都去执行一遍的话，则成本太高，所以可以使用WITH AS短语，则只要执行一遍即可。如果WITH AS短语所定义的表名被调用两次以上，则优化器会自动将WITH AS短语所获取的数据放入一个TEMP表里，如果只是被调用一次，则不会。而提示materialize则是强制将WITH AS短语里的数据放入一个全局临时表里。很多查询通过这种方法都可以提高速度。

然后就是两个对xml操作的函数：

如果希望将 XML 数据类型实例拆分为关系数据，nodes() 方法十分有用。它允许您标识将映射到新行的节点。

每一个 xml 数据类型实例都具有隐式提供的上下文节点。对于在列或变量中存储的 XML 实例来说，它是文档节点。文档节点是位于每个 xml 数据类型实例顶部的隐式节点。 nodes() 方法的结果是一个包含原始 XML 实例的逻辑副本的行集。在这些逻辑副本中，每个行示例的上下文节点都被设置成由查询表达式标识的节点之一。这样，后续的查询可以浏览与这些上下文节点相关的节点。您可以从行集中检索多个值。例如，可以将 value() 方法应用于 nodes() 所返回的行集，从原始 XML 实例中检索多个值。请注意，当 value() 方法应用于 XML 实例时，它仅返回一个值。

示例
A. 对 xml 类型的变量使用 nodes() 方法
在此示例中，现有一个包含 <Root> 顶级元素和三个 <row> 子元素的 XML 文档。此查询使用 nodes() 方法为每个 <row> 元素设置单独的上下文节点。nodes() 方法返回包含三行的行集。每行都有一个原始 XML 的逻辑副本，其中每个上下文节点都标识原始文档中的一个不同的 <row> 元素。

然后，查询会从每行返回上下文节点：

复制代码
DECLARE @x xml
SET @x='<Root>
<row id="1"><name>Larry</name><oflw>some text</oflw></row>
<row id="2"><name>moe</name></row>
<row id="3" />
</Root>'
SELECT T.c.query('.') AS result
FROM @x.nodes('/Root/row') T(c)
go

结果如下。在此示例中，查询方法返回上下文项及其内容：

复制代码
<row id="1"><name>Larry</name><oflw>some text</oflw></row>
<row id="2"><name>moe</name></row>
<row id="3"/>

对上下文节点应用父级取值函数将返回所有三行的 <Root> 元素。

复制代码
SELECT T.c.query('..') AS result
FROM @x.nodes('/Root/row') T(c)
go

结果如下：

复制代码
<Root>
<row id="1"><name>Larry</name><oflw>some text</oflw></row>
<row id="2"><name>moe</name></row>
<row id="3" />
</Root>
<Root>
<row id="1"><name>Larry</name><oflw>some text</oflw></row>
<row id="2"><name>moe</name></row>
<row id="3" />
</Root>
<Root>
<row id="1"><name>Larry</name><oflw>some text</oflw></row>
<row id="2"><name>moe</name></row>
<row id="3" />
</Root>

下面的查询指定了绝对路径。对使用绝对路径表达式的上下文节点的查询，将从上下文节点的根节点开始进行。因此，您将收到由 nodes() 返回的每个上下文节点的全部三行。

复制代码
SELECT T.c.query('/Root/row') AS result
FROM @x.nodes('/Root/row') T(c)
go
<row id="1"><name>Larry</name><oflw>some text</oflw></row>
<row id="2"><name>moe</name></row>
<row id="3" />
<row id="1"><name>Larry</name><oflw>some text</oflw></row>
<row id="2"><name>moe</name></row>
<row id="3" />
<row id="1"><name>Larry</name><oflw>some text</oflw></row>
<row id="2"><name>moe</name></row>
<row id="3" />

请注意，由 xml 数据类型的 nodes() 方法返回的列无法直接使用。例如，下面的查询将返回错误：

复制代码
...
SELECT T.c
FROM @x.nodes('/Root/row') T(c)

在以下查询中，xml 数据类型的 value() 和 query() 方法应用到由 nodes() 方法返回的行集中。value() 方法返回上下文项 (<row>) 的 id 属性；query() 方法返回上下文项的 <name> 元素子树。

复制代码
DECLARE @x xml
SET @x='
<Root>
<row id="1"><name>Larry</name><oflw>some text</oflw></row>
<row id="2"><name>Joe</name></row>
<row id="3" />
</Root>
'
SELECT T.c.value('@id','int') as id,
T.c.query('name') as NAME
FROM @x.nodes('/Root/row') T(c)
go

结果如下：

复制代码
id NAME
-----------------------
1 <name>Larry</name>
2 <name>Joe</name>
3

请注意，结果包括行 ID 3 并且 <row> 元素不包含子 <name>。如果您希望对结果进行筛选，以便返回（或不返回）不带子 <name> 的行，就可以使用下列方法之一对其进行筛选：

使用 nodes() 路径表达式（例如 /Root/row[name]）中的谓词。

对行集使用 exist() 方法。

使用 CROSS APPLY。

使用 OUTER APPLY。

以下查询对 nodes() 返回的行集指定 exist() 方法。如果上下文节点 (<row>) 包含子 <name>，则 exist() 方法返回 True。

复制代码
DECLARE @x xml
SET @x='<Root>
<row id="1"><name>Larry</name><oflw>some text</oflw></row>
<row id="2"><name>Joe</name></row>
<row id="3" />
</Root>'
SELECT T1.rows.value('@id','int') as id
FROM @x.nodes('/Root/row') T1(rows)
WHERE T1.rows.exist('name') = 1;
GO

此查询将返回两行：行 ID 分别为 1 和 2。

以下查询使用 OUTER APPLY。OUTER APPLY 将 nodes() 应用于 T1（行）中的每个行，并返回构成结果集的行，也会返回 NULL。因此，WHERE 子句用于筛选行并只检索 T2.names 列不为 NULL 的行。

复制代码
DECLARE @x xml
SET @x='
<Root>
<row id="1"><name>Larry</name><oflw>some text</oflw></row>
<row id="2"><name>Joe</name></row>
<row id="3" />
</Root>'
SELECT T1.rows.value('@id','int') as id
FROM @x.nodes('/Root/row') T1(rows)
OUTER APPLY T1.rows.nodes('./name') as T2(names)
WHERE T2.names is not null
GO

以下查询使用 CROSS APPLY。CROSS APPLY 将 nodes() 应用于外部表 [T1（行）] 中的每一行，并且只返回当 nodes() 应用于 T1.rows 时构成结果集的行。在这种情况下，您不需要 WHERE 子句来测试 IS NOT NULL。

复制代码
DECLARE @x xml
SET @x='<Root>
<row id="1"><name>Larry</name><oflw>some text</oflw></row>
<row id="2"><name>Joe</name></row>
<row id="3" />
</Root>'
SELECT T1.rows.value('@id','int') as id
FROM @x.nodes('/Root/row') T1(rows)
CROSS APPLY T1.rows.nodes('./name') as T2(names)
GO

有关 CROSS APPLY 和 OUTER APPLY 的信息，请参阅使用 APPLY。

B. 针对 xml 类型的列指定 nodes() 方法
在此示例中使用自行车生产说明，并将其存储在 ProductModel 表的 Instructions xml 类型列中。有关详细信息，请参阅 AdventureWorks 数据库中的 xml 数据类型表示形式。

在以下示例中，nodes() 方法是针对 ProductModel 表中 xml 类型的 Instructions 列指定的。

nodes() 方法通过指定 /MI:root/MI:Location 路径将 <Location> 元素设置为上下文节点。结果行集包括原始文档的逻辑副本，每个副本对应文档中的一个 <Location> 节点，上下文节点设置为 <Location> 元素。因此，nodes() 函数给出一组 <Location> 上下文节点。

query() 方法针对此行集请求 self::node，因此将返回每行中的 <Location> 元素。

在此示例中，查询在特定产品样式的生产说明文档中将每一个 <Location> 元素都设置为上下文节点。您可以使用这些上下文节点来按照以下方式来检索值：

在每个 <Location> 中查找 LocationID

在每个 <Location> 中检索生产步骤（<step> 子元素）

此查询使用 query() 方法返回上下文项，其中指定了 self::node() 的缩写语法 "."。

请注意以下方面：

nodes() 方法应用于 Instructions 列并返回一个行集 T (C)。此行集包含将 /root/Location 作为上下文项的原始生产说明文档的逻辑副本。

CROSS APPLY 将 nodes() 应用于 Instructions 表中的每一行，并只返回构成结果集的行。

复制代码
SELECT C.query('.') as result
FROM Production.ProductModel
CROSS APPLY Instructions.nodes('
declare namespace MI="http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelManuInstructions";
/MI:root/MI:Location') as T(C)
WHERE ProductModelID=7

下面是部分结果：

复制代码
<MI:Location LocationID="10" ...>
<MI:step ... />
...
</MI:Location>
<MI:Location LocationID="20" ... >
<MI:step ... />
...
</MI:Location>
...

以下查询与先前的查询相似，但是它通过使用行集中的上下文节点，利用 value() 和 query() 检索一组值。对于每个位置，SELECT 子句都检索在该位置使用的位置 ID 和工具。

复制代码
SELECT C.value('@LocationID','int') as LId,
C.query('declare namespace MI="http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelManuInstructions";
MI:step/MI:tool') as result
FROM Production.ProductModel
CROSS APPLY Instructions.nodes('
declare namespace MI="http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelManuInstructions";
/MI:root/MI:Location') as T(C)
WHERE ProductModelID=7

结果如下。为提高可读性，未显示命名空间。

复制代码
LId result
10 <MI:tool xmlns:MI="...">T-85A framing tool</MI:tool>
<MI:tool xmlns:MI="...">Trim Jig TJ-26</MI:tool>
<MI:tool xmlns:MI="...">router with a carbide tip 15</MI:tool>
<MI:tool xmlns:MI="...">Forming Tool FT-15</MI:tool>
20
30 <MI:tool xmlns:MI="...">standard debur tool</MI:tool>
45 <MI:tool xmlns:MI="...">paint harness</MI:tool>
50
60

C. 将 nodes() 应用于由其他 nodes() 方法返回的行集
以下代码查询 ProductModel 表的 Instructions 列中生产说明的 XML 文档。此查询返回包含产品样式 ID、生产位置和生产步骤的行集。

请注意以下方面：

首先，nodes() 方法应用于 Instructions 列并返回 T1（位置）行集。此行集包含将 /root/Location 作为上下文项的原始生产说明文档的逻辑副本。

其次，nodes() 应用于 T1（位置）行集并返回 T2（步骤）行集。此行集包含将 /root/Location 作为上下文项的原始生产说明文档的逻辑副本。

复制代码
SELECT ProductModelID, Locations.value('./@LocationID','int') as LocID,
steps.query('.') as Step
FROM Production.ProductModel
CROSS APPLY Instructions.nodes('
declare namespace MI="http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelManuInstructions";
/MI:root/MI:Location') as T1(Locations)
CROSS APPLY T1.Locations.nodes('
declare namespace MI="http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelManuInstructions";
./MI:step ') as T2(steps)
WHERE ProductModelID=7
go
-- result
ProductModelID LocID Step
----------------------------
7 10 <step ... />
7 10 <step ... />
...
7 20 <step ... />
7 20 <step ... />
7 20 <step ... />
...

此查询两次声明 MI 前缀。此外，您可以使用 WITH XMLNAMESPACES 来声明一次前缀并在查询中使用它：

复制代码
WITH XMLNAMESPACES (
'http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelManuInstructions' AS MI)

SELECT ProductModelID, Locations.value('./@LocationID','int') as LocID,
steps.query('.') as Step
FROM Production.ProductModel
CROSS APPLY Instructions.nodes('
/MI:root/MI:Location') as T1(Locations)
CROSS APPLY T1.Locations.nodes('
./MI:step ') as T2(steps)
WHERE ProductModelID=7
go

以下查询与先前的查询相似，但是它将 exist() 方法应用于 T2（步骤）行集中的 XML，以便只检索至少使用一个生产工具的生产步骤。即：<step> 元素至少包含一个 <tool> 子元素。

复制代码
WITH XMLNAMESPACES (
'http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelManuInstructions' AS MI)

SELECT ProductModelID,
Locations.value('./@LocationID','int') as LocID,
steps.query('.') as Steps
FROM Production.ProductModel
CROSS APPLY Instructions.nodes('/MI:root/MI:Location') as T1(Locations)
CROSS APPLY T1.Locations.nodes('./MI:step') as T2(steps)
WHERE ProductModelID=7
AND steps.exist('./MI:tool') = 1
Go

以上是一点小小的分享，希望对大家的sql进步有帮助。

本文链接

排列3D的全排列组合

2010-03-19T05:44:00Z

上午看见有c写的全排列，我也想用C#来实现一下，买过彩票的朋友应该都熟悉3d吧，那么我简单实现一个3d彩票的全排列，3D是从0-9（可能是1-9）这些数字，然后从中选3个数，可以有全排列的买法，也有组合的买法，那么下面贴代码了（vs2008）。代码对排列3进行操作：代码

NickLee的学习demo(父子列表清单)

2010-03-16T09:01:00Z

前面我有给NickLee的一个控件地址，不过在线学习没有demo我们很多时候很难下手，我做了个简单的demo，是关于父子列表清单，我们在很多时候做erp会遇见bom清单，也就是一个订单对应哪些产品，而一种产品对应哪些零部件，也就是一个产品它会有哪些材料清单。这样就会出现一个层层展开的关系，而且在设计权限的时候我们也会遇见父子权限或者上下级权限清单，在以前有用过gridview嵌套，后来找到这个控件...

一步一步学习C#(五委托与事件)

2010-03-15T07:34:00Z

1.事件原理：在说明事件的原理之前，我们先来做一个例子，如下： 1、启动VS,建立一个winform应用程序，在form窗口中，我们建立一个按钮，当点击这个按钮时，弹出消息"you clicked me!"。 2、关于winform我们在以后会详细讲解。 3、我们双击按钮后，在button1的click事件中的代码如下： private void button1_Click(object ...

一步一步学习C#(四继承)

2010-03-15T06:56:00Z

1.类的继承 1)继承父类，即拥有该类的所有成员字段和方法比如：继承一个控件，就等于继承了此控件的所有方法与属性，节省编码量。 1.启动vs,建立一个简单的winform窗口，输入一个按钮，在按钮事件中写入代码：MessageBox.Show("you clicked me!"); 2、我们再建立一个Form窗口，我们选择“继承的窗体”，再次选择刚刚建立的Form1。 ...

博客园_MR_ke

查看sql修改痕迹（SQL Change Tracking on Table）

sql server复灾 你懂了吗？

sql server管理 这些你懂吗？

Sql养成一个好习惯是一笔财富

sql 2005性能调优

SqlServer 2005处理xml格式

排列3D的全排列组合

NickLee的学习demo(父子列表清单)

一步一步学习C#(五 委托与事件)

一步一步学习C#(四 继承)

sql server复灾你懂了吗？

sql server管理这些你懂吗？

一步一步学习C#(五委托与事件)

一步一步学习C#(四继承)