精妙SQL语句收集

第一篇：精妙SQL语句收集

SQL编程经典-精妙SQL语句收集

一、基础

1、说明：创建数据库

CREATE DATABASE database-name

2、说明：删除数据库

drop database dbname

3、说明：备份sql server---创建 备份数据的 device USE master

EXEC sp_addumpdevice ’disk’, ’testBack’, ’c:mssql7backupMyNwind_1.dat’

---开始 备份

BACKUP DATABASE pubs TO testBack

4、说明：创建新表

create table tabname(col1 type1 [not null] [primary key],col2 type2 [not null],..)根据已有的表创建新表：

A：create table tab_new like tab_old(使用旧表创建新表)

B：create table tab_new as select col1,col2… from tab_old definition only

5、说明：删除新表

drop table tabname

6、说明：增加一个列

Alter table tabname add column col type 注：列增加后将不能删除。DB2中列加上后数据类型也不能改变，唯一能改变的是增加varchar类型的长度。

7、说明：添加主键： Alter table tabname add primary key(col)说明：删除主键： Alter table tabname drop primary key(col)

8、说明：创建索引：create [unique] index idxname on tabname(col….)

删除索引：drop index idxname

注：索引是不可更改的，想更改必须删除重新建。

9、说明：创建视图：create view viewname as select statement 删除视图：drop view viewname

10、说明：几个简单的基本的sql语句

选择：select * from table1 where 范围

插入：insert into table1(field1,field2)values(value1,value2)删除：delete from table1 where 范围

更新：update table1 set field1=value1 where 范围

查找：select * from table1 where field1 like ’%value1%’---like的语法很精妙，查资料!排序：select * from table1 order by field1,field2 [desc] 总数：select count as totalcount from table1 求和：select sum(field1)as sumvalue from table1 平均：select avg(field1)as avgvalue from table1 最大：select max(field1)as maxvalue from table1 最小：select min(field1)as minvalue from table1

11、说明：几个高级查询运算词

A： UNION 运算符

UNION 运算符通过组合其他两个结果表（例如 TABLE1 和 TABLE2）并消去表中任何重复行而派生出一个结果表。当 ALL 随 UNION 一起使用时（即 UNION ALL），不消除重复行。两种情况下，派生表的每一行不是来自 TABLE1 就是来 自 TABLE2。

B： EXCEPT 运算符

EXCEPT 运算符通过包括所有在 TABLE1 中但不在 TABLE2 中的行并消除所有重复行而派生出一个结果表。当 ALL 随 EXCEPT 一起使用时(EXCEPT ALL)，不消除重复行。

C： INTERSECT 运算符

INTERSECT 运算符通过只包括 TABLE1 和 TABLE2 中都有的行并消除所有重复行而派生出一个结果表。当 ALL 随 INTERSECT 一起使用时(INTERSECT ALL)，不消除重复行。

注：使用运算词的几个查询结果行必须是一致的。

12、说明：使用外连接 A、left outer join：

左外连接（左连接）：结果集几包括连接表的匹配行，也包括左连接表的所有行。

SQL: select a.a, a.b, a.c, b.c, b.d, b.f from a LEFT OUT JOIN b ON a.a = b.c

B：right outer join:

右外连接(右连接)：结果集既包括连接表的匹配连接行，也包括右连接表的所有行。

C：full outer join：

全外连接：不仅包括符号连接表的匹配行，还包括两个连接表中的所有记录。

二、提升

1、说明：复制表(只复制结构,源表名：a 新表名：b)(Access可用)法一：select * into b from a where 1<>1 法二：select top 0 * into b from a

2、说明：拷贝表(拷贝数据,源表名：a 目标表名：b)(Access可用)insert into b(a, b, c)select d,e,f from b;

3、说明：跨数据库之间表的拷贝(具体数据使用绝对路径)(Access可用)insert into b(a, b, c)select d,e,f from b in ‘具体数据库’ where 条件

例子：..from b in ’“&Server.MapPath(”.“)&”data.mdb“ &”’ where..4、说明：子查询(表名1：a 表名2：b)

select a,b,c from a where a IN(select d from b)或者: select a,b,c from a where a IN(1,2,3)

5、说明：显示文章、提交人和最后回复时间

select a.title,a.username,b.adddate from table a,(select max(adddate)adddate from table where table.title=a.title)b

6、说明：外连接查询(表名1：a 表名2：b)

select a.a, a.b, a.c, b.c, b.d, b.f from a LEFT OUT JOIN b ON a.a = b.c

7、说明：在线视图查询(表名1：a)

select * from(SELECT a,b,c FROM a)T where t.a > 1;

8、说明：between的用法,between限制查询数据范围时包括了边界值,not between不包括

select * from table1 where time between time1 and time2

select a,b,c, from table1 where a not between 数值1 and 数值2

9、说明：in 的使用方法

select * from table1 where a [not] in(‘值1’,’值2’,’值4’,’值6’)

10、说明：两张关联表，删除主表中已经在副表中没有的信息

delete from table1 where not exists(select * from table2 where table1.field1=table2.field1)

11、说明：四表联查问题：

select * from a left inner join b on a.a=b.b right inner join c on a.a=c.c inner join d on a.a=d.d where.....12、说明：日程安排提前五分钟提醒

SQL: select * from 日程安排 where datediff(’minute’,f开始时间,getdate())>5

13、说明：一条sql 语句搞定数据库分页

select top 10 b.* from(select top 20 主键字段,排序字段 from 表名 order by 排序字段 desc)a,表名 b where b.主键字段 = a.主键字段 order by a.排序字段

14、说明：前10条记录

select top 10 * form table1 where 范围

15、说明：选择在每一组b值相同的数据中对应的a最大的记录的所有信息(类似这样的用法可以用于**每月排行榜,每月热销产品分析,按科目成绩排名,等等.)

select a,b,c from tablename ta where a=(select max(a)from tablename tb where tb.b=ta.b)

16、说明：包括所有在 TableA 中但不在 TableB和TableC 中的行并消除所有重复行而派生出一个结果表

(select a from tableA)except(select a from tableB)except(select a from tableC)

17、说明：随机取出10条数据

select top 10 * from tablename order by newid()

18、说明：随机选择记录

select newid()

19、说明：删除重复记录

Delete from tablename where id not in(select max(id)from tablename group by col1,col2,...)

20、说明：列出数据库里所有的表名 select name from sysobjects where type=’U’

21、说明：列出表里的所有的

select name from syscolumns where id=object_id(’TableName’)

22、说明：列示type、vender、pcs字段，以type字段排列，case可以方便地实现多重选择，类似select 中的case。

select type,sum(case vender when ’A’ then pcs else 0 end),sum(case vender when ’C’ then pcs else 0 end),sum(case vender when ’B’ then pcs else 0 end)FROM tablename group by type 显示结果：

type vender pcs 电脑 A 1 电脑 A 1 光盘 B 2 光盘 A 2 手机 B 3 手机 C 3

23、说明：初始化表table1

TRUNCATE TABLE table1

24、说明：选择从10到15的记录

select top 5 * from(select top 15 * from table order by id asc)table_别名 order by id desc

三、技巧1、1=1，1=2的使用，在SQL语句组合时用的较多

“where 1=1” 是表示选择全部 “where 1=2”全部不选，如：

if @strWhere!=’’

begin

set @strSQL = ’select count(*)as Total from *’ + @tblName + ’+ where ’ + @strWhere end else begin

set @strSQL = ’select count(*)as Total from *’ + @tblName + ’+’ end

我们可以直接写成

set @strSQL = ’select count(*)as Total from *’ + @tblName + ’+ where 1=1 安定 ’+ @strWhere

2、收缩数据库--重建索引

DBCC REINDEX

DBCC INDEXDEFRAG--收缩数据和日志

DBCC SHRINKDB DBCC SHRINKFILE

3、压缩数据库

dbcc shrinkdatabase(dbname)

4、转移数据库给新用户以已存在用户权限

exec sp_change_users_login ’update_one’,’newname’,’oldname’

go

5、检查备份集

RESTORE VERIFYONLY from disk=’E:dvbbs.bak’

6、修复数据库

ALTER DATABASE [dvbbs] SET SINGLE_USER GO

DBCC CHECKDB(’dvbbs’,repair_allow_data_loss)WITH TABLOCK GO

ALTER DATABASE [dvbbs] SET MULTI_USER GO

7、日志清除 SET NOCOUNT ON

DECLARE @LogicalFileName sysname, @MaxMinutes INT, @NewSize INT

USE tablename--要操作的数据库名

SELECT @LogicalFileName = ’tablename_log’,--日志文件名

@MaxMinutes = 10,--Limit on time allowed to wrap log.@NewSize = 1--你想设定的日志文件的大小(M)

--Setup / initialize

DECLARE @OriginalSize int SELECT @OriginalSize = size FROM sysfiles

WHERE name = @LogicalFileName

SELECT ’Original Size of ’ + db_name()+ ’ LOG is ’ +

CONVERT(VARCHAR(30),@OriginalSize)+ ’ 8K pages or ’ + CONVERT(VARCHAR(30),(@OriginalSize*8/1024))+ ’MB’

FROM sysfiles

WHERE name = @LogicalFileName CREATE TABLE DummyTrans

(DummyColumn char(8000)not null)

DECLARE @Counter INT, @StartTime DATETIME, @TruncLog VARCHAR(255)SELECT @StartTime = GETDATE()，@TruncLog = ’BACKUP LOG ’ + db_name()+ ’ WITH TRUNCATE_ONLY’

DBCC SHRINKFILE(@LogicalFileName, @NewSize)EXEC(@TruncLog)

--Wrap the log if necessary.WHILE @MaxMinutes > DATEDIFF(mi, @StartTime, GETDATE())--time has not expired AND @OriginalSize =(SELECT size FROM sysfiles WHERE name = @LogicalFileName)AND(@OriginalSize * 8 /1024)> @NewSize BEGIN--Outer loop.SELECT @Counter = 0

WHILE((@Counter < @OriginalSize / 16)AND(@Counter < 50000))BEGIN--update

INSERT DummyTrans VALUES(’Fill Log’)DELETE DummyTrans

SELECT @Counter = @Counter + 1 END

EXEC(@TruncLog)END

SELECT ’Final Size of ’ + db_name()+ ’ LOG is ’ + CONVERT(VARCHAR(30),size)+ ’ 8K pages or ’ + CONVERT(VARCHAR(30),(size*8/1024))+ ’MB’ FROM sysfiles

WHERE name = @LogicalFileName DROP TABLE DummyTrans SET NOCOUNT OFF

8、说明：更改某个表

exec sp_changeobjectowner ’tablename’,’dbo’

9、存储更改全部表

CREATE PROCEDURE dbo.User_ChangeObjectOwnerBatch @OldOwner as NVARCHAR(128), @NewOwner as NVARCHAR(128)AS

DECLARE @Name as NVARCHAR(128)DECLARE @Owner as NVARCHAR(128)

DECLARE @OwnerName as NVARCHAR(128)

DECLARE curObject CURSOR FOR select ’Name’ = name，’Owner’ = user_name(uid)from sysobjects

where user_name(uid)=@OldOwner order by name

OPEN curObject

FETCH NEXT FROM curObject INTO @Name, @Owner WHILE(@@FETCH_STATUS=0)BEGIN

if @Owner=@OldOwner begin

set @OwnerName = @OldOwner + ’.’ + rtrim(@Name)exec sp_changeobjectowner @OwnerName, @NewOwner end

--select @name,@NewOwner,@OldOwner

FETCH NEXT FROM curObject INTO @Name, @Owner END

close curObject

deallocate curObject GO

10、SQL SERVER中直接循环写入数据

declare @i int set @i=1 while @i<30 begin

insert into test(userid)values(@i)set @i=@i+1 end

第二篇：精妙SQL语句

精妙SQL语句

 说明：复制表(只复制结构,源表名：a 新表名：b)select * into b from a where 1<>1

 说明：拷贝表(拷贝数据,源表名：a 目标表名：b)insert into b(a, b, c)select d,e,f from b; 说明：显示文章、提交人和最后回复时间

select a.title,a.username,b.adddate from table a,(select max(adddate)adddate from table where table.title=a.title)b

 说明：外连接查询(表名1：a 表名2：b)

select a.a, a.b, a.c, b.c, b.d, b.f from a LEFT OUT JOIN b ON a.a = b.c  说明：日程安排提前五分钟提醒

select * from 日程安排 where datediff('minute',f开始时间,getdate())>5  说明：两张关联表，删除主表中已经在副表中没有的信息

delete from info where not exists(select * from infobz where info.infid=infobz.infid)

 说明：--

SQL:

SELECT A.NUM, A.NAME, B.UPD_DATE, B.PREV_UPD_DATE

FROM TABLE1，(SELECT X.NUM, X.UPD_DATE, Y.UPD_DATE PREV_UPD_DATE

FROM(SELECT NUM, UPD_DATE, INBOUND_QTY, STOCK_ONHAND

FROM TABLE2

WHERE TO_CHAR(UPD_DATE,'YYYY/MM')= TO_CHAR(SYSDATE, 'YYYY/MM'))X，(SELECT NUM, UPD_DATE, STOCK_ONHAND

FROM TABLE2

WHERE TO_CHAR(UPD_DATE,'YYYY/MM')=

TO_CHAR(TO_DATE(TO_CHAR(SYSDATE, 'YYYY/MM')|| '/01','YYYY/MM/DD')1 FROM Handle a)

 一个SQL语句的问题:行列转换 select * from v_temp 上面的视图结果如下: user_name role_name-------------------------系统管理员 管理员

feng 管理员

feng 一般用户

test 一般用户

想把结果变成这样: user_name role_name---------------------------系统管理员 管理员

feng 管理员,一般用户

test 一般用户

=================== create table a_test(name varchar(20),role2 varchar(20))insert into a_test values('李','管理员')insert into a_test values('张','管理员')insert into a_test values('张','一般用户')insert into a_test values('常','一般用户')

create function join_str(@content varchar(100))returns varchar(2000)as begin declare @str varchar(2000)set @str='' select @str=@str+','+rtrim(role2)from a_test where [name]=@content select @str=right(@str,len(@str)-1)return @str end go

--调用：

select [name],dbo.join_str([name])role2 from a_test group by [name]

--select distinct name,dbo.uf_test(name)from a_test  快速比较结构相同的两表

结构相同的两表，一表有记录3万条左右，一表有记录2万条左右，我怎样快速查找两表的不同记录？

============================ 给你一个测试方法，从northwind中的orders表取数据。select * into n1 from orders select * into n2 from orders

select * from n1 select * from n2

--添加主键，然后修改n1中若干字段的若干条

alter table n1 add constraint pk_n1_id primary key(OrderID)alter table n2 add constraint pk_n2_id primary key(OrderID)

select OrderID from(select * from n1 union select * from n2)a group by OrderID having count(*)> 1

应该可以，而且将不同的记录的ID显示出来。下面的适用于双方记录一样的情况，select * from n1 where orderid in(select OrderID from(select * from n1 union select * from n2)a group by OrderID having count(*)> 1)至于双方互不存在的记录是比较好处理的--删除n1,n2中若干条记录

delete from n1 where orderID in('10728','10730')delete from n2 where orderID in('11000','11001')

--*************************************************************--双方都有该记录却不完全相同

select * from n1 where orderid in(select OrderID from(select * from n1 union select * from n2)a group by OrderID having count(*)> 1)union--n2中存在但在n1中不存的在10728,10730 select * from n1 where OrderID not in(select OrderID from n2)union--n1中存在但在n2中不存的在11000,11001 select * from n2 where OrderID not in(select OrderID from n1) 四种方法取表里n到m条纪录：

1.select top m * into 临时表(或表变量)from tablename order by columnname--将top m笔插入 set rowcount n select * from 表变量 order by columnname desc

2.select top n * from(select top m * from tablename order by columnname)a order by columnname desc

3.如果tablename里没有其他identity列，那么： select identity(int)id0,* into #temp from tablename

取n到m条的语句为：

select * from #temp where id0 >=n and id0 <= m

如果你在执行select identity(int)id0,* into #temp from tablename这条语句的时候报错,那是因为你的DB中间的select into/bulkcopy属性没有打开要先执行： exec sp_dboption 你的DB名字,'select into/bulkcopy',true

4.如果表里有identity属性，那么简单：

select * from tablename where identitycol between n and m  如何删除一个表中重复的记录？

create table a_dist(id int,name varchar(20))

insert into a_dist values(1,'abc')insert into a_dist values(1,'abc')insert into a_dist values(1,'abc')insert into a_dist values(1,'abc')

exec up_distinct 'a_dist','id'

select * from a_dist

create procedure up_distinct(@t_name varchar(30),@f_key varchar(30))--f_key表示是分组字段﹐即主键字段 as begin declare @max integer,@id varchar(30),@sql varchar(7999),@type integer select @sql = 'declare cur_rows cursor for select '+@f_key+' ,count(*)from ' +@t_name +' group by ' +@f_key +' having count(*)> 1' exec(@sql)open cur_rows fetch cur_rows into @id,@max while @@fetch_status=0 begin

select @max = @max-1 set rowcount @max

select @type = xtype from syscolumns where id=object_id(@t_name)and name=@f_key if @type=56 select @sql = 'delete from '+@t_name+' where ' + @f_key+' = '+ @id if @type=167 select @sql = 'delete from '+@t_name+' where ' + @f_key+' = '+''''+ @id +'''' exec(@sql)fetch cur_rows into @id,@max end

close cur_rows deallocate cur_rows set rowcount 0 end

select * from systypes select * from syscolumns where id = object_id('a_dist') 查询数据的最大排序问题（只能用一条语句写）

CREATE TABLE hard(qu char(11),co char(11),je numeric(3, 0))

insert into hard values('A','1',3)insert into hard values('A','2',4)insert into hard values('A','4',2)insert into hard values('A','6',9)insert into hard values('B','1',4)insert into hard values('B','2',5)insert into hard values('B','3',6)insert into hard values('C','3',4)insert into hard values('C','6',7)insert into hard values('C','2',3)

要求查询出来的结果如下：

qu co je

---------------------------A 6 9 A 2 4 B 3 6 B 2 5 C 6 7 C 3 4

就是要按qu分组，每组中取je最大的前2位！而且只能用一句sql语句！！

select * from hard a where je in(select top 2 je from hard b where a.qu=b.qu order by je)

 求删除重复记录的sql语句？

怎样把具有相同字段的纪录删除，只留下一条。例如，表test里有id,name字段

如果有name相同的记录 只留下一条，其余的删除。name的内容不定，相同的记录数不定。有没有这样的sql语句？

============================== A:一个完整的解决方案：

将重复的记录记入temp1表: select [标志字段id],count(*)into temp1 from [表名] group by [标志字段id] having count(*)>1

2、将不重复的记录记入temp1表: insert temp1 select [标志字段id],count(*)from [表名] group by [标志字段id] having count(*)=1

3、作一个包含所有不重复记录的表：

select * into temp2 from [表名] where 标志字段id in(select 标志字段id from temp1)

4、删除重复表: delete [表名]

5、恢复表：

insert [表名] select * from temp2

6、删除临时表: drop table temp1 drop table temp2 ================================ B: create table a_dist(id int,name varchar(20))

insert into a_dist values(1,'abc')insert into a_dist values(1,'abc')insert into a_dist values(1,'abc')insert into a_dist values(1,'abc')

exec up_distinct 'a_dist','id'

select * from a_dist

create procedure up_distinct(@t_name varchar(30),@f_key varchar(30))--f_key表示是分组字段﹐即主键字段 as begin declare @max integer,@id varchar(30),@sql varchar(7999),@type integer select @sql = 'declare cur_rows cursor for select '+@f_key+' ,count(*)from ' +@t_name +' group by ' +@f_key +' having count(*)> 1' exec(@sql)open cur_rows

fetch cur_rows into @id,@max while @@fetch_status=0 begin

select @max = @max-1 set rowcount @max

select @type = xtype from syscolumns where id=object_id(@t_name)and name=@f_key if @type=56 select @sql = 'delete from '+@t_name+' where ' + @f_key+' = '+ @id if @type=167 select @sql = 'delete from '+@t_name+' where ' + @f_key+' = '+''''+ @id +'''' exec(@sql)fetch cur_rows into @id,@max end

close cur_rows deallocate cur_rows set rowcount 0 end

select * from systypes select * from syscolumns where id = object_id('a_dist') 行列转换--普通

假设有张学生成绩表(CJ)如下

Name Subject Result 张三 语文 80 张三 数学 90 张三 物理 85 李四 语文 85 李四 数学 92 李四 物理 82

想变成

姓名 语文 数学 物理

张三 80 90 85 李四 85 92 82

declare @sql varchar(4000)set @sql = 'select Name'

select @sql = @sql + ',sum(case Subject when '''+Subject+''' then Result end)['+Subject+']'

from(select distinct Subject from CJ)as a

select @sql = @sql+' from test group by name' exec(@sql)

行列转换--合并

有表A, id pid 1 1 1 2 1 3 2 1 2 2 3 1

如何化成表B: id pid 1 1,2,3 2 1,2 3 1

创建一个合并的函数

create function fmerg(@id int)returns varchar(8000)as begin

declare @str varchar(8000)set @str=''

select @str=@str+','+cast(pid as varchar)from 表A where id=@id set @str=right(@str,len(@str)-1)return(@str)End go

--调用自定义函数得到结果

select distinct id,dbo.fmerg(id)from 表A  如何取得一个数据表的所有列名

方法如下：先从SYSTEMOBJECT系统表中取得数据表的SYSTEMID,然后再SYSCOLUMN表中取得该数据表的所有列名。

SQL语句如下：

declare @objid int,@objname char(40)set @objname = 'tablename'

select @objid = id from sysobjects where id = object_id(@objname)

select 'Column_name' = name from syscolumns where id = @objid order by colid

或

SELECT * FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME ='users'

 通过SQL语句来更改用户的密码

修改别人的,需要sysadmin role

EXEC sp_password NULL, 'newpassword', 'User'

如果帐号为SA执行EXEC sp_password NULL, 'newpassword', sa  怎么判断出一个表的哪些字段不允许为空？

select COLUMN_NAME from INFORMATION_SCHEMA.COLUMNS where IS_NULLABLE='NO' and TABLE_NAME=tablename  如何在数据库里找到含有相同字段的表？

a.查已知列名的情况

SELECT b.name as TableName,a.name as columnname From syscolumns a INNER JOIN sysobjects b ON a.id=b.id AND b.type='U'

AND a.name='你的字段名字'

 未知列名查所有在不同表出现过的列名

Select o.name As tablename,s1.name As columnname From syscolumns s1, sysobjects o Where s1.id = o.id And o.type = 'U' And Exists（Select 1 From syscolumns s2 Where s1.name = s2.name And s1.id <> s2.id)

 查询第xxx行数据

假设id是主键：

select * from(select top xxx * from yourtable)aa where not exists(select 1 from(select top xxx-1 * from yourtable)bb where aa.id=bb.id)

如果使用游标也是可以的

fetch absolute [number] from [cursor_name] 行数为绝对行数

 SQL Server日期计算

a.一个月的第一天

SELECT DATEADD(mm, DATEDIFF(mm,0,getdate()), 0)b.本周的星期一

SELECT DATEADD(wk, DATEDIFF(wk,0,getdate()), 0)c.一年的第一天

SELECT DATEADD(yy, DATEDIFF(yy,0,getdate()), 0)d.季度的第一天

SELECT DATEADD(qq, DATEDIFF(qq,0,getdate()), 0)e.上个月的最后一天

SELECT dateadd(ms,-3,DATEADD(mm, DATEDIFF(mm,0,getdate()), 0))f.去年的最后一天

SELECT dateadd(ms,-3,DATEADD(yy, DATEDIFF(yy,0,getdate()), 0))g.本月的最后一天

SELECT dateadd(ms,-3,DATEADD(mm, DATEDIFF(m,0,getdate())+1, 0))h.本月的第一个星期一

select DATEADD(wk, DATEDIFF(wk,0, dateadd(dd,6-datepart(day,getdate()),getdate())), 0)

i.本年的最后一天

SELECT dateadd(ms,-3,DATEADD(yy, DATEDIFF(yy,0,getdate())+1, 0))。

 获取表结构[把 'sysobjects' 替换 成 'tablename' 即可]

SELECT CASE IsNull(I.name, '')When '' Then '' Else '*'

End as IsPK，Object_Name(A.id)as t_name, A.name as c_name，IsNull(SubString(M.text, 1, 254), '')as pbc_init, T.name as F_DataType，CASE IsNull(TYPEPROPERTY(T.name, 'Scale'), '')WHEN '' Then Cast(A.prec as varchar)

ELSE Cast(A.prec as varchar)+ ',' + Cast(A.scale as varchar)END as F_Scale，A.isnullable as F_isNullAble FROM Syscolumns as A JOIN Systypes as T

ON(A.xType = T.xUserType AND A.Id = Object_id('sysobjects'))LEFT JOIN(SysIndexes as I JOIN Syscolumns as A1

ON(I.id = A1.id and A1.id = object_id('sysobjects')and(I.status & 0x800)= 0x800 AND A1.colid <= I.keycnt))

ON(A.id = I.id AND A.name = index_col('sysobjects', I.indid, A1.colid))LEFT JOIN SysComments as M

ON(M.id = A.cdefault and ObjectProperty(A.cdefault, 'IsConstraint')= 1)ORDER BY A.Colid ASC

 提取数据库内所有表的字段详细说明的SQL语句

SELECT

(case when a.colorder=1 then d.name else '' end)N'表名', a.colorder N'字段序号', a.name N'字段名'，(case when COLUMNPROPERTY(a.id,a.name,'IsIdentity')=1 then ''else '' end)N'标识'，(case when(SELECT count(*)FROM sysobjects WHERE(name in(SELECT name FROM sysindexes

WHERE(id = a.id)AND(indid in(SELECT indid

FROM sysindexkeys

WHERE(id = a.id)AND(colid in(SELECT colid FROM syscolumns

WHERE(id = a.id)AND(name = a.name)))))))AND(xtype = 'PK'))>0 then '' else '' end)N'主键', b.name N'类型'，a.length N'占用字节数'，COLUMNPROPERTY(a.id,a.name,'PRECISION')as N'长度'，isnull(COLUMNPROPERTY(a.id,a.name,'Scale'),0)as N'小数位数',(case when a.isnullable=1 then ''else '' end)N'允许空', isnull(e.text,'')N'默认值'，isnull(g.[value],'')AS N'字段说明' FROM syscolumns a left join systypes b on a.xtype=b.xusertype inner join sysobjects d

on a.id=d.id and d.xtype='U' and d.name<>'dtproperties' left join syscomments e on a.cdefault=e.id

left join sysproperties g

on a.id=g.id AND a.colid = g.smallid order by object_name(a.id),a.colorder

 快速获取表test的记录总数[对大容量表非常有效]

快速获取表test的记录总数:

select rows from sysindexes where id = object_id('test')and indid in(0,1)

update 2 set KHXH=(ID+1)2 2行递增编号

update [23] set id1 = 'No.'+right('00000000'+id,6)where id not like 'No%' //递增

update [23] set id1= 'No.'+right('00000000'+replace(id1,'No.',''),6)//补位递增 delete from [1] where(id%2)=1 奇数

 替换表名字段

update [1] set domurl = replace(domurl,'Upload/Imgswf/','Upload/Photo/')where domurl like '%Upload/Imgswf/%'  截位

SELECT LEFT(表名, 5)

下列语句部分是Mssql语句，不可以在access中使用。

SQL分类：

DDL-数据定义语言(CREATE，ALTER，DROP，DECLARE)

DML-数据操纵语言(SELECT，DELETE，UPDATE，INSERT)

DCL-数据控制语言(GRANT，REVOKE，COMMIT，ROLLBACK)

首先,简要介绍基础语句：

1、说明：创建数据库

CREATE DATABASE database-name

2、说明：删除数据库

drop database dbname

3、说明：备份sql server

---创建 备份数据的 device

USE master

EXEC sp_addumpdevice 'disk', 'testBack', 'c:mssql7backupMyNwind_1.dat'

---开始 备份

BACKUP DATABASE pubs TO testBack

4、说明：创建新表

create table tabname(col1 type1 [not null] [primary key],col2 type2 [not null],..)

根据已有的表创建新表：

A：create table tab_new like tab_old(使用旧表创建新表)

B：create table tab_new as select col1,col2… from tab_old definition only

5、说明：删除新表drop table tabname

6、说明：增加一个列

Alter table tabname add column col type

注：列增加后将不能删除。DB2中列加上后数据类型也不能改变，唯一能改变的是增加varchar类型的长度。

7、说明：添加主键： Alter table tabname add primary key(col)

说明：删除主键： Alter table tabname drop primary key(col)

8、说明：创建索引：create [unique] index idxname on tabname(col….)

删除索引：drop index idxname

注：索引是不可更改的，想更改必须删除重新建。

9、说明：创建视图：create view viewname as select statement

删除视图：drop view viewname

10、说明：几个简单的基本的sql语句

选择：select * from table1 where 范围

插入：insert into table1(field1,field2)values(value1,value2)

删除：delete from table1 where 范围

更新：update table1 set field1=value1 where 范围

查找：select * from table1 where field1 like ‟%value1%‟---like的语法很精妙，查资料!

排序：select * from table1 order by field1,field2 [desc]

总数：select count * as totalcount from table1

求和：select sum(field1)as sumvalue from table1

平均：select avg(field1)as avgvalue from table1

最大：select max(field1)as maxvalue from table1

最小：select min(field1)as minvalue from table1

11、说明：几个高级查询运算词

A： UNION 运算符

UNION 运算符通过组合其他两个结果表（例如 TABLE1 和 TABLE2）并消去表中任何重复行而派生出一个结果表。当 ALL 随 UNION 一起使用时（即 UNION ALL），不消除重复行。两种情况下，派生表的每一行不是来自 TABLE1 就是来自 TABLE2。

B： EXCEPT 运算符

EXCEPT 运算符通过包括所有在 TABLE1 中但不在 TABLE2 中的行并消除所有重复行而派生出一个结果表。当 ALL 随 EXCEPT 一起使用时(EXCEPT ALL)，不消除重复行。

C： INTERSECT 运算符

INTERSECT 运算符通过只包括 TABLE1 和 TABLE2 中都有的行并消除所有重复行而派生出一个结果表。当 ALL 随 INTERSECT 一起使用时(INTERSECT ALL)，不消除重复行。

注：使用运算词的几个查询结果行必须是一致的。

12、说明：使用外连接

A、left outer join：

左外连接（左连接）：结果集几包括连接表的匹配行，也包括左连接表的所有行。

SQL: select a.a, a.b, a.c, b.c, b.d, b.f from a LEFT OUT JOIN b ON a.a = b.c

B：right outer join:

右外连接(右连接)：结果集既包括连接表的匹配连接行，也包括右连接表的所有行。

C：full outer join：

全外连接：不仅包括符号连接表的匹配行，还包括两个连接表中的所有记录。

其次，大家来看一些不错的sql语句

1、说明：复制表(只复制结构,源表名：a 新表名：b)(Access可用)

法一：select * into b from a where 1<>1

法二：select top 0 * into b from a

2、说明：拷贝表(拷贝数据,源表名：a 目标表名：b)(Access可用)

insert into b(a, b, c)select d,e,f from b;

3、说明：跨数据库之间表的拷贝(具体数据使用绝对路径)(Access可用)

insert into b(a, b, c)select d,e,f from b in „具体数据库‟ where 条件

例子：..from b in '“&Server.MapPath(”.“)&”data.mdb“ &”' where..4、说明：子查询(表名1：a 表名2：b)

select a,b,c from a where a IN(select d from b)或者: select a,b,c from a where a IN(1,2,3)

5、说明：显示文章、提交人和最后回复时间

select a.title,a.username,b.adddate from table a,(select max(adddate)adddate from table where table.title=a.title)b

6、说明：外连接查询(表名1：a 表名2：b)

select a.a, a.b, a.c, b.c, b.d, b.f from a LEFT OUT JOIN b ON a.a = b.c

7、说明：在线视图查询(表名1：a)

select * from(SELECT a,b,c FROM a)T where t.a > 1;

8、说明：between的用法,between限制查询数据范围时包括了边界值,not between不包括

select * from table1 where time between time1 and time2

select a,b,c, from table1 where a not between 数值1 and 数值2

9、说明：in 的使用方法

select * from table1 where a [not] in(„值1‟,‟值2‟,‟值4‟,‟值6‟)

10、说明：两张关联表，删除主表中已经在副表中没有的信息

delete from table1 where not exists(select * from table2 where table1.field1=table2.field1)

11、说明：四表联查问题：

select * from a left inner join b on a.a=b.b right inner join c on a.a=c.c inner join d on a.a=d.d where.....12、说明：日程安排提前五分钟提醒

SQL: select * from 日程安排 where datediff('minute',f开始时间,getdate())>5

13、说明：一条sql 语句搞定数据库分页

select top 10 b.* from(select top 20 主键字段,排序字段 from 表名 order by 排序字段 desc)a,表名 b where b.主键字段 = a.主键字段 order by a.排序字段

14、说明：前10条记录

select top 10 * form table1 where 范围

15、说明：选择在每一组b值相同的数据中对应的a最大的记录的所有信息(类似这样的用法可以用于论坛每月排行榜,每月热销产品分析,按科目成绩排名,等等.)

select a,b,c from tablename ta where a=(select max(a)from tablename tb where tb.b=ta.b)

16、说明：包括所有在 TableA 中但不在 TableB和TableC 中的行并消除所有重复行而派生出一个结果表

(select a from tableA)except(select a from tableB)except(select a from tableC)

17、说明：随机取出10条数据

select top 10 * from tablename order by newid()

18、说明：随机选择记录

select newid()

19、说明：删除重复记录

Delete from tablename where id not in(select max(id)from tablename group by col1,col2,...)

20、说明：列出数据库里所有的表名

select name from sysobjects where type='U'

21、说明：列出表里的所有的

select name from syscolumns where id=object_id('TableName')

22、说明：列示type、vender、pcs字段，以type字段排列，case可以方便地实现多重选择，类似select 中的case。

select type,sum(case vender when 'A' then pcs else 0 end),sum(case vender when 'C' then pcs else 0 end),sum(case vender when 'B' then pcs else 0 end)FROM tablename group by type

显示结果：

type vender pcs

电脑 A 1

电脑 A 1

光盘 B 2

光盘 A 2

手机 B 3

手机 C 3

23、说明：初始化表table1

TRUNCATE TABLE table1

24、说明：选择从10到15的记录

select top 5 * from(select top 15 * from table order by id asc)table_别名 order by id desc

随机选择数据库记录的方法（使用Randomize函数，通过SQL语句实现）

对存储在数据库中的数据来说，随机数特性能给出上面的效果，但它们可能太慢了些。你不能要求ASP“找个随机数”然后打印出来。实际上常见的解决方案是建立如下所示的循环：

Randomize

RNumber = Int(Rnd*499)+1

While Not objRec.EOF

If objRec(“ID”)= RNumber THEN

...这里是执行脚本...end if

objRec.MoveNext

Wend

这很容易理解。首先，你取出1到500范围之内的一个随机数（假设500就是数据库内记录的总数）。然后，你遍历每一记录来测试ID 的值、检查其是否匹配RNumber。满足条件的话就执行由THEN 关键字开始的那一块代码。假如你的RNumber 等于495，那么要循环一遍数据库花的时间可就长了。虽然500这个数字看起来大了些，但相比更为稳固的企业解决方案这还是个小型数据库了，后者通常在一个数据库内就包含了成千上万条记录。这时候不就死定了？

采用SQL，你就可以很快地找出准确的记录并且打开一个只包含该记录的recordset，如下所示：

Randomize

RNumber = Int(Rnd*499)+ 1

SQL = “SELECT * FROM Customers WHERE ID = ” & RNumber

set objRec = ObjConn.Execute(SQL)

Response.WriteRNumber & “ = ” & objRec(“ID”)& “ ” & objRec(“c_email”)

不必写出RNumber 和ID，你只需要检查匹配情况即可。只要你对以上代码的工作满意，你自可按需操作“随机”记录。Recordset没有包含其他内容，因此你很快就能找到你需要的记录这样就大大降低了处理时间。

再谈随机数

现在你下定决心要榨干Random 函数的最后一滴油，那么你可能会一次取出多条随机记录或者想采用一定随机范围内的记录。把上面的标准Random 示例扩展一下就可以用SQL应对上面两种情况了。

为了取出几条随机选择的记录并存放在同一recordset内，你可以存储三个随机数，然后查询数据库获得匹配这些数字的记录：

SQL = “SELECT * FROM Customers WHERE ID = ” & RNumber & “ OR ID = ” & RNumber2 & “ OR ID = ” & RNumber3

假如你想选出10条记录（也许是每次页面装载时的10条链接的列表），你可以用BETWEEN 或者数学等式选出第一条记录和适当数量的递增记录。这一操作可以通过好几种方式来完成，但是 SELECT 语句只显示一种可能（这里的ID 是自动生成的号码）：

SQL = “SELECT * FROM Customers WHERE ID BETWEEN ” & RNumber & “ AND ” & RNumber & “+ 9”

注意：以上代码的执行目的不是检查数据库内是否有9条并发记录。

随机读取若干条记录，测试过

Access语法：SELECT top 10 * From 表名 ORDER BY Rnd(id)

Sql server:select top n * from 表名 order by newid()

mysqlelect * From 表名 Order By rand()Limit n

Access左连接语法(最近开发要用左连接,Access帮助什么都没有,网上没有Access的SQL说明,只有自己测试, 现在记下以备后查)

语法elect table1.fd1,table1,fd2,table2.fd2 From table1 left join table2 on table1.fd1,table2.fd1 where...使用SQL语句 用...代替过长的字符串显示

语法：

SQL数据库：select case when len(field)>10 then left(field,10)+'...' else field end as news_name,news_id from tablename

Access数据库：SELECT iif(len(field)>2,left(field,2)+'...',field)FROM tablename;

Conn.Execute说明

Execute方法

该方法用于执行SQL语句。根据SQL语句执行后是否返回记录集，该方法的使用格式分为以下两种：

1．执行SQL查询语句时，将返回查询得到的记录集。用法为：

Set 对象变量名=连接对象.Execute(“SQL 查询语言”)

Execute方法调用后，会自动创建记录集对象，并将查询结果存储在该记录对象中，通过Set方法，将记录集赋给指定的对象保存，以后对象变量就代表了该记录集对象。

2．执行SQL的操作性语言时，没有记录集的返回。此时用法为：

连接对象.Execute “SQL 操作性语句” [, RecordAffected][, Option]

·RecordAffected 为可选项，此出可放置一个变量，SQL语句执行后，所生效的记录数会自动保存到该变量中。通过访问该变量，就可知道SQL语句队多少条记录进行了操作。

·Option 可选项，该参数的取值通常为adCMDText，它用于告诉ADO，应该将Execute方法之后的第一个字符解释为命令文本。通过指定该参数，可使执行更高效。

·BeginTrans、RollbackTrans、CommitTrans方法

这三个方法是连接对象提供的用于事务处理的方法。BeginTrans用于开始一个事物；RollbackTrans用于回滚事务；CommitTrans用于提交所有的事务处理结果，即确认事务的处理。

事务处理可以将一组操作视为一个整体，只有全部语句都成功执行后，事务处理才算成功；若其中有一个语句执行失败，则整个处理就算失败，并恢复到处里前的状态。

BeginTrans和 CommitTrans用于标记事务的开始和结束，在这两个之间的语句，就是作为事务处理的语句。判断事务处理是否成功，可通过连接对象的Error集合来实现，若Error集合的成员个数不为0，则说明有错误发生，事务处理失败。Error集合中的每一个Error对象，代表一个错误信息。

常用SQL语句书写技巧(转)

关键词： SQL

SQL结构化查询字符串的改写，是实现数据库查询性能提升的最现实、最有效的手段，有时甚至是唯一的手段，比如在不允许大幅度修改现有数据库结构的情况下。

通过优化SQL语句提高查询性能的关键是：

l 根据实际需求情况，建立合适的索引； l 使用一切可能的方式去利用好索引，避免全表扫描；

l 尽量减少内存及数据I/O方面的开销

一、建立索引

（一）建立“适当”的索引，是快速查询的基础。

索引（index）是除表之外另一重要的、用户定义的存储在物理介质上的数据结构。当根据索引码的值搜索数据时，索引提供了对数据的快速访问。事实上，没有索引，数据库也能根据SELECT语句成功地检索到结果，但随着表变得越来越大，使用“适当”的索引的效果就越来越明显。注意，在这句话中，我们用了“适当”这个词，这是因为，如果使用索引时不认真考虑其实现过程，索引既可以提高也会破坏数据库的工作性能。

索引实际上是一种特殊的目录，SQL SERVER提供了两种索引：

l 聚集索引（clustered index，也称聚类索引、簇集索引）

我们把这种正文内容本身就是一种按照一定规则排列的目录称为“聚集索引”。

例如：

汉语字典中按拼音查某一个字，就是使用“聚集索引”，实际上，你根本用不着查目录，直接在字典正文里找，就能很快找到需要的汉字（假设你知道发音）。

l 非聚集索引（nonclustered index，也称非聚类索引、非簇集索引）

我们把目录纯粹是目录，正文纯粹是正文的排序方式称为“非聚集索引”。

例如：

汉语字典中按部首查某一个字，部首目录和正文一定要刻意的通过页码才能联系到一起，其顺序不是天然一致的。

聚集索引与非聚集索引的最大区别就在于：聚集索引是对原数据表进行排序，因此只要符合索引条件，就能够直接连续的读取数据记录，几乎可以达到对数据表的零扫描；而非聚集索引仅仅只是另外建了一张索引表，取数据的时候，从索引表取得结果后，还需要到指针所指的数据行读取相应数据，因此，在性能上，聚集索引会大大优于非聚集索引。

但是在一张表中，聚集索引只允许一个，是比较宝贵的，因此要尽可能的用于那些使用频率最高的索引上。另外，查询时必需要用到索引的起始列，否则索引无效。另外，起始列也必需是使用频繁的列，那样的索引性能才会达到最优化。

（二）表：何时应使用聚集索引或非聚集索引

动作描述 使用聚集索引 使用非聚集索引

列经常被分组排序 ○ ○

返回某范围内的数据 ○

一个或极少不同值

小数目的不同值 ○

大数目的不同值 ○

频繁更新的列 ○

外键列 ○ ○

主键列 ○ ○

频繁修改索引列 ○

（三）索引建立的一些注意项

1、不要把聚集索引浪费在主键上，除非你只按主键查询

虽然SQL SERVER默认是在主键上建立聚集索引的，但实际应用中，这样做比较浪费。通常，我们会在每个表中都建立一个ID列，以区分每条数据，并且这个ID列是自动增大的，步长一般为1。此时，如果我们将这个列设为主键，SQL SERVER会将此列默认为聚集索引。这样做有好处，就是可以让您的数据在数据库中按照ID进行物理排序，但这样做实用价值不大。

从我们前面谈到的聚集索引的定义我们可以看出，使用聚集索引的最大好处就是能够根据查询要求，迅速缩小查询范围，避免全表扫描。在实际应用中，因为ID号是自动生成的，我们并不知道每条记录的ID 号，所以我们很难在实践中用ID号来进行查询。这就使让ID号这个主键作为聚集索引成为一种资源浪费。聚集索引相对与非聚集索引的优势是很明显的，而每个表中只能有一个聚集索引的规则，这使得聚集索引变得更加宝贵，应该用在其他查询频率高的字段上。其次，让每个ID号都不同的字段作为聚集索引也不符合“大数目的不同值情况下不应建立聚合索引”规则；当然，这种情况只是针对用户经常修改记录内容，特别是索引项的时候会负作用，但对于查询速度并没有影响。

2、索引的建立要根据实际应用需求来进行

并非是在任何字段上简单地建立索引就能提高查询速度。聚集索引建立的规则大致是“既不能绝大多数都相同，又不能只有极少数相同”。举个例子，在公文表的收发日期字段上建立聚合索引是比较合适的。在政务系统中，我们每天都会收一些文件，这些文件的发文日期将会相同，在发文日期上建立聚合索引对性能的提升应该是相当大的。在群集索引下，数据物理上按顺序存于数据页上，重复值也排列在一起，因而在范围查找时，可以先找到这个范围的起末点，且只在这个范围内扫描数据页，避免了大范围扫描，提高了查询速度。

另一个相反的例子：比如在雇员表的“性别”列上只有“男”与“女”两个不同值，因此就完全没必要建立索引。

3、在聚集索引中加入所有需要提高查询速度的字段，形成复合索引

根据一些实验的结果，我们可以得出一些可供参考的结论：

ü 仅用复合聚集索引的起始列作为查询条件和同时用到复合聚集索引的全部列的查询，速度是几乎一样的，甚至比后者还要快（在查询结果集数目一样的情况下）；

ü 仅用复合聚集索引的非起始列作为查询条件的话，这个索引是不起任何作用的。

ü 复合聚集索引的所有列都用上，而且因为查询条件严格，查询结果少的话，会形成“索引覆盖”，性能可以达到最优。

ü 最重要的一点：无论是否经常使用复合聚合索引的其他列，其起始列一定要是使用最频繁的列。

4.根据实践得出的一些其他经验，特定情况下有效

ü 用聚合索引比用不是聚合索引的主键速度快；

ü 用聚合索引比用一般的主键作order by速度快，特别是在小数据量情况；

ü 使用聚合索引内的时间段，搜索时间会按数据占整个数据表的百分比成比例减少，而无论聚合索引使用了多少个；

ü 日期列不会因为有分秒的输入而减慢查询速度；

ü 由于改变一个表的内容，将会引起索引的变化。频繁的insert,update,delete语句将导致系统花费较大的代价进行索引更新，引起整体性能的下降。一般来讲，在对查询性能的要求高于对数据维护性能要求时，应该尽量使用索引，否则，就要慎重考虑一下付出的代价。在某些极端情况下，可先删除索引，再对数据库表更新大量数据，最后再重建索引，新建立的索引总是比较好用。

二、编写优化的SQL语句，充分利用索引

下面就某些SQL语句的where子句编写中需要注意的问题作详细介绍。在这些where子句中，即使某些列存在索引，但是由于编写了劣质的SQL，系统在运行该SQL语句时也不能使用该索引，而同样使用全表扫描，这就造成了响应速度的极大降低。

SQL语句在提交给数据库进行操作前，都会经过查询分析阶段，SQLSERVER内置的查询优化器会分析查询条件的的每个部分，并判断这些条件是否符合扫描参数（SARG）的标准。只有当一个查询条件符合SARG的标准，才可以通过预先设置的索引，提升查询性能。

SARG的定义：用于限制搜索操作的一种规范，通常是指一个特定的匹配，一个确定范围内的匹配或者两个以上条件的AND连接。一般形式如下：

列名 操作符 <常数 或 变量> 或

<常数 或 变量> 操作符 列名

列名可以出现在操作符的一边，而常数或变量出现在操作符的另一边。如：

Name=‟张三‟

价格>5000

5000<价格

Name=‟张三‟ and 价格>5000

如果一个表达式不能满足SARG的形式，那它就无法限制搜索的范围了，也就是说SQL SERVER必须对每一行都判断它是否满足WHERE子句中的所有条件，既进行全表扫描。所以，一个索引对于不满足SARG形式的表达式来说是无用的, 如：当查询条件为“价格*2 >5000”时，就无法利用建立在价格字段上的索引。

SQLSERVER内置了查询优化器，能将一些条件自动转换为符合SARG标准，如：将“价格*2 >5000” 转换为“价格 >2500/2 ”，以达到可以使用索引的目的，但这种转化不是100%可靠的，有时会有语义上的损失，有时转化不了。如果对“查询优化器”的工作原理不是特别了解，写出的SQL语句可能不会按照您的本意进行查询。所以不能完全依赖查询优化器的优化，建议大家还是利用自己的优化知识，尽可能显式的书写出符合SARG标准的 SQL语句，自行确定查询条件的构建方式，这样一方面有利于查询分析器分析最佳索引匹配顺序，另一方面也有利于今后重读代码。

介绍完SARG后，我们再结合一些实际运用中的例子来做进一步的讲解：

1、Like语句是否属于SARG取决于使用%通配符的样式

如：name like „张%‟，这就属于SARG

而：name like „%张‟ ,就不属于SARG

通配符%在字符串首字符的使用会导致索引无法使用，虽然实际应用中很难避免这样用，但还是应该对这种现象有所了解，至少知道此种用法性能是很低下的。

2、“非”操作符不满足SARG形式，使得索引无法使用

不满足SARG形式的语句最典型的情况就是包括非操作符的语句，如：NOT、!=、<>、!<、!>、NOT EXISTS、NOT IN、NOT LIKE等。

下面是一个NOT子句的例子：

...where not(status ='valid')

not运算符也隐式的包含在另外一些逻辑运算符中，比如<>运算符。见下例：

...where status <>'invalid';

再看下面这个例子：

select * from employee where salary<>3000;

对这个查询，可以改写为不使用not：

select * from employee where salary<3000 or salary>3000;

虽然这两种查询的结果一样，但是第二种查询方案会比第一种查询方案更快些。第二种查询允许对salary列使用索引，而第一种查询则不能使用索引。

3、函数运算不满足SARG形式，使得索引无法使用

例：下列SQL条件语句中的列都建有恰当的索引，但执行速度却非常慢：

select * from record where substring(card_no,1,4)=′5378′(13秒)

select * from record where amount/30< 1000（11秒）

select * from record where convert(char(10),date,112)=′19991201′（10秒）

分析：

where子句中对列的任何操作结果都是在SQL运行时逐列计算得到的，因此它不得不进行全表扫描，而没有使用该列上面的索引；如果这些结果在查询编译时就能得到，那么就可以被SQL优化器优化，使用索引，避免表搜索，因此将SQL重写成下面这样：

select * from record where card_no like ′5378%′（< 1秒）

select * from record where amount < 1000*30（< 1秒）

select * from record where date= ′1999/12/01′（< 1秒）

你会发现SQL明显快很多

4、尽量不要对建立了索引的字段，作任何的直接处理

select * from employs where first_name + last_name ='beill cliton';

无法使用索引

改为：

select * from employee where

first_name = substr('beill cliton',1,instr('beill cliton',' ')-1)and

last_name = substr('beill cliton',instr('beill cliton',' ')+1)

则可以使用索引

5、不同类型的索引效能是不一样的，应尽可能先使用效能高的

比如：数字类型的索引查找效率高于字符串类型，定长字符串char，nchar的索引效率高于变长字符串varchar,nvarchar的索引。

应该将

where username='张三' and age>20

改进为

where age>20 and username='张三'

注意：

此处，SQL的查询分析优化功能可以做到自动重排条件顺序，但还是建议预先手工排列好。

6、尽量不要使用 is null 与 is not null作为查询条件

任何包含null值的列都将不会被包含在索引中，如果某列数据中存在空值，那么对该列建立索引的性能提升是值得怀疑的，尤其是将null作为查询条件的一部分时。建议一方面避免使用is null和is not null, 另一方面不要让数据库字段中存在null, 即使没有内容，也应利用缺省值，或者手动的填入一个值，如:‟‟ 空字符串。

7、某些情况下IN 的作用与OR 相当，且都不能充分利用索引

例：表stuff有200000行，id_no上有非群集索引，请看下面这个SQL：

select count(*)from stuff where id_no in(′0′,′1′)（23秒）

where条件中的′in′在逻辑上相当于′ or′，所以语法分析器会将in(′0′,′1′)转化为id_no =′0′ or id_no=′1′来执行。我们期望它会根据每个or子句分别查找，再将结果相加，这样可以利用id_no上的索引；但实际上,它却采用了“OR策略”，即先取出满足每个or子句的行，存入临时数据库的工作表中，再建立唯一索引以去掉重复行，最后从这个临时表中计算结果。因此，实际过程没有利用id_no 上索引，并且完成时间还要受tempdb数据库性能的影响。

实践证明，表的行数越多，工作表的性能就越差，当stuff有620000行时，执行时间会非常长！如果确定不同的条件不会产生大量重复值，还不如将or子句分开：

select count(*)from stuff where id_no=′0′

select count(*)from stuff where id_no=′1′

得到两个结果，再用union作一次加法合算。因为每句都使用了索引，执行时间会比较短，select count(*)from stuff where id_no=′0′

union

select count(*)from stuff where id_no=′1′

从实践效果来看，使用union在通常情况下比用or的效率要高的多，而exist关键字和in关键字在用法上类似，性能上也类似，都会产生全表扫描，效率比较低下，根据未经验证的说法，exist可能比in要快些。

8、使用变通的方法提高查询效率

like关键字支持通配符匹配，但这种匹配特别耗时。例如：select * from customer where zipcode like “21_ _ _”，即使在zipcode字段上已建立了索引，在这种情况下也可能还是采用全表扫描方式。如果把语句改为：select * from customer where zipcode >“21000”，在执行查询时就会利用索引，大大提高速度。但这种变通是有限制的，不应引起业务意义上的损失，对于邮政编码而言，zipcode like “21_ _ _” 和 zipcode >“21000” 意义是完全一致的。

9、组合索引的高效使用

假设已在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

（11秒）

select count(*)from record

where date > ′19990901′ and place in(′BJ′,′SH′)

（< 1秒）

这是一个设置较合理的组合索引。它将date作为前导列，使每个SQL都可以利用索引，并且在第一和第三个SQL中形成了索引覆盖，因而性能达到了最优。如果索引不便于更改，修正SQL中的条件顺序以配合索引顺序也是可行的。

10、order by按聚集索引列排序效率最高

排序是较耗时的操作，应尽量简化或避免对大型表进行排序，如缩小排序的列的范围，只在有索引的列上排序等等。

我们来看：（gid是主键，fariqi是聚合索引列）

select top 10000 gid,fariqi,reader,title from tgongwen

用时：196 毫秒。扫描计数 1，逻辑读 289 次，物理读 1 次，预读 1527 次。

select top 10000 gid,fariqi,reader,title from tgongwen order by gid asc

用时：4720毫秒。扫描计数 1，逻辑读 41956 次，物理读 0 次，预读 1287 次。

select top 10000 gid,fariqi,reader,title from tgongwen order by gid desc

用时：4736毫秒。扫描计数 1，逻辑读 55350 次，物理读 10 次，预读 775 次。

select top 10000 gid,fariqi,reader,title from tgongwen order by fariqi asc

用时：173毫秒。扫描计数 1，逻辑读 290 次，物理读 0 次，预读 0 次。

select top 10000 gid,fariqi,reader,title from tgongwen order by fariqi desc

用时：156毫秒。扫描计数 1，逻辑读 289 次，物理读 0 次，预读 0 次。

从以上我们可以看出，不排序的速度以及逻辑读次数都是和“order by 聚集索引列” 的速度是相当的，但这些都比“order by 非聚集索引列”的查询速度是快得多的。

同时，按照某个字段进行排序的时候，无论是正序还是倒序，速度是基本相当的。

三、关于节省数据查询系统开销方面的措施

1、使用TOP尽量减少取出的数据量

TOP是SQL SERVER中用来提取前几条或前某个百分比数据的关键词。

select top 20 gid,fariqi,reader,title from tgongwen order by gid desc select top 60 percent gid,fariqi,reader,title from tgongwen order by gid desc

在实际的应用中，应该经常利用top 剔除掉不必要的数据，只保留必须的数据集合。这样不仅可以减少数据库逻辑读的次数，还能避免不必要的内存浪费，对系统性能的提升都是有好处的。

2、字段提取要按照“需多少、提多少”的原则，避免“select *”

这个举个例子：

select top 10000 gid,fariqi,reader,title from tgongwen order by gid desc

用时：4673毫秒

select top 10000 gid,fariqi,title from tgongwen order by gid desc

用时：1376毫秒

select top 10000 gid,fariqi from tgongwen order by gid desc

用时：80毫秒

由此看来，字段大小越大，数目越多，select所耗费的资源就越多，比如取int类型的字段就会比取char的快很多。我们每少提取一个字段，数据的提取速度就会有相应的提升。提升的幅度根据舍弃的字段的大小来判断。

3、count(*)与 count(字段)方法比较

我们来看一些实验例子（gid为Tgongwen的主键）：

select count(*)from Tgongwen

用时：1500毫秒

select count(gid)from Tgongwen

用时：1483毫秒

select count(fariqi)from Tgongwen

用时：3140毫秒

select count(title)from Tgongwen 用时：52050毫秒

从以上可以看出，用count(*)和用 count(主键)的速度是相当的，而count(*)却比其他任何除主键以外的字段汇总速度要快，而且字段越长，汇总速度就越慢。如果用 count(*)，SQL SERVER会自动查找最小字段来汇总。当然，如果您直接写count(主键)将会来的更直接些。

4、有嵌套查询时，尽可能在内层过滤掉数据

如果一个列同时在主查询和where子句中出现，很可能当主查询中的列值改变之后，子查询必须重新查询一次。而且查询嵌套层次越多，效率越低，因此应当尽量避免子查询。如果子查询不可避免，那么要在子查询中过滤掉尽可能多的行。

5、多表关联查询时，需注意表顺序，并尽可能早的过滤掉数据

在使用Join进行多表关联查询时候，应该使用系统开销最小的方案。连接条件要充份考虑带有索引的表、行数多的表，并注意优化表顺序；说的简单一点，就是尽可能早的将之后要做关联的数据量降下来。

一般情况下，sqlserver 会对表的连接作出自动优化。例如：

select name,no from A

join B on A.id=B.id

join C on C.id=A.id

where name='wang'

尽管A表在From中先列出，然后才是B,最后才是C。但sql server可能会首先使用c表。它的选择原则是相对于该查询限制为单行或少数几行，就可以减少在其他表中查找的总数据量。绝大多数情况下，sql server 会作出最优的选择，但如果你发觉某个复杂的联结查询速度比预计的要慢，就可以使用SET FORCEPLAN语句强制sql server按照表出现顺序使用表。如上例加上：SET FORCEPLAN ON…….SET FORCEPLAN OFF 表的执行顺序将会按照你所写的顺序执行。在查询分析器中查看2种执行效率，从而选择表的连接顺序。SET FORCEPLAN的缺点是只能在存储过程中使用。

小结：

Ø 聚集索引比较宝贵，应该用在查询频率最高的地方；

Ø 在数据为“既不是绝大多数相同，也不是极少数相同”状态时，最能发挥聚集索引的潜力；

Ø 复合索引的设置和使用要注意保持顺序一致；

Ø 条件子句的表达式最好符合SARG规范，是可利用索引的；

Ø 任何对列的操作都导致全表扫描，如数据库函数、计算表达式等，查询时应尽可能将操作移至等号的某一边；

Ø 要注意含有null值时，是不能充分利用索引的；

Ø exist, in、or等子句常会使索引失效；

如果不产生大量重复值，可以考虑把子句拆开，再用union拼合；

Ø 排序时应充分利用带索引的字段；

Ø 尽可能早，快的过滤掉无用的数据，只将必须的数据带到后续的操作中去

从前面讲叙的内容可以看出，SQL语句优化的实质就是在结果正确的前提下，用分析优化器可以识别的SARG规范语句，充份利用索引，减少数据的I/O次数，尽量避免全表扫描的发生。

以上内容有些是指导性的理论原则，有些是实际摸索的经验，大家在使用时应灵活处理，根据实际情况，选择合适的方法。本文中列举的实验数据仅作比对用，不具备普遍意义。大家在实际项目中，应充分利用性能监测和分析工具（如SQLSERVER带的相关工具）来检验自己的优化效果。

此外，还有很重要的一点要提醒大家，同样复杂的数据操作，在SQLSERVER数据库级别完成的代价要远远小于在应用端用程序代码完成的代价，所以建议大家全面，深入的学习SQL语法中重要关键字的应用，如：Group By，Having等，尽量把数据操作任务放在数据库系统中完成。数据库应用系统的性能优化是一个复杂的过程，上述这些只是在SQL语句层次的一种体现，深入研究还会涉及数据库层的资源配置、网络层的流量控制以及操作系统层的总体设计等等，这些将在以后的文章中详细论述

如何获得sql查询侯满足条件的记录数

select kch into :ls_kch from cj_cjb where kch = :s_kch and kscj < 60 using ltr;

请问如何知道符合条件kch的纪录数。SELECT KCH, COUNT(*)INTO :ls_kch, :ll_count cj_cjb WHERE kch = :s_kch AND kscj < 60 UAING ltr;

ll_count

SRY少了个FROM

执行完后看：

sqlca.sqlnrows

呵呵select只能返回一条记录啊，要是有多条记录符合条件pb是会报错的。

are2000(乌鸦与土狗)说的对呀

只是想知道符合条件的纪录数，直接这样写：

SELECT COUNT(*)

INTO :ll_count

from cj_cjb

WHERE kch = :s_kch

AND kscj < 60

UAING sqlca;

楼上说的对啊

呵呵

多行的话要用游标的

用游标取的时候,在for 循环中加个变量就可以知道条数,数据也取出来了~~

如何查询SQLSERVER数据库DB1中所有表的记录数？

use DB1

if object_id('tempdb..##')is not null drop table ##

select cast(null as sysname)as 表名称, 1 as 记录数 into ## where 1 = 0

declare @TableName sysname

declare testcur cursor for select [name] from sysobjects where xtype ='U' order by [name]

open testcur

fetch next from testcur into @TableName

while @@fetch_status = 0

begin

exec('insert into ## select ''' + @TableName + ''',(select count(1)from ' + @TableName + ')')

fetch next from testcur into @TableName end

close testcur

deallocate testcur

select * from ##

drop table ##

Pubwin EP数据备份:

SQL server2000版本重装前，需要备份哪些数据

SQL server2000版本重装前，需要备份数据库文件，文件路径为： HintsoftPubwinServerdatabase 下的“local_Data.MDF”和“local_log.LDF”

除了备份数据库文件以外还有就是需要备份数据库的备份文件 其路径为 ： HintsoftPubwinServerappServserverwebappsNetCafebackuplongtermdata 还有一个方面需要注意的是 网吧的会员是否存在头像与身份证证件照 如有的话 请备份

HintsoftPubwinServerappServserverwebappsNetCafeheadphotos HintsoftPubwinServerappServserverwebappsNetCafephotos ； 备份好后，重新安装将备份文件放置相应的目录即可。如何防止远程修改数据库

一、屏蔽1433端口（以win2000为例）： 设置安全策略：

“控制面板”—〉“管理工具”—〉“本地安全策略”

选择IP安全策略—〉创建IP安全策略—〉建立名称—〉“激活默认响应规则”下一步—〉初始身份验证方法选择“win2000默认（V5）”—〉弹出的警告界面直接确认—〉完成建立安全策略。

选择你新建的策略—〉属性—〉添加—〉选择“此规则不指定隧道” —〉网络类型选择“所有网络连接”—〉身份验证方法“win2000默认（V5）” —〉弹出的警告界面直接确认—〉“所有IP通讯”—〉筛选器选择“要求安全设置”—〉继续下一步完成选中“所有 IP 通讯”—〉点“编辑”按钮，打开“IP筛选器列表”—〉继续点“编辑”按钮，打开“筛选器 属性” —〉在“寻址”中，源地址选择“任何IP地址”，目的地址选择“我的IP地址”，同时选中“镜像”—〉在“协议”中，协议选择“TCP”，设置协议端口为 “从任意端口”到“到此端口：1433” —〉确定，为了安全起见，最好再新建一个IP筛选器屏蔽1434端口。

完成上面配置后，在刚配置的策略点击右键，选择指派，完成后重新启动机器。如何验证数据库的1433已经不能连接？

1）局域网内找一个机器（非本机）安装企业管理，添加注册刚刚配制过安全策略的服务器，应该是那个等待注册的画面，状态中显示：“正在验证注册信息”或拒绝连接或服务未开启的提示。

2）局域网内找一个机器（非本机），在dos控制台下，输入telnet EP服务器IP 1433 如果安全策略应用成功的话，应该不能够连接，会出现如下的话：正在连接到xxxxxxx...无法打开到主机的连接 在端口 1433 : 连接失败。如果应用安全策略失败，则能够连接成功。

二、关闭不安全的服务

第一步只是屏蔽了其它机器连接数据库的端口，但是操作系统本身还存在一些漏洞，这些漏洞同样会导致数据库不安全。可以运行services.msc进入本地服务管理，禁用WMI和Server服务（屏蔽WMI和 IPC共享漏洞），但是有些网吧需要用到Server服务的部分功能，所以对于Server服务，可以使用以下两种较为灵活的方法来屏蔽： 1）批处理自启动法：

打开记事本，输入以下内容（记得每行最后要回车）： net share ipc$ /delete net share admin$ /delete net share c$ /delete net share d$ /delete net share e$ /delete ……（你有几个硬盘分区就写几行这样的命令）

保存为NotShare.bat（注意后缀！），然后把这个批处理文件拖到“程序”→“启动”项，这样每次开机就会运行它，也就是通过net命令关闭共享。

如果哪一天你需要开启某个或某些共享，只要重新编辑这个批处理文件即可（把相应的那个命令行删掉）。2）注册表改键值法 “ 开始”→“运行”输入“regedit”确定后，打开注册表编辑器，找到“HKEY_LOCAL_MACHINESYSTEM CurrentControlSetServiceslanmanserverparameters”项，双击右侧窗口中的 “AutoShareServer”项将键值由1改为0，这样就能关闭硬盘各分区的共享。如果没有AutoShareServer项，可自己新建一个再改键值。然后还是在这一窗口下再找到“AutoShareWks”项，也把键值由1改为0，关闭admin$共享。最后到 “HKEY_LOCAL_MACHINESYSTEMCurrentControlSetControlLsa”项处找到 “restrictanonymous”，将键值设为1，关闭IPC$共享。

PUBWIN后台网页应该映射那个端口? 8443，443

sql server多表关联update

UPDATE Tab1 SET a.Name = b.Name FROM Tab1 a,Tab2 b WHERE a.ID = b.ID

批量insert数据

insert into student(sno,sname,ssex,sage,sdept)select '95001','李勇','男','20','cs' union select '95002','刘晨','女','19','is' union select '95003','王敏','女','18','ma' union select '95004','张立','男','19','is'

第三篇：Oracle SQL精妙SQL语句讲解

SQL*PLUS界面：

登录：输入SQLPLUS回车；输入正确的ORACLE用户名并回车；输入用户口令并回车，显示提示符：SQL>

退出：输入EXIT即可。

2）命令的编辑与运行：

在命令提示符后输入SQL命令并运行，以分号结束输入；以斜杠结束输入；以空行结束输入；

利用SQL缓冲区进行PL/SQL块的编辑和运行；

利用命令文件进行PL/SQL块的编辑和运行。

数据库查询

用SELECT语句从表中提取查询数据。语法为

SELECT [DISTINCT] {column1,column2,…} FROM tablename WHERE {conditions} GROUP BY {conditions} ORDER BY {expressions} [ASC/DESC];

说明：SELECT子句用于指定检索数据库的中哪些列，FROM子句用于指定从哪一个表或视图中检索数据。

SELECT中的操作符及多表查询WHERE子句。(LIKE,IS,…)

WHERE子句中的条件可以是一个包含等号或不等号的条件表达式，也可以是一个含有IN、NOT IN、BETWEEN、LIKE、IS NOT NULL等比较运算符的条件式，还可以是由单一的条件表达通过逻辑运算符组合成复合条件。

ORDER BY 子句

ORDER BY 子句使得SQL在显示查询结果时将各返回行按顺序排列，返回行的排列顺序由ORDER BY 子句指定的表达式的值确定。

连接查询

利用SELECT语句进行数据库查询时，可以把多个表、视图的数据结合起来，使得查询结果的每一行中包含来自多个表达式或视图的数据，这种操作被称为连接查询。

连接查询的方法是在SELECT命令的FROM子句中指定两个或多个将被连接查询的表或视图，并且在WHERE子句告诉ORACLE如何把多个表的数据进行合并。根据WHERE子句中的条件表达式是等还是不等式，可以把连接查询分为等式连接和不等式连接。

子查询

如果某一个SELECT命令（查询1）出现在另一个SQL命令（查询2）的一个子句中，则称查询1是查询2的子查询。

基本数据类型（NUMBER,VARCHAR2,DATE）O

RACEL支持下列内部数据类型：

VARCHAR2 变长字符串，最长为2000字符。

NUMBER 数值型。

LONG 变长字符数据，最长为2G字节。

DATE 日期型。

RAW 二进制数据，最长为255字节。

LONG RAW 变长二进制数据，最长为2G字节。

ROWID 二六进制串，表示表的行的唯一地址。

CHAR 定长字符数据，最长为255。

常用函数用法：

一个函数类似于一个算符，它操作数据项，返回一个结果。函数在格式上不同于算符，它个具有变元，可操作0个、一个、二个或多个变元，形式为：

函数名（变元，变元，…）

函数具有下列一般类形：

单行函数

分组函数

单行函数对查询的表或视图的每一行返回一个结果行。它有数值函数，字符函数，日期函数，转换函数等。

分组函数返回的结果是基于行组而不是单行，所以分组函数不同于单行函数。在许多分组函数中可有下列选项：

DISTRNCT 该选项使分组函数只考虑变元表达式中的不同值。

ALL该选项使分组函数考虑全部值，包含全部重复。

全部分组函数（除COUNT（*）外）忽略空值。如果具有分组函数的查询，没有返回行或只有空值（分组函数的变元取值的行），则分组函数返回空值。

5、数据操纵语言命令：

数据库操纵语言（DML）命令用于查询和操纵模式对象中的数据，它不隐式地提交当前事务。它包含UPDATE、INSERT、DELETE、EXPLAIN PLAN、SELECT和LOCK TABLE 等命令。下面简单介绍一下：

1)UPDATE tablename SET {column1=expression1,column2=expression2,…} WHERE {conditions};

例如：S QL>UPDATE EMP

SET JOB =’MANAGER’

WHERE ENAME=’MAPTIN’;

SQL >SELECT * FROM EMP;

UPDATE子句指明了要修改的数据库是EMP,并用WHERE子句限制了只对名字(ENAME)为’MARTIN’的职工的数据进行修改,SET子句则说明修改的方式,即把’MARTION’的工作名称(JOB)改为’MARAGER’.2)INSERT INTO tablename {column1,column2,…} VALUES {expression1,expression2,…};

例如：SQL>SELECT INTO DEPT（DNAME，DEPTNO）

VALUES（‘ACCOUNTING’，10）

3)DELETE FROM tablename WHERE {conditions};

例如：SQL>DELETE FROM EMP

WHERE EMPNO = 7654;

DELETE命令删除一条记录,而且DELETE命令只能删除整行,而不能删除某行中的部分数据.4）事务控制命令

提交命令(COMMIT):可以使数据库的修改永久化.设置AUTOCOMMIT为允许状态:SQL >SET AUTOCOMMIT ON;

回滚命令(ROLLBACK):消除上一个COMMIT命令后的所做的全部修改,使得数据库的内容恢复到上一个COMMIT执行后的状态.使用方法是:

SQL>ROLLBACK;

创建表、视图、索引、同义词、用户。、表是存储用户数据的基本结构。

建立表主要指定义下列信息：

列定义

完整性约束

表所在表空间

存储特性

可选择的聚集

从一查询获得数据

语法如下：CREATE TABLE tablename

(column1 datatype [DEFAULT expression] [constraint], column1 datatype [DEFAULT expression] [constraint], ……）

[STORAGE子句] [其他子句…]；

例如：

SQL>CREATE TABLE NEW_DEPT(DPTNO NUMBER(2), DNAME CHAR(6), LOC CHAR(13);

更改表作用：

增加列

增加完整性约束

重新定义列（数据类型、长度、缺省值）

修改存储参数或其它参数

使能、使不能或删除一完整性约束或触发器

显式地分配一个范围

2）、视图

视图是一个逻辑表，它允许操作者从其它表或视图存取数据，视图本身不包含数据。视图所基于的表称为基表。

引入视图有下列作用：

提供附加的表安全级，限制存取基表的行或/和列集合。

隐藏数据复杂性。

为数据提供另一种观点。

促使ORACLE的某些操作在包含视图的数据库上执行，而不在另一个数据库上执行。

3）、索引

索引是种数据库对象。对于在表或聚集的索引列上的每一值将包含一项，为行提供直接的快速存取。在下列情况ORACLE可利用索引改进性能：

按指定的索引列的值查找行。

按索引列的顺序存取表。

建立索引： CREATE [UNIQUE] INDEX indexname ON tablename(column ,。。)；

例如：SQL>CREAT INDEX IC_EMP

ON CLUSTER EMPLOYEE

4）、同义词

同义词：为表、视图、序列、存储函数、包、快照或其它同义词的另一个名字。使用同义词为了安全和方便。对一对象建立同义词可有下列好处：

引用对象不需指出对象的持有者。

引用对象不需指出它所位于的数据库。

为对象提供另一个名字。

建立同义词：

CREATE SYNONYM symnon_name FOR [username.]tablename;

例如：CREAT PUBLIC SYNONYM EMP

FOR SCOTT.EMP @SALES

5）、用户

CREATE USER username IDENTIFIED BY password;

例如：SQL>CREATE USER SIDNEY

IDENTIFIED BY CARTON;

Oracle扩展PL/SQL简介

PL/SQL概述。

PL/SQL是Oracle对SQL规范的扩展，是一种块结构语言，即构成一个PL/SQL程序的基本单位（过程、函数和无名块）是逻辑块，可包含任何数目的嵌套了快。这种程序结构支持逐步求精方法解决问题。一个块（或子块）将逻辑上相关的说明和语句组合在一起，其形式为：

DECLARE

---说明

BEGIN

---语句序列

EXCEPTION

---例外处理程序

END；

它有以下优点:

支持SQL;

生产率高;

性能好;

可称植性;

与ORACLE集成.PL/SQL体系结构

PL/SQL运行系统是种技术，不是一种独立产品，可认为这种技术是PL/SQL块和子程序的一种机，它可接收任何有效的PL/SQL块或子程序。如图所示：

PL/SQL机可执行过程性语句，而将SQL语句发送到ORACLE服务器上的SQL语句执行器。在ORACLE预编译程序或OCI程序中可嵌入无名的PL/SQL块。如果ORACLE具有PROCEDURAL选件，有名的PL/SQL块（子程序）可单独编译，永久地存储在数据库中，准备执行。

PL/SQL基础：

PL/SQL有一字符集、保留字、标点、数据类型、严密语法等，它与SQL有相同表示，现重点介绍。

1）、数据类型：如下表所示

数据类型 子类型

纯量类型 数值 BINARY_INTEGER NATURAL,POSITIVE

NUMBER DEC,DECIMAL,DOUBLE PRECISION,PLOAT,INTEGER,INT,NUMERIC,REAL,SMALLINT

字符 CHAR CHARACTER,STRING

VARCHAR2 VARCHAR

LONG

LONG RAW

RAW

RAWID

逻辑 BOOLEAN

日期 DATE

组合 类型 记录 RECORD

表 TABLE

2）、变量和常量

在PL/SQL程序中可将值存储在变量和常量中，当程序执行时，变量的值可以改变，而常量的值不能改变。

3）、程序块式结构：

DECLARE

变量说明部分；

BEGIN

执行语句部分；

[EXCEPTION

例外处理部分；] END;控制语句：

分支语句：

IF condition THEN

Sequence_of_statements;

END IF;

IF condition THEN

Sequence_of_statement1;

ELSE

Sequence_of_statement2;

END IF;

IF condition1 THEN

Sequence_of_statement1;

ELSIF condition2 THEN

Sequence_of_statement2;

ELSIF condition3 THEN

Sequence_of_statement3;

END IF;

循环语句：

LOOP

Sequence_of_statements;

IF condition THEN

EXIT;

END IF;

END LOOP;

WHILE condition LOOP

Sequence_of_statements;

END LOOP;

FOR counter IN lower_bound..higher_bound LOOP

Sequence_of_statements;

END LOOP;

子程序：

存储过程：

CREATE PROCEDURE 过程名(参数说明1，参数说明2，[局部说明]

BEGIN

执行语句；

END 过程名；

。)IS。

存储函数：

CREATE FUNCTION 函数名(参数说明1，参数说明2。。)RETURN 类型 IS [局部说明] BEGIN

执行语句；

END 函数名

Oracle SQL精妙SQL语句讲解

好东西，大家赶紧收藏吧~~~

--行列转换 行转列

DROP TABLE t_change_lc;CREATE TABLE t_change_lc(card_code VARCHAR2(3), q NUMBER, bal NUMBER);

INSERT INTO t_change_lc

SELECT '001' card_code, ROWNUM q, trunc(dbms_random.VALUE * 100)bal FROM dual CONNECT BY ROWNUM <= 4 UNION

SELECT '002' card_code, ROWNUM q, trunc(dbms_random.VALUE * 100)bal FROM dual CONNECT BY ROWNUM <= 4;

SELECT * FROM t_change_lc;

SELECT a.card_code，SUM(decode(a.q, 1, a.bal, 0))q1，SUM(decode(a.q, 2, a.bal, 0))q2，SUM(decode(a.q, 3, a.bal, 0))q3，SUM(decode(a.q, 4, a.bal, 0))q4

FROM t_change_lc a GROUP BY a.card_code ORDER BY 1;

--行列转换 列转行

DROP TABLE t_change_cl;CREATE TABLE t_change_cl AS SELECT a.card_code，SUM(decode(a.q, 1, a.bal, 0))q1，SUM(decode(a.q, 2, a.bal, 0))q2，SUM(decode(a.q, 3, a.bal, 0))q3，SUM(decode(a.q, 4, a.bal, 0))q4

FROM t_change_lc a GROUP BY a.card_code ORDER BY 1;

SELECT * FROM t_change_cl;

SELECT t.card_code，t.rn q，decode(t.rn, 1, t.q1, 2, t.q2, 3, t.q3, 4, t.q4)bal

FROM(SELECT a.*, b.rn

FROM t_change_cl a，(SELECT ROWNUM rn FROM dual CONNECT BY ROWNUM <= 4)b)t ORDER BY 1, 2;

--行列转换 行转列 合并

DROP TABLE t_change_lc_comma;CREATE TABLE t_change_lc_comma AS SELECT card_code,'quarter_'||q AS q FROM t_change_lc;

SELECT * FROM t_change_lc_comma;

SELECT t1.card_code, substr(MAX(sys_connect_by_path(t1.q, ';')), 2)q

FROM(SELECT a.card_code，a.q，row_number()over(PARTITION BY a.card_code ORDER BY a.q)rn

FROM t_change_lc_comma a)t1 START WITH t1.rn = 1 CONNECT BY t1.card_code = PRIOR t1.card_code

AND t1.rn1 = PRIOR t1.rn GROUP BY t1.card_code;

SELECT * FROM t_change_cl_comma;SELECT t.card_code，substr(t.q，instr(';' || t.q, ';', 1, rn)，instr(t.q || ';', ';', 1, rn)-instr(';' || t.q, ';', 1, rn))q

FROM(SELECT a.card_code, a.q, b.rn

FROM t_change_cl_comma a，(SELECT ROWNUM rn FROM dual CONNECT BY ROWNUM <= 100)b

WHERE instr(';' || a.q, ';', 1, rn)> 0)t ORDER BY 1, 2;

--实现一条记录根据条件多表插入 DROP TABLE t_ia_src;CREATE TABLE t_ia_src AS SELECT 'a'||ROWNUM c1, 'b'||ROWNUM c2 FROM dual CONNECT BY ROWNUM<=5;DROP TABLE t_ia_dest_1;CREATE TABLE t_ia_dest_1(flag VARCHAR2(10), c VARCHAR2(10));DROP TABLE t_ia_dest_2;CREATE TABLE t_ia_dest_2(flag VARCHAR2(10), c VARCHAR2(10));DROP TABLE t_ia_dest_3;CREATE TABLE t_ia_dest_3(flag VARCHAR2(10), c VARCHAR2(10));

SELECT * FROM t_ia_src;SELECT * FROM t_ia_dest_1;SELECT * FROM t_ia_dest_2;SELECT * FROM t_ia_dest_3;

INSERT ALL WHEN(c1 IN('a1','a3'))THEN

INTO t_ia_dest_1(flag,c)VALUES(flag1,c2)WHEN(c1 IN('a2','a4'))THEN

INTO t_ia_dest_2(flag,c)VALUES(flag2,c2)ELSE INTO t_ia_dest_3(flag,c)VALUES(flag1||flag2,c1||c2)SELECT c1,c2, 'f1' flag1, 'f2' flag2 FROM t_ia_src;

--如果存在就更新，不存在就插入用一个语句实现 DROP TABLE t_mg;CREATE TABLE t_mg(code VARCHAR2(10), NAME VARCHAR2(10));

SELECT * FROM t_mg;

MERGE INTO t_mg a USING(SELECT 'the code' code, 'the name' NAME FROM dual)b ON(a.code = b.code)WHEN MATCHED THEN

UPDATE SET a.NAME = b.NAME WHEN NOT MATCHED THEN

INSERT(code, NAME)VALUES(b.code, b.NAME);

--抽取/删除重复记录

DROP TABLE t_dup;CREATE TABLE t_dup AS SELECT 'code_'||ROWNUM code, dbms_random.string('z',5)NAME FROM dual CONNECT BY ROWNUM<=10;

INSERT INTO t_dup SELECT 'code_'||ROWNUM code, dbms_random.string('z',5)NAME FROM dual CONNECT BY ROWNUM<=2;

SELECT * FROM t_dup;

SELECT * FROM t_dup a WHERE a.ROWID <>(SELECT MIN(b.ROWID)FROM t_dup b WHERE a.code=b.code);

SELECT b.code, b.NAME

FROM(SELECT a.code，a.NAME，row_number()over(PARTITION BY a.code ORDER BY a.ROWID)rn

FROM t_dup a)b WHERE b.rn > 1;

--IN/EXISTS的不同适用环境--t_orders.customer_id有索引 SELECT a.*

FROM t_employees a WHERE a.employee_id IN

(SELECT b.sales_rep_id FROM t_orders b WHERE b.customer_id = 12);

SELECT a.*

FROM t_employees a WHERE EXISTS(SELECT 1

FROM t_orders b

WHERE b.customer_id = 12

AND a.employee_id = b.sales_rep_id);

--t_employees.department_id有索引 SELECT a.*

FROM t_employees a WHERE a.department_id = 10

AND EXISTS(SELECT 1 FROM t_orders b WHERE a.employee_id = b.sales_rep_id);

SELECT a.*

FROM t_employees a WHERE a.department_id = 10

AND a.employee_id IN(SELECT b.sales_rep_id FROM t_orders b);

--FBI DROP TABLE t_fbi;CREATE TABLE t_fbi AS SELECT ROWNUM rn, dbms_random.STRING('z',10)NAME , SYSDATE + dbms_random.VALUE * 10 dt FROM dual

CONNECT BY ROWNUM <=10;

CREATE INDEX idx_nonfbi ON t_fbi(dt);

DROP INDEX idx_fbi_1;CREATE INDEX idx_fbi_1 ON t_fbi(trunc(dt));

SELECT * FROM t_fbi WHERE trunc(dt)= to_date('2006-09-21','yyyy-mm-dd');

--不建议使用

SELECT * FROM t_fbi WHERE to_char(dt, 'yyyy-mm-dd')= '2006-09-21';

--LOOP中的COMMIT/ROLLBACK DROP TABLE t_loop PURGE;create TABLE t_loop AS SELECT * FROM user_objects WHERE 1=2;

SELECT * FROM t_loop;

--逐行提交 DECLARE BEGIN

FOR cur IN(SELECT * FROM user_objects)LOOP

INSERT INTO t_loop VALUES cur;

COMMIT;

END LOOP;END;

--模拟批量提交 DECLARE

v_count NUMBER;BEGIN

FOR cur IN(SELECT * FROM user_objects)LOOP

INSERT INTO t_loop VALUES cur;

v_count := v_count + 1;

IF v_count >= 100 THEN

COMMIT;

END IF;

END LOOP;

COMMIT;END;

--真正的批量提交 DECLARE

CURSOR cur IS

SELECT * FROM user_objects;

TYPE rec IS TABLE OF user_objects%ROWTYPE;

recs rec;BEGIN

OPEN cur;

WHILE(TRUE)LOOP

FETCH cur BULK COLLECT

INTO recs LIMIT 100;

--forall 实现批量

FORALL i IN 1..recs.COUNT

INSERT INTO t_loop VALUES recs(i);

COMMIT;

EXIT WHEN cur%NOTFOUND;

END LOOP;

CLOSE cur;END;

--悲观锁定/乐观锁定

DROP TABLE t_lock PURGE;CREATE TABLE t_lock AS SELECT 1 ID FROM dual;

SELECT * FROM t_lock;

--常见的实现逻辑，隐含bug DECLARE

v_cnt NUMBER;BEGIN

--这里有并发性的bug

SELECT MAX(ID)INTO v_cnt FROM t_lock;

--here for other operation

v_cnt := v_cnt + 1;

INSERT INTO t_lock(ID)VALUES(v_cnt);

COMMIT;END;

--高并发环境下，安全的实现逻辑 DECLARE

v_cnt NUMBER;BEGIN

--对指定的行取得lock

SELECT ID INTO v_cnt FROM t_lock WHERE ID=1 FOR UPDATE;

--在有lock的情况下继续下面的操作

SELECT MAX(ID)INTO v_cnt FROM t_lock;

--here for other operation

v_cnt := v_cnt + 1;

INSERT INTO t_lock(ID)VALUES(v_cnt);

COMMIT;--提交并且释放lock END;

--硬解析/软解析

DROP TABLE t_hard PURGE;CREATE TABLE t_hard(ID INT);

SELECT * FROM t_hard;

DECLARE

sql_1

VARCHAR2(200);BEGIN

--hard parse

--java中的同等语句是 Statement.execute()

FOR i IN 1..1000 LOOP

sql_1 := 'insert into t_hard(id)values(' || i || ')';

EXECUTE IMMEDIATE sql_1;

END LOOP;

COMMIT;

--soft parse

--java中的同等语句是 PreparedStatement.execute()

sql_1

:= 'insert into t_hard(id)values(:id)';

FOR i IN 1..1000 LOOP

EXECUTE IMMEDIATE sql_1

USING i;

END LOOP;

COMMIT;END;

--正确的分页算法

SELECT *

FROM(SELECT a.*, ROWNUM rn

FROM(SELECT * FROM t_employees ORDER BY first_name)a

WHERE ROWNUM <= 500)WHERE rn > 480;

--分页算法(why not this one)SELECT a.*, ROWNUM rn

FROM(SELECT * FROM t_employees ORDER BY first_name)a WHERE ROWNUM <= 500 AND ROWNUM > 480;

--分页算法(why not this one)SELECT b.*

FROM(SELECT a.*, ROWNUM rn

FROM t_employees a

WHERE ROWNUM < = 500

ORDER BY first_name)b WHERE b.rn > 480;

--OLAP--小计合计 SELECT CASE

WHEN a.deptno IS NULL THEN

'合计'

WHEN a.deptno IS NOT NULL AND a.empno IS NULL THEN

'小计'

ELSE

'' || a.deptno

END deptno，a.empno，a.ename，SUM(a.sal)total_sal

FROM scott.emp a GROUP BY GROUPING SETS((a.deptno),(a.deptno, a.empno, a.ename),());

--分组排序 SELECT a.deptno，a.empno，a.ename，a.sal，--可跳跃的rank

rank()over(PARTITION BY a.deptno ORDER BY a.sal DESC)r1，--密集型rank

dense_rank()over(PARTITION BY a.deptno ORDER BY a.sal DESC)r2，--不分组排序

rank()over(ORDER BY sal DESC)r3

FROM scott.emp a

ORDER BY a.deptno,a.sal DESC;

--当前行数据和前/后n行的数据比较 SELECT a.empno，a.ename，a.sal，--上面一行

lag(a.sal)over(ORDER BY a.sal DESC)lag_1，--下面三行

lead(a.sal, 3)over(ORDER BY a.sal DESC)lead_3

FROM scott.emp a ORDER BY a.sal DESC;

一、数据表设计图

二、创建语句

/*================*/ /* DBMS name: ORACLE Version 9i */ /* Created on: 2008-11-10 23:39:24 */ /*================*/

alter table “emp”

drop constraint FK_EMP_REFERENCE_DEPT;

drop table “dept” cascade constraints;

drop table “emp” cascade constraints;

drop table “salgrade” cascade constraints;

/*================*/ /* Table: “dept” */ /*================*/

create table dept(deptno NUMBER(11)not null, dname VARCHAR2(15)not null, loc VARCHAR2(15)not null, constraint PK_DEPT primary key(deptno));

/*================*/ /* Table: “emp” */ /*================*/

create table emp(empno NUMBER(11)not null, deptno NUMBER(11), ename VARCHAR2(15)not null, sal NUMBER(11)not null, job VARCHAR2(15)not null, mgr NUMBER(11)not null, hirdate DATE not null, comm NUMBER(11)not null, constraint PK_EMP primary key(empno));

/*================*/ /* Table: salgrade */ /*================*/

create table salgrade(grade NUMBER(11)not null, losal NUMBER(11)not null, hisal NUMBER(11)not null, constraint PK_SALGRADE primary key(grade));

alter table emp add constraint FK_EMP_REFERENCE_DEPT foreign key(deptno)references dept(deptno);

三、测试要求及语句

/** *公司工资最高的员工列表 子查询 */

select t.ename,t.sal from emp t where t.sal =(select max(sal)from emp)

/** *查询每一个员工的经理人及自己的名字 */

select e1.ename,e2.ename from emp e1 join emp e2 on(e1.mgr = e2.empno)

/** *查询公司平均薪水的等级 */

select s.grade from salgrade s where(select avg(t.sal)from emp t)between s.losal and s.hisal

/** *求部门中那些人的工资最高 */

select d.dname,ename,sal from(select t.deptno,ename,sal from(select deptno,max(sal)as max_sal from emp group by deptno)e join emp t on(e.deptno = t.deptno and t.sal = max_sal))et join dept d on(d.deptno = et.deptno)

/** *查询部门平均薪水的等级 */

select d.dname,avg_sal,grade from(select deptno,avg_sal,grade from(select deptno,avg(sal)as avg_sal from emp group by deptno)e join salgrade s on(e.avg_sal between s.losal and s.hisal))es join dept d on(es.deptno = d.deptno)

/** *求部门的平均薪水等级 */

select deptno,avg(grade)from(select deptno,grade from emp e join salgrade s on(e.sal between s.losal and s.hisal))t group by t.deptno

/** * 求那些人是经理人 */

select ename from emp e where empno in(select distinct mgr from emp)

/** *不准用组函数 求薪水的最高值 */

select ename from emp where empno not in(select distinct e1.empno from emp e1 join emp e2 on(e1.sal

/** *平均薪水最高的部门编号与名称 */

select d.deptno,dname from(select deptno,avg(sal)avg_sal from emp group by deptno)t1 join dept d on(d.deptno = t1.deptno)where avg_sal =(select max(avg_sal)from(select deptno,avg(sal)avg_sal from emp group by deptno)t2)

/** *求平均薪水的等级最低的部门名称 */

select dname from dept d where d.deptno in(select deptno from(select deptno,grade from(select deptno,avg(sal)avg_sal from emp group by deptno)t1 join salgrade g on(avg_sal between g.losal and g.hisal))t2 where t2.grade =(select min(grade)from(select deptno,grade from(select deptno,avg(sal)avg_sal from emp group by deptno)t1 join salgrade g on(avg_sal between g.losal and g.hisal))t3))

/** *求部门经理人中平均薪水最低的部门名称 */

select d.dname,t1.avg_sal from dept d join(select deptno,avg(sal)avg_sal from(select e2.deptno,e2.ename,e2.sal from emp e1 join emp e2 on(e1.mgr = e2.empno))t group by deptno)t1 on(d.deptno = t1.deptno)where avg_sal =(select min(avg_sal)from(select deptno,avg(sal)avg_sal from(select e2.deptno,e2.ename,e2.sal from emp e1 join emp e2 on(e1.mgr = e2.empno))t group by deptno))/** *求必普通员工的最高薪水还要高的经理人名称 */

select ename from(select e2.ename,e2.empno,e2.sal from emp e1 join emp e2 on(e1.mgr = e2.empno))t where t.sal >(select max(e.sal)from emp e where e.empno not in(select e1.mgr from emp e1 join emp e2 on(e1.mgr = e2.empno)))

/** *求薪水最高的第6名到10名雇员 */

SELECT * FROM(SELECT A.*, ROWNUM RN FROM(SELECT * FROM(select e1.ename,e1.sal from emp e1 order by e1.sal desc))A WHERE ROWNUM <= 10)WHERE RN >= 6

第四篇：Oracle-SQL精妙SQL语句讲解

Oracle: SQL精妙SQL语句讲解

一、重复操作查询

--where条件得distinct systemdicid作为唯一标识 select *

from dmis_zd_systemdic t WHERE typeid = '06012'

and t.systemdicid in(select min(systemdicid)from dmis_zd_systemdic where typeid = '06012'

group by name)order by orderno;

二、检查表是否存在

select count(tname)from tab where tname = upper('表名');

三、日期函数

--返回当前日期的第一天

select trunc(sysdate,'year')from dual;--返回当前日期月份的第一天

select trunc(sysdate,'month')from dual;--上月最后一天

select last_day(add_months(sysdate,-1))from dual;--给定日期后最近星期几得日期

select next_day(to_date('2009-12-01', 'yyyy-mm-dd'), '星期一')next_day from dual;

四、同一张表中，根据一个字段更新另一个字段

update(select t.fgenerationtime as ftime, t.fgeneratedateall as str from dmis_fs_approvebook t where t.fgenerationtime is not null)set str = TO_CHAR(ftime, 'yyyy-mm-dd')where str is null;

五、重复数据查询 select * FROM EMP E WHERE E.ROWID >(SELECT MIN(X.ROWID)FROM EMP X WHERE X.EMP_NO = E.EMP_NO);

六、合并不同表的数据（merge into）merge into student s using(select id, name, tel from test001)x on(s.s_id = x.id)when matched then

update set s_name = x.name when not matched then

insert(s_id, s_name, s_age)values(x.id, x.name, x.tel);commit;

七、查询执行sql（v$sql）

select t.module, t.first_load_time, t.sql_text from v$sql t order by first_load_time desc;

2、数据库精度修改处理--Create table /*drop table temp_data;*/ create table temp_data(FID VARCHAR2(40)not null, USEHOURS NUMBER(10)default 0, FVOLTAGE NUMBER(10)default 0, INVOLTAGE NUMBER(10)default 0);alter table TEMP_DATA add constraint tempfid primary key(FID);

insert into temp_data select a.fid, a.usehours, a.fvoltage, a.involtage from dmis_fs_factorymonthdetail a;

update dmis_fs_factorymonthdetail t set t.usehours = '', t.fvoltage = '', t.involtage = '';

alter table DMIS_FS_FACTORYMONTHDETAIL modify USEHOURS NUMBER(10,1);alter table DMIS_FS_FACTORYMONTHDETAIL modify FVOLTAGE NUMBER(10,1);alter table DMIS_FS_FACTORYMONTHDETAIL modify INVOLTAGE NUMBER(10,1);

update(select a.usehours as tusehours, b.usehours as fusehours, a.fvoltage as tfvoltage, b.fvoltage as ffvoltage, a.involtage as tinvoltage, b.involtage as finvoltage, a.fid as ffid, b.fid as tfid from dmis_fs_factorymonthdetail a, temp_data b where a.fid = b.fid)tt set tt.tusehours = tt.fusehours, tt.tfvoltage = tt.ffvoltage, tt.tinvoltage = tt.finvoltage where ffid = tfid;drop table temp_data;commit;

3、恢复drop掉的存储过程 用sys用户登陆，执行如下的查询：

SQL> select text from dba_source as of timestamp to_timestamp('2009-03-06 09:45:00', 'YYYY-MM-DD

HH24:MI:SS')

where

owner='IPRA'

and

name=

'P_IPACCHECK_NC' order by line;

4、删除某个用户下的对象--删除某个用户下的对象 set heading off;set feedback off;spool c:dropobj.sql;prompt--Drop constraint select 'alter table '||table_name||' drop constraint '||constraint_name||';' from user_constraints where constraint_type='R';prompt--Drop tables select 'drop table '||table_name ||';' from user_tables;

prompt--Drop view select 'drop view ' ||view_name||';' from user_views;

prompt--Drop sequence select

--行列转换 行转列

DROP TABLE t_change_lc;CREATE TABLE t_change_lc(card_code VARCHAR2(3), q NUMBER, bal NUMBER);INSERT INTO t_change_lc SELECT '001' card_code, ROWNUM q, trunc(dbms_random.VALUE * 100)bal FROM dual CONNECT BY ROWNUM <= 4 UNION

SELECT '002' card_code, ROWNUM q, trunc(dbms_random.VALUE * 100)bal FROM dual CONNECT BY ROWNUM <= 4;SELECT * FROM t_change_lc;SELECT a.card_code, SUM(decode(a.q, 1, a.bal, 0))q1, SUM(decode(a.q, 2, a.bal, 0))q2, SUM(decode(a.q, 3, a.bal, 0))q3, SUM(decode(a.q, 4, a.bal, 0))q4 FROM t_change_lc a GROUP BY a.card_code ORDER BY 1;--行列转换 列转行

DROP TABLE t_change_cl;CREATE TABLE t_change_cl AS SELECT a.card_code, SUM(decode(a.q, 1, a.bal, 0))q1, SUM(decode(a.q, 2, a.bal, 0))q2, SUM(decode(a.q, 3, a.bal, 0))q3, SUM(decode(a.q, 4, a.bal, 0))q4 FROM t_change_lc a GROUP BY a.card_code ORDER BY 1;SELECT * FROM t_change_cl;SELECT t.card_code, t.rn q, decode(t.rn, 1, t.q1, 2, t.q2, 3, t.q3, 4, t.q4)bal FROM(SELECT a.*, b.rn FROM t_change_cl a,(SELECT ROWNUM rn FROM dual CONNECT BY ROWNUM <= 4)b)t ORDER BY 1, 2;

--行列转换 行转列 合并

DROP TABLE t_change_lc_comma;CREATE TABLE t_change_lc_comma AS SELECT card_code,'quarter_'||q AS q FROM t_change_lc;SELECT * FROM t_change_lc_comma;SELECT t1.card_code, substr(MAX(sys_connect_by_path(t1.q, ';')), 2)q FROM(SELECT a.card_code, a.q, row_number()over(PARTITION BY a.card_code ORDER BY a.q)rn FROM t_change_lc_comma a)t1 START WITH t1.rn = 1

CONNECT BY t1.card_code = PRIOR t1.card_code AND t1.rn1 = PRIOR t1.rn GROUP BY t1.card_code;SELECT * FROM t_change_cl_comma;SELECT t.card_code, substr(t.q, instr(';' || t.q, ';', 1, rn), instr(t.q || ';', ';', 1, rn)-instr(';' || t.q, ';', 1, rn))q FROM(SELECT a.card_code, a.q, b.rn FROM t_change_cl_comma a,(SELECT ROWNUM rn FROM dual CONNECT BY ROWNUM <= 100)b WHERE instr(';' || a.q, ';', 1, rn)> 0)t ORDER BY 1, 2;

--实现一条记录根据条件多表插入 DROP TABLE t_ia_src;CREATE TABLE t_ia_src AS SELECT 'a'||ROWNUM c1, 'b'||ROWNUM c2 FROM dual CONNECT BY ROWNUM<=5;DROP TABLE t_ia_dest_1;CREATE TABLE t_ia_dest_1(flag VARCHAR2(10), c VARCHAR2(10));DROP TABLE t_ia_dest_2;CREATE TABLE t_ia_dest_2(flag VARCHAR2(10), c VARCHAR2(10));DROP TABLE t_ia_dest_3;CREATE TABLE t_ia_dest_3(flag VARCHAR2(10), c VARCHAR2(10));SELECT * FROM t_ia_src;SELECT * FROM t_ia_dest_1;SELECT * FROM t_ia_dest_2;SELECT * FROM t_ia_dest_3;INSERT ALL

WHEN(c1 IN('a1','a3'))THEN

INTO t_ia_dest_1(flag,c)VALUES(flag1,c2)WHEN(c1 IN('a2','a4'))THEN

INTO t_ia_dest_2(flag,c)VALUES(flag2,c2)ELSE

INTO t_ia_dest_3(flag,c)VALUES(flag1||flag2,c1||c2)SELECT c1,c2, 'f1' flag1, 'f2' flag2 FROM t_ia_src;

--如果存在就更新，不存在就插入用一个语句实现 DROP TABLE t_mg;CREATE TABLE t_mg(code VARCHAR2(10), NAME VARCHAR2(10));SELECT * FROM t_mg;MERGE INTO t_mg a USING(SELECT 'the code' code, 'the name' NAME FROM dual)b ON(a.code = b.code)WHEN MATCHED THEN

UPDATE SET a.NAME = b.NAME WHEN NOT MATCHED THEN

INSERT(code, NAME)VALUES(b.code, b.NAME);

--抽取/删除重复记录 DROP TABLE t_dup;CREATE TABLE t_dup AS SELECT 'code_'||ROWNUM code, dbms_random.string('z',5)NAME FROM dual CONNECT BY ROWNUM<=10;INSERT INTO t_dup SELECT 'code_'||ROWNUM code, dbms_random.string('z',5)NAME FROM dual CONNECT BY ROWNUM<=2;SELECT * FROM t_dup;SELECT * FROM t_dup a WHERE a.ROWID <>(SELECT MIN(b.ROWID)FROM t_dup b WHERE a.code=b.code);SELECT b.code, b.NAME FROM(SELECT a.code, a.NAME, row_number()over(PARTITION BY a.code ORDER BY a.ROWID)rn FROM t_dup a)b WHERE b.rn > 1;--IN/EXISTS的不同适用环境--t_orders.customer_id有索引 SELECT a.*

FROM t_employees a WHERE a.employee_id IN

(SELECT b.sales_rep_id FROM t_orders b WHERE b.customer_id = 12);SELECT a.*

FROM t_employees a WHERE EXISTS(SELECT 1 FROM t_orders b WHERE b.customer_id = 12

AND a.employee_id = b.sales_rep_id);--t_employees.department_id有索引 SELECT a.*

FROM t_employees a WHERE a.department_id = 10 AND EXISTS

(SELECT 1 FROM t_orders b WHERE a.employee_id = b.sales_rep_id);SELECT a.*

FROM t_employees a WHERE a.department_id = 10

AND a.employee_id IN(SELECT b.sales_rep_id FROM t_orders b);--FBI DROP TABLE t_fbi;CREATE TABLE t_fbi AS

SELECT ROWNUM rn, dbms_random.STRING('z',10)NAME , SYSDATE + dbms_random.VALUE * 10 dt FROM dual CONNECT BY ROWNUM <=10;CREATE INDEX idx_nonfbi ON t_fbi(dt);DROP INDEX idx_fbi_1;CREATE INDEX idx_fbi_1 ON t_fbi(trunc(dt));SELECT * FROM t_fbi WHERE trunc(dt)= to_date('2006-09-21','yyyy-mm-dd');--不建议使用

SELECT * FROM t_fbi WHERE to_char(dt, 'yyyy-mm-dd')= '2006-09-21';--LOOP中的COMMIT/ROLLBACK DROP TABLE t_loop PURGE;create TABLE t_loop AS SELECT * FROM user_objects WHERE 1=2;SELECT * FROM t_loop;--逐行提交 DECLARE BEGIN

FOR cur IN(SELECT * FROM user_objects)LOOP INSERT INTO t_loop VALUES cur;COMMIT;END LOOP;END;

--模拟批量提交 DECLARE

v_count NUMBER;BEGIN

FOR cur IN(SELECT * FROM user_objects)LOOP INSERT INTO t_loop VALUES cur;v_count := v_count + 1;IF v_count >= 100 THEN COMMIT;END IF;END LOOP;COMMIT;END;

--真正的批量提交 DECLARE CURSOR cur IS

SELECT * FROM user_objects;TYPE rec IS TABLE OF user_objects%ROWTYPE;recs rec;BEGIN OPEN cur;WHILE(TRUE)LOOP FETCH cur BULK COLLECT INTO recs LIMIT 100;

--forall 实现批量

FORALL i IN 1..recs.COUNT

INSERT INTO t_loop VALUES recs(i);COMMIT;EXIT WHEN cur%NOTFOUND;END LOOP;CLOSE cur;END;

--悲观锁定/乐观锁定 DROP TABLE t_lock PURGE;CREATE TABLE t_lock AS SELECT 1 ID FROM dual;SELECT * FROM t_lock;

--常见的实现逻辑，隐含bug DECLARE v_cnt NUMBER;BEGIN

--这里有并发性的bug SELECT MAX(ID)INTO v_cnt FROM t_lock;--here for other operation v_cnt := v_cnt + 1;INSERT INTO t_lock(ID)VALUES(v_cnt);COMMIT;END;

--高并发环境下，安全的实现逻辑 DECLARE v_cnt NUMBER;BEGIN

--对指定的行取得lock SELECT ID INTO v_cnt FROM t_lock WHERE ID=1 FOR UPDATE;

--在有lock的情况下继续下面的操作

SELECT MAX(ID)INTO v_cnt FROM t_lock;--here for other operation v_cnt := v_cnt + 1;INSERT INTO t_lock(ID)VALUES(v_cnt);COMMIT;--提交并且释放lock END;

--硬解析/软解析

DROP TABLE t_hard PURGE;CREATE TABLE t_hard(ID INT);SELECT * FROM t_hard;DECLARE

sql_1 VARCHAR2(200);BEGIN

--hard parse--java中的同等语句是 Statement.execute()FOR i IN 1..1000 LOOP sql_1 := 'insert into t_hard(id)values(' || i || ')';EXECUTE IMMEDIATE sql_1;END LOOP;COMMIT;--soft parse--java中的同等语句是 PreparedStatement.execute()sql_1 := 'insert into t_hard(id)values(:id)';FOR i IN 1..1000 LOOP EXECUTE IMMEDIATE sql_1 USING i;END LOOP;COMMIT;END;

--正确的分页算法 SELECT *

FROM(SELECT a.*, ROWNUM rn FROM(SELECT * FROM t_employees ORDER BY first_name)a WHERE ROWNUM <= 500)WHERE rn > 480;

--分页算法(why not this one)SELECT a.*, ROWNUM rn FROM(SELECT * FROM t_employees ORDER BY first_name)a WHERE ROWNUM <= 500 AND ROWNUM > 480;

--分页算法(why not this one)SELECT b.*

FROM(SELECT a.*, ROWNUM rn FROM t_employees a WHERE ROWNUM < = 500 ORDER BY first_name)b WHERE b.rn > 480;--OLAP

--小计合计 SELECT CASE

WHEN a.deptno IS NULL THEN '合计'

WHEN a.deptno IS NOT NULL AND a.empno IS NULL THEN '小计' ELSE

'' || a.deptno END deptno, a.empno, a.ename, SUM(a.sal)total_sal FROM scott.emp a GROUP BY GROUPING SETS((a.deptno),(a.deptno, a.empno, a.ename),());

--分组排序 SELECT a.deptno, a.empno, a.ename, a.sal,--可跳跃的rank rank()over(PARTITION BY a.deptno ORDER BY a.sal DESC)r1,--密集型rank dense_rank()over(PARTITION BY a.deptno ORDER BY a.sal DESC)r2,--不分组排序

rank()over(ORDER BY sal DESC)r3 FROM scott.emp a ORDER BY a.deptno,a.sal DESC;--当前行数据和前/后n行的数据比较 SELECT a.empno, a.ename, a.sal,--上面一行

lag(a.sal)over(ORDER BY a.sal DESC)lag_1,--下面三行

lead(a.sal, 3)over(ORDER BY a.sal DESC)lead_3 FROM scott.emp a ORDER BY a.sal DESC;

第五篇：SQL高手篇精妙SQL语句介绍

说明:复制表(只复制结构,源表名:a 新表名:b)SQL: select * into b from a where 1<>1

说明:拷贝表(拷贝数据,源表名:a 目标表名:b)SQL: insert into b(a, b, c)select d,e,f from b;

说明:显示文章、提交人和最后回复时间

SQL: select a.title,a.username,b.adddate from table a,(select max(adddate)adddate from table where table.title=a.title)b

说明:外连接查询(表名1:a 表名2:b)

SQL: select a.a, a.b, a.c, b.c, b.d, b.f from a LEFT OUT JOIN b ON a.a = b.c

说明:日程安排提前五分钟提醒

SQL: select * from 日程安排 where datediff('minute',f开始时间,getdate())>5

说明:两张关联表，删除主表中已经在副表中没有的信息

SQL:

delete from info where not exists(select * from infobz where info.infid=infobz.infid)

说明:--SQL:

SELECT A.NUM, A.NAME, B.UPD_DATE, B.PREV_UPD_DATE FROM TABLE1,(SELECT X.NUM, X.UPD_DATE, Y.UPD_DATE PREV_UPD_DATE FROM(SELECT NUM, UPD_DATE, INBOUND_QTY, STOCK_ONHAND FROM TABLE2 WHERE TO_CHAR(UPD_DATE,'YYYY/MM')= TO_CHAR(SYSDATE, 'YYYY/MM'))X,(SELECT NUM, UPD_DATE, STOCK_ONHAND FROM TABLE2 WHERE TO_CHAR(UPD_DATE,'YYYY/MM')= TO_CHAR(TO_DATE(TO_CHAR(SYSDATE, 'YYYY/MM')|| '/01','YYYY/MM/DD')1 FROM Handle a)