博客园_专注于技术,专注于生活

如何清除sql server日志

2012-01-09T02:53:00Z

1．打开查询分析器，输入命令

DUMP TRANSACTION 数据库名 WITH NO_LOG

2.再打开企业管理器--右键你要压缩的数据库--所有任务--收缩数据库--收缩文件--选择日志文件--在收缩方式里选择收缩至XXM,这里会给出一个允许收缩到的最小M数,直接输入这个数,确定就可以了。

清除Log有两种方法：

1.自动清除法

开放数据库选项 Trunc Log on Chkpt，使数据库系统每隔一段时间自动清除Log。此方法的优点是无须人工干预，由SQL　Server自动执行，并且一般不会出现Log溢满的情况；缺点是只清除Log而不做备份。

2.手动清除法

执行命令“dump transaction”来清除Log。以下两条命令都可以清除日志：

dump transaction with truncate_only

dump transaction with no_log

通常删除事务日志中不活跃的部分可使用“dump transaction with trancate_only”命令，这条命令写进事务日志时，还要做必要的并发性检查。SYBASE提供“dump transaction with no_log”来处理某些非常紧迫的情况，使用这条命令有很大的危险性，SQL　Server会弹出一条警告信息。为了尽量确保数据库的一致性，你应将它作为“最后一招”。

以上两种方法只??清除日志，而不做日志备份，若想备份日志，应执行“dump transaction database_name to dumpdevice”命令。

PS:附一个更好的方法

先分离数据库后，直接删除日志以后,再在查询分析器里用

exec sp_attach_single_file_db '数据库名', '.mdf文件路径'

命令附加数据库。 OVER.在别的地方看到的不错。

数据库日志操作

先提供一种复杂的方法压缩日志及数据库文件如下：

1.清空日志

DUMP TRANSACTION 库名 WITH NO_LOG

2.截断事务日志：

BACKUP LOG 数据库名 WITH NO_LOG

3.收缩数据库文件(如果不压缩,数据库的文件不会减小

企业管理器--右键你要压缩的数据库--所有任务--收缩数据库--收缩文件

--选择日志文件--在收缩方式里选择收缩至XXM,这里会给出一个允许收缩到的最小M数,直接输入这个数,确定就可以了

--选择数据文件--在收缩方式里选择收缩至XXM,这里会给出一个允许收缩到的最小M数,直接输入这个数,确定就可以了

也可以用SQL语句来完成

--收缩数据库

DBCC SHRINKDATABASE(客户资料)

--收缩指定数据文件,1是文件号,可以通过这个语句查询到:select * from sysfiles

DBCC SHRINKFILE(1)

4.为了最大化的缩小日志文件(如果是sql 7.0,这步只能在查询分析器中进行)

a.分离数据库:

企业管理器--服务器--数据库--右键--分离数据库

b.在我的电脑中删除LOG文件

c.附加数据库:

企业管理器--服务器--数据库--右键--附加数据库

此法将生成新的LOG，大小只有500多K

或用代码：

下面的示例分离 pubs，然后将 pubs 中的一个文件附加到当前服务器。

a.分离

E X E C sp_detach_db @dbname = 'pubs'

b.删除日志文件

c.再附加

E X E C sp_attach_single_file_db @dbname = 'pubs',

@physname = 'c:\Program Files\Microsoft SQL Server\MSSQL\Data\pubs.mdf'

5.为了以后能自动收缩,做如下设置:

企业管理器--服务器--右键数据库--属性--选项--选择"自动收缩"

--SQL语句设置方式:

E X E C sp_dboption '数据库名', 'autoshrink', 'TRUE'

6.如果想以后不让它日志增长得太大

企业管理器--服务器--右键数据库--属性--事务日志

--将文件增长限制为xM(x是你允许的最大数据文件大小)

--SQL语句的设置方式:

alter database 数据库名 modify file(name=逻辑文件名,maxsize=20)

特别注意：

请按步骤进行,未进行前面的步骤,请不要做后面的步骤

否则可能损坏你的数据库.

一般不建议做第4,6两步

第4步不安全,有可能损坏数据库或丢失数据

第6步如果日志达到上限,则以后的数据库处理会失败,在清理日志后才能恢复.

另外提供一种更简单的方法，本人屡试不爽，建议大家使用。

更简单的方法：

1。右建数据库属性窗口--故障还原模型--设为简单

2。右建数据库所有任务--收缩数据库

3。右建数据库属性窗口--故障还原模型--设为大容量日志记录

可能有不少朋友遇到过这样的问题：

update或delete语句忘带了where子句，或where子句精度不够，执行之后造成了严重的后果，

这种情况的数据恢复只能利用事务日志的备份来进行，所以如果你的SQL没有进行相应的全库备份

或不能备份日志（truncate log on checkpoint选项为1），那么就无法进行数据的恢复了，或者

只能恢复到最近一次的备份的数据了。

以下简单说明恢复数据方法：

1，如果误操作之前存在一个全库备份（或已有多个差异备份或增量备份），首先要做的事就是进进行一次日志备份（如果为了不让日志文件变大而置trunc. log on chkpt.选项为1那你就死翘了）

backup log dbName to disk='fileName'

2，恢复一个全库备份，注意需要使用with norecovery，如果还有其他差异或增量备份，则逐个恢复

restore database dbName from disk='fileName' with norecovery

3，恢复最后一个日志备份即刚做的日志备份，指定恢复时间点到误操作之前的时刻

restore log dbName from disk='fileName'

with stopat='date_time'

以上这些操作都可以在SQL SERVER企业管理器里完成，难度不大。。。

日志文件满而造成SQL数据库无法写入文件时，可用两种方法：

一种方法：清空日志。

1．打开查询分析器，输入命令

DUMP TRANSACTION 数据库名 WITH NO_LOG

另一种方法有一定的风险性，因为SQL SERVER的日志文件不是即时写入数据库主文件的，如处理不当，会造成数据的损失。

1: 删除LOG

分离数据库企业管理器－＞服务器－＞数据库－＞右键－＞分离数据库

2：删除LOG文件

附加数据库企业管理器－＞服务器－＞数据库－＞右键－＞附加数据库

此法生成新的LOG，大小只有500多K。

注意：建议使用第一种方法。

如果以后,不想要它变大。

SQL2000下使用：

在数据库上点右键->属性->选项->故障恢复-模型-选择-简单模型。

或用SQL语句：

alter database 数据库名 set recovery simple

另外，Truncate log on checkpoint(此选项用于SQL7.0，SQL 2000中即故障恢复模型选择为简单模型)当执行CHECKPOINT 命令时如果事务日志文件超过其大小的70% 则将其内容清除在开发数据库时时常将此选项设置为True Auto shrink定期对数据库进行检查当数据库文件或日志文件的未用空间超过其大小的25%时，系统将会自动缩减文件使其未用空间等于25% 当文件大小没有超过其建立时的初始大小时不会缩减文件缩减后的文件也必须大于或等于其初始大小对事务日志文件的缩减只有在对其作备份时或将Truncate log on checkpoint 选项设为True 时才能进行。

注意：一般立成建立的数据库默认属性已设好，但碰到意外情况使数据库属性被更改，请用户清空日志后，检查数据库的以上属性，以防事务日志再次充满。

当然，如果误操作是一些不记日志的操作比如truncate table，select into等操作，那么是无法利

用上述方法来恢复数据的...

删除SQL日志1: 删除LOG

1：分离数据库企业管理器－＞服务器－＞数据库－＞右键－＞分离数据库

2：删除LOG文件

3：附加数据库企业管理器－＞服务器－＞数据库－＞右键－＞附加数据库

此法生成新的LOG，大小只有520多K

再将此数据库设置自动收缩

或用代码：

下面的示例分离 77169database，然后将 77169database 中的一个文件附加到当前服务器。

EXEC sp_detach_db @dbname = '77169database'

EXEC sp_attach_single_file_db @dbname = '77169database',

@physname = 'c:\Program Files\Microsoft SQL Server\MSSQL\Data\77169database.mdf

2:清空日志

DUMP TRANSACTION 库名 WITH NO_LOG /// DUMP TRANSACTION ulionmis WITH NO_LOG

再：

企业管理器--右键你要压缩的数据库--所有任务--收缩数据库--收缩文件--选择日志文件--在收缩方式里选择收缩至XXM,这里会给出一个允许收缩到的最小M数,直接输入这个数,确定就可以了

3: 如果想以后不让它增长

企业管理器－＞服务器－＞数据库－＞属性－＞事务日志－＞将文件增长限制为2M

自动收缩日志,也可以用下面这条语句

Alter DATABASE 数据库名

SET AUTO_SHRINK ON

故障还原模型改为简单,用语句是

USE MASTER

Alter DATABASE 数据库名 SET RECOVERY SIMPLE

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

截断事务日志：

BACKUP LOG { database_name | @database_name_var }

{

[ WITH

{ NO_LOG | TRUNCATE_ONLY } ]

}

--压缩日志及数据库文件大小

/*--特别注意

请按步骤进行,未进行前面的步骤,请不要做后面的步骤

否则可能损坏你的数据库.

--*/

1.清空日志

DUMP TRANSACTION 库名 WITH NO_LOG

2.截断事务日志：

BACKUP LOG 数据库名 WITH NO_LOG

3.收缩数据库文件(如果不压缩,数据库的文件不会减小

企业管理器--右键你要压缩的数据库--所有任务--收缩数据库--收缩文件

--选择日志文件--在收缩方式里选择收缩至XXM,这里会给出一个允许收缩到的最小M数,直接输入这个数,确定就可以了

--选择数据文件--在收缩方式里选择收缩至XXM,这里会给出一个允许收缩到的最小M数,直接输入这个数,确定就可以了

也可以用SQL语句来完成

--收缩数据库

DBCC SHRINKDATABASE(客户资料)

--收缩指定数据文件,1是文件号,可以通过这个语句查询到:select * from sysfiles

DBCC SHRINKFILE(1)

4.为了最大化的缩小日志文件(如果是sql 7.0,这步只能在查询分析器中进行)

a.分离数据库:

企业管理器--服务器--数据库--右键--分离数据库

b.在我的电脑中删除LOG文件

c.附加数据库:

企业管理器--服务器--数据库--右键--附加数据库

此法将生成新的LOG，大小只有500多K

或用代码：

下面的示例分离 77169database，然后将 77169database 中的一个文件附加到当前服务器。

a.分离

EXEC sp_detach_db @dbname = '77169database'

b.删除日志文件

c.再附加

EXEC sp_attach_single_file_db @dbname = '77169database',

@physname = 'c:\Program Files\Microsoft SQL Server\MSSQL\Data\77169database.mdf'

5.为了以后能自动收缩,做如下设置:

企业管理器--服务器--右键数据库--属性--选项--选择"自动收缩"

--SQL语句设置方式:

EXEC sp_dboption '数据库名', 'autoshrink', 'TRUE'

6.如果想以后不让它日志增长得太大

企业管理器--服务器--右键数据库--属性--事务日志

--将文件增长限制为xM(x是你允许的最大数据文件大小)

--SQL语句的设置方式:

alter database 数据库名 modify file(name=逻辑文件名,maxsize=20)

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

/*--压缩数据库的通用存储过程

压缩日志及数据库文件大小

因为要对数据库进行分离处理

所以存储过程不能创建在被压缩的数据库中

--*/

/*--调用示例

exec p_compdb 'test'

--*/

use master --注意,此存储过程要建在master数据库中

if exists (select * from dbo.sysobjects where id = object_id(N'[dbo].[p_compdb]') and OBJECTPROPERTY(id, N'IsProcedure') = 1)

drop procedure [dbo].[p_compdb]

create proc p_compdb

@dbname sysname, --要压缩的数据库名

@bkdatabase bit=1, --因为分离日志的步骤中,可能会损坏数据库,所以你可以选择是否自动数据库

@bkfname nvarchar(260)='' --备份的文件名,如果不指定,自动备份到默认备份目录,备份文件名为:数据库名+日期时间

--1.清空日志

exec('DUMP TRANSACTION ['+@dbname+'] WITH NO_LOG')

--2.截断事务日志：

exec('BACKUP LOG ['+@dbname+'] WITH NO_LOG')

--3.收缩数据库文件(如果不压缩,数据库的文件不会减小

exec('DBCC SHRINKDATABASE(['+@dbname+'])')

--4.设置自动收缩

exec('EXEC sp_dboption '''+@dbname+''',''autoshrink'',''TRUE''')

--后面的步骤有一定危险,你可以可以选择是否应该这些步骤

--5.分离数据库

if @bkdatabase=1

begin

if isnull(@bkfname,'')=''

set @bkfname=@dbname+'_'+convert(varchar,getdate(),112)

+replace(convert(varchar,getdate(),108),':','')

select 提示信息='备份数据库到SQL 默认备份目录,备份文件名:'+@bkfname

exec('backup database ['+@dbname+'] to disk='''+@bkfname+'''')

end

--进行分离处理

create table #t(fname nvarchar(260),type int)

exec('insert into #t select filename,type=status&0x40 from ['+@dbname+']..sysfiles')

exec('sp_detach_db '''+@dbname+'''')

--删除日志文件

declare @fname nvarchar(260),@s varchar(8000)

declare tb cursor local for select fname from #t where type=64

open tb

fetch next from tb into @fname

while @@fetch_status=0

begin

set @s='del "'+rtrim(@fname)+'"'

exec master..xp_cmdshell @s,no_output

fetch next from tb into @fname

end

close tb

deallocate tb

--附加数据库

set @s=''

declare tb cursor local for select fname from #t where type=0

open tb

fetch next from tb into @fname

while @@fetch_status=0

begin

set @s=@s+','''+rtrim(@fname)+''''

fetch next from tb into @fname

end

close tb

deallocate tb

exec('sp_attach_single_file_db '''+@dbname+''''+@s)

日志文件满而造成SQL数据库无法写入文件时，可用两种方法：

一种方法：清空日志。

1．打开查询分析器，输入命令

DUMP TRANSACTION 数据库名 WITH NO_LOG

另一种方法有一定的风险性，因为SQL SERVER的日志文件不是即时写入数据库主文件的，如处理不当，会造成数据的损失。

1: 删除LOG

分离数据库企业管理器－＞服务器－＞数据库－＞右键－＞分离数据库

2：删除LOG文件

附加数据库企业管理器－＞服务器－＞数据库－＞右键－＞附加数据库

此法生成新的LOG，大小只有500多K。

注意：建议使用第一种方法。

如果以后,不想要它变大。

SQL2000下使用：

在数据库上点右键->属性->选项->故障恢复-模型-选择-简单模型。

或用SQL语句：

alter database 数据库名 set recovery simple

如何删除sql 2000日志

2004年9月24日11:23

前几天也碰到日志文件过大的问题，数据库实际大小为600M, 日志文件实际大小为33M, 但日志文件占用空间为2.8G!!!

试了多种方式，SHIRNK DATABASE， TRUNCATE LOG FILE, 都没办法将文件缩小。无论如何，这应该算SQL SERVER的一个BUG吧。

后来找到下面的代码，就可以将日志文件缩小到自己想要的大小了。把代码COPY到查询分析器里，，然后修改其中的3个参数(数据库名，日志文件名，和目标日志文件的大小)，运行即可(我已经用过多次了)

-----

SET NOCOUNT ON

DECLARE @LogicalFileName sysname,

@MaxMinutes INT,

@NewSize INT

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

Select　@LogicalFileName = ‘Marias_log‘,　-- 日志文件名

@MaxMinutes = 10,　　　　　　　 -- Limit on time allowed to wrap log.

@NewSize = 100　　　　　　　　　-- 你想设定的日志文件的大小(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

删除MS SQL Server 2000日志

1.打开MS SQL Server 2000企业管理器

2.打开数据库，选中需要删除日期的数据库，点击“察看”，选择“任务板”：

3.鼠标右键点中需要删除日期的数据库，选择右键菜单“所有任务”-“备份数据库”：

4.选择“事务日志”：

5.点击“添加”，选择“文件名”：

6.选择备份目录，输入文件名，点击“确定”：

7.点击“确定”：

8.选择“重写现有媒体”，点击“确定”：

9.开始备份：

10.备份完成：

事务日志删除了一部分，如果还不够小，则再重复一次。

11.重新鼠标右键点中需要删除日志的数据库，选择右键菜单“所有任务”-“收缩数据库”：

12.点击“文件”：

13.选择日志“数据库文件”，在“收缩操作”中选择“从文件结尾截断可用空间”，点击“确定”：

14.日志收缩完毕：

关于SQL Server事务日志的问题汇总

1、用BACKUP LOG database WITH NO_LOG清除日志

把数据库属性中的故障还原模型改为“简单”可以大大减慢日志增长的速度。如果把还原模型调到简单，这样就不支持时间点还原了，但是日志文件会很小，如果数据比较重要推荐还是把数据库的还原模型调为完全。

用BACKUP LOG database WITH NO_LOG命名后，会截断不活动日志，不减小物理日志文件的大小，但逻辑日志会减小，收缩数据库后会把不活动虚拟日志删除来释放空间，不会损坏数据。

如果日志被截断并收缩数据库后，就不能直接用最近的一个全库备份做时间点还原，建议立即备份数据库，以防万一。

2、sql server运行中，删除主数据库事务日志文件

步骤如下：(1)、分离数据库：企业管理器－－数据库－－右击你要删除日志的数据库－－所有任务－－分离数据库

(2)、然后删除日志文件

(3)、然后再附加数据库：企业管理器－－数据库－－右击数据库－－所有任务－－附加数据库。这时候只附加mdf就可以了。

3、压缩SQL数据库及日志的详细方法

数据库在使用一段时间后，时常会出现因数据删除而造成数据库中空闲空间太多的情况，这时就需要减少分配给数据库文件和事务日志文件的磁盘空间，以免浪费磁盘空间。当数据库中没有数据时，可以修改数据库文件属性直接改变其占用空间，但当数据库中有数据时，这样做会破坏数据库中的数据，因此需要使用压缩的方式来缩减数据库空间。可以在数据库属性选项中选择“Auto shrink”选项，让系统自动压缩数据库，也可以用人工的方法来压缩。人工压缩数据库有以下两种方式：

1)、用Enterprise Manager 压缩数据库

在Enterprise Manager 中在所要压缩的数据库上单击右键，从快捷菜单中的“所有任务（All Tasks）”中选择“Shrink Database（压缩数据库）”选项，可以在对话框中选择数据库的压缩方式，也可以选择使用压缩计划或压缩单个文件。单击“Files”按钮，会出现压缩数据库文件对话框，可以针对每个数据库文件进行不同的压缩设置。单击“Change” 按钮，会出现压缩计划编辑对话框，可以指定压缩计划的执行方式。单击“Change” 按钮，会出现循环工作计划编辑对话框，可以编辑计划执行的周期或时间点。设置完成后单击“OK” 按钮就开始压缩数据库，在压缩结束后会显示一个压缩情况信息框。

2)、用Transact-SQL 命令压缩数据库

可以使用DBCC SHRINKDATABASE 和DBCC SHRINKFILE 命令来压缩数据库。其中DBCC SHRINKDATABASE 命令对数据库进行压缩，DBCC SHRINKFILE 命令对数据库中指定的文件进行压缩。

(1)、DBCC SHRINKDATABASE

DBCC SHRINKDATABASE 命令语法如下：

DBCC SHRINKDATABASE (database_name [, target_percent][, {NOTRUNCATE | TRUNCATEONLY}] )

各参数说明如下：

·target_percent 指定将数据库压缩后，未使用的空间占数据库大小的百分之几。如果指定的百分比过大，超过了压缩前未使用空间所占的比例，则数据库不会被压缩。并且压缩后的数据库不能比数据库初始设定的容量小。

·NOTRUECATE

将数据库缩减后剩余的空间保留在数据库，中不返还给操作系统。如果不选择此选项，则剩余的空间返还给操作系统。

·TRUNCATEONLY

将数据库缩减后剩余的空间返还给操作系统。使用此命令时SQL Server 将文件缩减到最后一个文件分配，区域但不移动任何数据文件。选择此项后，target_percent 选项就无效了。

例：压缩数据库mytest 的未使用空间为数据库大小的20%。

dbcc shrinkdatabase (mytest, 20)

运行结果如下：

DBCC execution completed. If DBCC printed error messages, contact your system administrator.

(2)、DBCC SHRINKFILE

DBCC SHRINKFILE 命令压缩当前数据库中的文件。其语法如下：

DBCC SHRINKFILE ( {file_name | file_id }{ [, target_size] |[, {EMPTYFILE | NOTRUNCATE | TRUNCATEONLY}] } )

各参数说明如下：

·file_id

指定要压缩的文件的鉴别号（Identification number，即ID）。文件的ID 号可以通过 FILE_ID（）函数或如本章前面所讲述的Sp_helpdb 系统存储过程来得到。

·target_size

指定文件压缩后的大小。以MB 为单位。如果不指定此选项，SQL Server 就会尽最大可能地缩减文件。

·EMPTYFILE

指明此文件不再使用，将移动所有在此文件中的数据到同一文件组中的其它文件中去。执行带此参数的命令后，此文件就可以用Alter DATABASE 命令来删除了。

其余参数NOTRUNCATE 和TRUNCATEONLY 与DBCC SHRINKDATABASE 命令中的含义相同。

例: 压缩数据库mydb 中的数据库文件mydb_data2 的大小到1MB。

use mydb dbcc shrinkfile (mydb_data2, 1)

目前的状况是：MDF文件保存完好（已拷出来），LDF已丢失。使用

EXEC sp_attach_single_file_db @dbname = 'TyBusiness',

@physname = 'E:\Help\TyBusiness.MDF'

报如下错误：

未能打开新数据库 'TyBusiness'。Create DATABASE 将终止。

设备激活错误。物理文件名 'd:\Program Files\Microsoft SQL Server\MSSQL\TyBusiness_log.ldf' 可能有误。

1.先建一个与你要恢复的数据库名称一样的数据库.

2.停止sql server,把你的数据库替换这个数据库

3.重起sql server,把数据库设成紧急状态:

sp_configure 'allow',1

reconfigure with overirde

update sysdatabases set status=32768 where name='yourdata'

4.重建日志文件

dbcc rebuild_log('yourdata','your data path\newdata_log.ldf')

5.取消紧急模式

update sysdatabases set status=0 where name='yourdata'

restore sysdatabases yourdata with recovery

sp_configure 'allow',0

reconfigure with override

6.重起sql server

7.ok

减小SQL日志。

use yourdatabasename

backup log yourdatabasename with TRUNCATE_ONLY

DBCC SHRINKFILE (逻辑文件名, 收缩后的大小)

在Query Analyzer中:

1.執行:

EXEC sp_detach_db 'dbname', 'true'; --將你的數據庫卸除

然後將SQL Server安裝路徑下的data目錄中的dbname_log.ldf文件移走或刪除

EXEC sp_attach_single_file_db

'dbname','d:\mssql7\data\dbname.mdf';

--以單文件形式恢復數據庫,系統自動分配給你一個500K大小的日誌文件.

use yourdatabasename

backup log yourdatabasename with TRUNCATE_ONLY

DBCC SHRINKFILE (逻辑文件名, 收缩后的大小)

彻底删除数据库日志的方法

现在私服运行了一段时间，特别是人比较多的服，相信大家的数据库日志log文件已经相当大了吧。其实这些log文件对于我们普通用户来说是没什么用，上面只是详细的记录了所有对该数据库的每一步操作，实际的数据已经保存到数据库文件中了，所以是不可能有什么回档之类的问题的。以前我们也问过微软的人，据说是如果你的数据库文件坏掉了，有这个他们有办法帮助你恢复数据库，但是由于方法并不公开，所以对于我们来说，这只是占空间的东西。因为原先没觉得这个是问题，所以也没站出来介绍一下，现在看越来越多的朋友问这个问题，就提供一下方法。下面是主题了：

1、进入企业管理器，选中数据库，比如muonline

2、所有任务->分离数据库

3、到数据库文件的存放目录，将MuOnline_log.LDF文件删除，你怕S的话可以拷出去

4、企业管理器->附加数据库，选muonline，这个时候你会看见日志文件这项是一个叉，不要紧继续，此时数据库就会提示你该数据库无日志是否创建一个新的，确定就是了。

5、记得数据库重新附加后用户要重新设置一下。

以后如果新的日志文件变大了，再继续这个步骤就行了

--假设test2为数据库名称

在查询分析器中执行：

backup log MuOnline with NO_LOG

backup log MuOnline with TRUNCATE_ONLY

DBCC SHRINKDATABASE(MuOnline)

将上面的语句多次执行，直到日志文件缩小。

exec sp_dboption MuOnline,autoshrink,on

建立作业,每半个小时一次日志备份,每天一次完全数据库备份。

在Log收缩到正常大小后，将autoshrink选项设置为off。

查询分析器里运行:

backup log MuOnlie with NO_LOG

backup log MuOnlie with TRUNCATE_ONLY

DBCC SHRINKDATABASE(MuOnlie)

关于SQL的日志清理命令!大家看看有没有用吧!

BACKUP LOG MuOnline WITH NO_LOG

DBCC SHRINKDATABASE(MuOnline,10)

这是清理MuOnline日志的千万点到MuOnline再选查询分析器不然整理了其他数据库会出错的

看看这个

关于各种日志暴大的解决办法（3种）

关于各种日志暴大的解决办法

要限制sql日志的大小很容易，只要选到那两个数据库（muonline和ranking）然后右键属性，在数据文件和事务日志里面就可以改

关键是那个joinserver的日志，有时候很正常，一天下来顶多几十m，有时候1分钟就能赏到4个G，其实要他不生成那么大的日志很简单，只要到joinserver的目录里面把log那个目录删除或改名就可以了（我就是这么干的），一点都不影响使用，开joinserver的时候它只会说write log error，对正常使用没有影响，这样joinserver目录就一直是700多k了，哈哈

对于GS和其他的日志，因为都很小，所以就没改，个人认为其实也可以这么干的

真正解决数据库日志大的方法

首先在数据库属性里把按百分比增长从10％改为1％，这样就大大限制了增长速度

其次在每次重启服务器的时候，在查询器里执行下面的，这样的方法是我认为最安全也是最简单的，建议置顶

感觉好用的朋友顶了

backup log MuOnline with NO_LOG

backup log MuOnline with TRUNCATE_ONLY

DBCC SHRINKDATABASE(MuOnline)

解决数据库日志大的方法

、进入企业管理器，选中数据库，比如muonline

2、所有任务->分离数据库

3、到数据库文件的存放目录，将MuOnline_log.LDF文件删除，你怕S的话可以拷出去

5、记得数据库重新附加后用户要重新设置一下

[推荐]数据库自动备份、缩小以及防止回档

不要在属性里限制数据库大小，这样文件容量满的时候会出现回档

建立作业，每天自动备份数据库，自动删除2天前的备份

建立作业，每天运行一次以下代码，缩小日志文件

backup log MuOnline with NO_LOG

backup log MuOnline with TRUNCATE_ONLY

DBCC SHRINKDATABASE(MuOnline)

我就是这么做的，什么问题都没有，MU服务端全部用到的空间顶多2个G

日志可以这样减肥！！

右击MuOnline，所有任务，分离数据库

然后到D:\Muserver\db 把那个.log文件删掉

你会发现MuOnline数据库消失了

右击一下，所有任务，点附加数据库

路径指向D:\Muserver\db 选中里面的.mdf

你会发现日志有个大叉叉

不管它，直接点确定。

系统提示找不到日志，要不要新建一个

新建一个就Ok了。

这样减肥效果不错吧。

解决方法

日志文件满而造成SQL数据库无法写入文件时，可用两种方法：

一种方法：清空日志。

1．打开查询分析器，输入命令

DUMP TRANSACTION 数据库名 WITH NO_LOG

另一种方法有一定的风险性，因为SQL SERVER的日志文件不是即时写入数据库主文件的，如处理不当，会造成数据的损失。

1: 删除LOG

分离数据库企业管理器－＞服务器－＞数据库－＞右键－＞分离数据库

2：删除LOG文件

附加数据库企业管理器－＞服务器－＞数据库－＞右键－＞附加数据库

此法生成新的LOG，大小只有500多K。

注意：建议使用第一种方法。

如果以后,不想要它变大。

SQL2000下使用：

在数据库上点右键->属性->选项->故障恢复-模型-选择-简单模型。

或用SQL语句：

alter database 数据库名 set recovery simple

另外，如上图中数据库属性有两个选项，与事务日志的增长有关：

Truncate log on checkpoint(此选项用于SQL7.0，SQL 2000中即故障恢复模型选择为简单模型)当执行CHECKPOINT 命令时如果事务日志文件超过其大小的70% 则将其内容清除在开发数据库时时常将此选项设置为True Auto shrink定期对数据库进行检查当数据库文件或日志文件的未用空间超过其大小的25%时，系统将会自动缩减文件使其未用空间等于25% 当文件大小没有超过其建立时的初始大小时不会缩减文件缩减后的文件也必须大于或等于其初始大小对事务日志文件的缩减只有在对其作备份时或将Truncate log on checkpoint 选项设为True 时才能进行。

减少SQL日志的方法

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

一:

分享]解决SQL日志增大的办*[望置顶]

--假设test2为数据库名称

在查询分析器中执行：

backup log MuOnline with NO_LOG

backup log MuOnline with TRUNCATE_ONLY

DBCC SHRINKDATABASE(MuOnline)

将上面的语句多次执行，直到日志文件缩小。

exec sp_dboption 'MuOnline','autoshrink','on'

建立作业,每半个小时一次日志备份,每天一次完全数据库备份。

在Log收缩到正常大小后，将autoshrink选项设置为off。

二:

数据库增大是因为你的日志增大了，以前大家讨论过的，最简单可行的办法就是在你数据库属性->选项->故障还原里面选成简单模式(缺省为完全模式)，然后选收缩数据库进行一次收缩，以后你的数据库基本就不怎么会增长了

三:

1、进入企业管理器，选中数据库，比如muonline

2、所有任务->分离数据库

3、到数据库文件的存放目录，将MuOnline_log.LDF文件删除，你怕S的话可以拷出去

5、记得数据库重新附加后用户要重新设置一下。

本文链接

SQL Server 2005中的SSIS维护计划

2012-01-09T02:50:00Z

SQL Server的每一个版本都已经逐渐变得越来越自我调整和自我维护了。然而，对于基本维护的需求，例如删除索引碎片，更新统计数据，检查数据库一致性，以及进行备份仍然是不会消失的。你可以想象一下，索引的维护就像是给你的汽车换油，备份就像是买保险。你可以没有保险，但是一旦你需要它，它就在手边。同样的，你的汽车可以在没有换油的情况下跑上几千公里，但是经常维护会产生更好的性能，并且可以让你的汽车寿命延续几年。

SQL Server 2005把维护计划以SSIS包的方式予以实现，它为任务的定制提供更大的灵活性。现在开始计划你要执行的Transact-SQL命令，以便察看，而不要用没有文档记载的SQL Server 2000中的存储过程。另一个你可以检查的领域是执行历史，它可以使解决问题的维护计划在很大程度上简单化。

目录表

SQL Server 2000中的维护计划

使用向导创建一个维护计划

在你的SSIS包的后面

改善SQL Server 2005

SQL Server 2000中的维护计划

让我们简单地回顾一下SQL Server 2000中的数据库维护计划是什么样子。你通过点击一些向导的界面创建一个维护计划，它让你选择完全备份、事务日至备份，索引维护和检查数据库一致性的选项。这听起来很简单，是吗?是的，除非维护计划是个“黑盒子”向导并没有显示给你刚才创建的任务会执行的Transact-SQL语句。

更进一步地讲，如果你曾经检查过通过维护计划向导创建的任务的属性，你就会知道任务的步骤看起来是下面这个样子:

EXECUTE master.dbo.xp_sqlmaint N'-PlanID 2CF0E6F5-C6DC-462A-8C50-4CF305C01FD2 -WriteHistory -VrfyBackup -BkUpMedia DISK -BkUpDB "e:\Program Files\Microsoft SQL Server\MSSQL\BACKUP" -DelBkUps 5DAYS -BkExt "BAK"'

为了了解这个维护计划屏幕之后的事情，你必须让你自己熟悉xp_sqlmaint扩展存储程序。这个程序也叫做 SQLMAINT工具，大概有一打的开关。此外，你还可以从命令行调用SQLMAINT。如果维护计划任务在任务历史中曾经失败过，在任务历史中显示了如下完全没有意义的信息片断的话，也许这样更重要:

Executed as user: ServerName\UserName. sqlmaint.exe failed. [SQLSTATE 42000] (Error 22029). The step failed.

幸运的是，你可以浏览到数据库维护计划的文件目录中，右击计划，并且选择“维护计划历史”来获得更加详细的错误信息。然而，即使是这样的解决问题的方法在碰到维护计划任务不总是可靠的时候，也会出错。

在nutshell SQL Server2000 维护计划向导中，创建重要维护任务非常简单，但是从可用性和支持的角度来说，就差得远了。

与维护计划的其他图形一样，在SQL Server2005中也有很大的改善。现在，维护计划是以SQL Server集成服务(SSIS)包的形式实现的;这就允许在包含在维护计划中的任务之间创建优先约束。如果你还没有使用SSIS的话，这个消息也许会对你造成威胁——但是不要担心，你仍然可以通过使用SQL Server管理套件(SSMS)中的向导来建立一个维护计划。在SSIS中构建维护计划，将会提供额外的灵活性，但是向导会帮助你开始，并且让你构建一个可靠的维护计划，而不需要你对SSIS有任何的了解，正如你下面将要看到的。

使用向导创建一个维护计划

要通过使用向导来创建一个维护计划，首先浏览到SSMS的管理目录，右击“维护计划”文件夹，然后选择维护计划向导。注意，SQL Server Agent服务必须要运行起来，在你创建数据库维护计划的时候。最开始的向导界面允许你选择目标数据库，并且指定连接到服务器上必需的安全信任书。接下来，你就可以选择你想要执行的维护任务，如下图所示:

?498)this.width=498;">

屏幕截图1: 选择维护任务

这个屏幕给你一个有关你想要完成的每一种类型的维护任务的大概描述。

接下来，你可以定义维护计划任务的执行顺序。例如，你可以在查看数据库一致性并且运行一个完全的数据库备份之前重新构建索引。然后，你就可以指定每个任务可能会影响到的目标数据库和对象。例如，重新构建索引可能会影响到单个的数据库，多个数据库，或者某个环境下的所有数据库。此外，你还能选择在哪个特定的表和索引视图上面重新构建索引。你还可以为重新构建索引制定一些高级选项，例如，你想要留给索引页面使用的空闲空间总量，无论你是否想要填充索引，还是你想要在重新构建它们的时候，还让它们在线。指定索引选项的屏幕如下所示:

498)this.width=498;">

屏幕截图2: 指定索引选项

接下来，为你想要执行的维护计划定义时间表。或者你还可以根据需要来运行维护计划。接下来的向导界面允许你指定记录维护计划执行过程中状态日至的文本文件。你可以指定电子邮件地址，以便将维护计划执行状态发送给你。最后一个屏幕提供了你在前面几个界面上选择的主要的维护计划选项。就是它了!正如我先前说过的，你不需要了解SSIS就可以创建一个数据库维护计划。

在你的SSIS包后面的内容

现在，让我们看看实际上在构建过程中发生了什么。要查看你刚刚创建的SSIS包，右击维护计划，然后选择“修改”。你就可以看到类似下面的画面:

498)this.width=498;">

屏幕截图3:查看SSIS 包

注意，蓝色箭头指出了执行的流程;蓝色的表示数据库一致性将会在“重新构建索引”任务完成之后进行检查。这个向导指挥让你评估是否每个任务都在执行下个任务之前完成了;所以，无论“重新构建索引”的任务成功了或者是失败了，维护计划都会继续执行下一步的检查数据库一致性任务。但是如果你想要按照某种条件来执行不同的任务，就是前面的任务是失败还是成功了?如果你双击蓝色箭头，SSIS就会允许你编辑优先约束，如下图所示:

498)this.width=498;">

屏幕截图4: 编辑优先约束.

从这个界面，你可以评估每个任务的执行结果，并且基于成功、失败，或者前面某个任务的完成来调用剩下的任务。你可以在执行其他任务之前，检查一个连接当前任务的表达式。这就是SSIS之所以特别好用的原因之一。

SQL Server 2005的改善

非常希望你能喜欢维护计划向导所作的改善，还有你可以通过点击向导屏幕来创建的SSIS包。但是这只是改善中很小的一部分!

SQL Server 2005可以让你查看通过维护向导的每个步骤创建的Transact-SQL命令。SQLMAINT工具(与xp_sqlmaint扩展存储过程一起)，都被宣布不再被支持。在维护计划的头巾之下，仍然是作为任务来实现，但是不再调用xp_sqlmaint，任务执行的是SSIS包而已。每项任务都可以通过传递参数值和配置文件来进行定制，除了执行和登录选项之外，如下图所示:

498)this.width=498;">

屏幕截图5:定制任务

在这篇文章中，我没有地方再来解释维护任务属性上面的每个标签了。你可以通过阅读SQL Server在线文档来学习更多。但是你可以了解，SSIS可以为定制维护计划任务提供更大的灵活性。

SQL Server 2005还允许你检查维护计划执行的历史，通过右击维护计划并选择“察看历史”来实现。在结果对话框内，你可以看到维护计划每个步骤的历史信息:

498)this.width=498;">

屏幕截图6: 查看维护计划的历史

在屏幕的底部，点击“察看T-SQL”，会显示给你任务实际上执行的Transact-SQL命令(或者一系列命令)，如下图所示:

498)this.width=498;">

屏幕截图7: 查看 T-SQL 命令

小结

这篇文章展示了SQL 2005中数据库维护计划的一些受欢迎的改善。在以前的软件版本中，维护计划运行得也相当的好，但是有一点点含糊和难以解决问题。新版本以 SSIS包的方式实现了维护计划，为定义维护计划任务、登录和配置选项的执行顺序提高了极大的灵活性。此外，维护计划任务不再需要通过若干个开关来调用一个神秘的扩展存储过程。相反，他们可以执行那些你可以查看的Transact-SQL命令，你会发现这样很舒服。最后但是绝对不是最不重要的，维护计划对于解决问题来说相当简单了，因为经过改善的用户界面可以让你查看它们的执行历史。

本文链接

sql 查询所有数据库、表名、表字段总结

2011-08-10T04:27:00Z

ms sql server
1、查询所有表
select [id], [name] from [sysobjects] where [type] = 'u' order by [name]
2、查询所有数据库
3、select [name] from [sysdatabases] order by [name]
查询表中字段
select [name] from [syscolumns] where [name] = 'tableXXX'order by [colid]

oracle

1、查找表的所有索引（包括索引名，类型，构成列）：

select t.*,i.index_type from user_ind_columns t,user_indexes i where t.index_name = i.index_name and t.table_name = i.table_name and t.table_name = 要查询的表

2、查找表的主键（包括名称，构成列）：

select cu.* from user_cons_columns cu, user_constraints au where cu.constraint_name = au.constraint_name and au.constraint_type = 'P' and au.table_name = 要查询的表

3、查找表的唯一性约束（包括名称，构成列）：

select column_name from user_cons_columns cu, user_constraints au where cu.constraint_name = au.constraint_name and au.constraint_type = 'U' and au.table_name = 要查询的表

4、查找表的外键（包括名称，引用表的表名和对应的键名，下面是分成多步查询）：

select * from user_constraints c where c.constraint_type = 'R' and c.table_name = 要查询的表

查询外键约束的列名：

select * from user_cons_columns cl where cl.constraint_name = 外键名称

查询引用表的键的列名：

select * from user_cons_columns cl where cl.constraint_name = 外键引用表的键名

5、查询表的所有列及其属性

select t.*,c.COMMENTS from user_tab_columns t,user_col_comments c where t.table_name = c.table_name and t.column_name = c.column_name and t.table_name = 要查询的表

6、查询所有表
select* from tabs

本文链接

删除sql数据库日志的方法

2011-04-25T06:09:00Z

执行以下sql：

backup log mydbname with no_log
go
dbcc shrinkdatabase(mydbname)
go

然后在企业管理器里面收缩数据库，日志文件大小可以收缩为0M

本文链接

VS2010项目放到VS2008下的方法

2011-02-25T01:35:00Z

一、将.sln文件中的

Microsoft Visual Studio Solution File, Format Version 11.00
# Visual Studio 2010

改成

Microsoft Visual Studio Solution File, Format Version 10.00
# Visual Studio 2008

二、将.csprog文件中的

Project ToolsVersion="4.0"

改为

Project ToolsVersion="2.0"

三、双击.sln文件即可成功打开

本文链接

XML格式与DataTable、DataSet、DataView格式的转换

2010-09-29T02:20:00Z

今天用到一个功能：就是把从数据库读出来的内容转换成XML字符串流格式，并输出给一个功能函数。
在写的过程，为方便以后的使用，我对这一功能进行分装。该类的具体格式如下：
XmlConvert类
命名空间：

using System.Xml;
using System.IO;

XmlToData子类
函数：
1、public static DataSet CXmlToDataSet(string xmlStr)将xml字符串转换成DataSet
2、public static DataTable CXmlToDatatTable(string xmlStr, int tableIndex)；将xml字符串转换成DataTable
3、public static DataSet CXmlFileToDataSet(string xmlFilePath)将xml文件转换成DataSet
4、public static DataTable CXmlToDataTable(string xmlFilePath, int tableIndex)将xml文件转换成DataTable
DataToXml子类
函数：
1、public static string CDataToXml(DataTable dt)；
2、public static string CDataToXml(DataSet ds, int tableIndex)；
3、public static string CDataToXml(DataView dv)；
4、 public static bool CDataToXmlFile(DataTable dt, string xmlFilePath)；
5、public static bool CDataToXmlFile(DataSet ds, int tableIndex, string xmlFilePath)
以上几个功能函数主要实现把Xml字符串、文件转换成DataSet、DataTable、DataView。
源代码中，对各个功能函数都进行了标注，以供大家参考！

/// <summary>
 /// 把DataSet、DataTable、DataView格式转换成XML字符串、XML文件
 /// 章学敏
 /// 2007-08-16
 /// </summary>
 public class DataToXml
 {
 /// <summary>
 /// 将DataTable对象转换成XML字符串
 /// </summary>
 /// <param name="dt">DataTable对象</param>
 /// <returns>XML字符串</returns>
 public static string CDataToXml(DataTable dt)
 {
 if (dt != null)
 {
 MemoryStream ms = null;
 XmlTextWriter XmlWt = null;
 try
 {
 ms = new MemoryStream();
 //根据ms实例化XmlWt
 XmlWt = new XmlTextWriter(ms, Encoding.Unicode);
 //获取ds中的数据
 dt.WriteXml(XmlWt);
 int count = (int)ms.Length;
 byte[] temp = new byte[count];
 ms.Seek(0, SeekOrigin.Begin);
 ms.Read(temp, 0, count);
 //返回Unicode编码的文本
 UnicodeEncoding ucode = new UnicodeEncoding();
 string returnValue = ucode.GetString(temp).Trim();
 return returnValue;
 }
 catch (System.Exception ex)
 {
 throw ex;
 }
 finally
 {
 //释放资源
 if (XmlWt != null)
 {
 XmlWt.Close();
 ms.Close();
 ms.Dispose();
 }
 }
 }
 else
 {
 return "";
 }
 }
 /// <summary>
 /// 将DataSet对象中指定的Table转换成XML字符串
 /// </summary>
 /// <param name="ds">DataSet对象</param>
 /// <param name="tableIndex">DataSet对象中的Table索引</param>
 /// <returns>XML字符串</returns>
 public static string CDataToXml(DataSet ds, int tableIndex)
 {
 if (tableIndex != -1)
 {
 return CDataToXml(ds.Tables[tableIndex]);
 }
 else
 {
 return CDataToXml(ds.Tables[0]);
 }
 }
 /// <summary>
 /// 将DataSet对象转换成XML字符串
 /// </summary>
 /// <param name="ds">DataSet对象</param>
 /// <returns>XML字符串</returns>
 public static string CDataToXml(DataSet ds)
 {
 return CDataToXml(ds, -1);
 }
 /// <summary>
 /// 将DataView对象转换成XML字符串
 /// </summary>
 /// <param name="dv">DataView对象</param>
 /// <returns>XML字符串</returns>
 public static string CDataToXml(DataView dv)
 {
 return CDataToXml(dv.Table);
 }

 /// <summary>
 /// 将DataSet对象数据保存为XML文件
 /// </summary>
 /// <param name="dt">DataSet</param>
 /// <param name="xmlFilePath">XML文件路径</param>
 /// <returns>bool值</returns>
 public static bool CDataToXmlFile(DataTable dt, string xmlFilePath)
 {
 if ((dt != null) && (!string.IsNullOrEmpty(xmlFilePath)))
 {
 string path = HttpContext.Current.Server.MapPath(xmlFilePath);
 MemoryStream ms = null;
 XmlTextWriter XmlWt = null;
 try
 {
 ms = new MemoryStream();
 //根据ms实例化XmlWt
 XmlWt = new XmlTextWriter(ms, Encoding.Unicode);
 //获取ds中的数据
 dt.WriteXml(XmlWt);
 int count = (int)ms.Length;
 byte[] temp = new byte[count];
 ms.Seek(0, SeekOrigin.Begin);
 ms.Read(temp, 0, count);
 //返回Unicode编码的文本
 UnicodeEncoding ucode = new UnicodeEncoding();
 //写文件
 StreamWriter sw = new StreamWriter(path);
 sw.WriteLine("<?xml version="1.0" encoding="utf-8"?>");
 sw.WriteLine(ucode.GetString(temp).Trim());
 sw.Close();
 return true;
 }
 catch (System.Exception ex)
 {
 throw ex;
 }
 finally
 {
 //释放资源
 if (XmlWt != null)
 {
 XmlWt.Close();
 ms.Close();
 ms.Dispose();
 }
 }
 }
 else
 {
 return false;
 }
 }
 /// <summary>
 /// 将DataSet对象中指定的Table转换成XML文件
 /// </summary>
 /// <param name="ds">DataSet对象</param>
 /// <param name="tableIndex">DataSet对象中的Table索引</param>
 /// <param name="xmlFilePath">xml文件路径</param>
 /// <returns>bool]值</returns>
 public static bool CDataToXmlFile(DataSet ds, int tableIndex, string xmlFilePath)
 {
 if (tableIndex != -1)
 {
 return CDataToXmlFile(ds.Tables[tableIndex], xmlFilePath);
 }
 else
 {
 return CDataToXmlFile(ds.Tables[0], xmlFilePath);
 }
 }
 /// <summary>
 /// 将DataSet对象转换成XML文件
 /// </summary>
 /// <param name="ds">DataSet对象</param>
 /// <param name="xmlFilePath">xml文件路径</param>
 /// <returns>bool]值</returns>
 public static bool CDataToXmlFile(DataSet ds, string xmlFilePath)
 {
 return CDataToXmlFile(ds, -1, xmlFilePath);
 }
 /// <summary>
 /// 将DataView对象转换成XML文件
 /// </summary>
 /// <param name="dv">DataView对象</param>
 /// <param name="xmlFilePath">xml文件路径</param>
 /// <returns>bool]值</returns>
 public static bool CDataToXmlFile(DataView dv, string xmlFilePath)
 {
 return CDataToXmlFile(dv.Table, xmlFilePath);
 }
 }

/// <summary>
 /// XML形式的字符串、XML文江转换成DataSet、DataTable格式
 /// 章学敏
 /// 2007-08-16
 /// </summary>
 public class XmlToData
 {
 /// <summary>
 /// 将Xml内容字符串转换成DataSet对象
 /// </summary>
 /// <param name="xmlStr">Xml内容字符串</param>
 /// <returns>DataSet对象</returns>
 public static DataSet CXmlToDataSet(string xmlStr)
 {
 if (!string.IsNullOrEmpty(xmlStr))
 {
 StringReader StrStream = null;
 XmlTextReader Xmlrdr = null;
 try
 {
 DataSet ds = new DataSet();
 //读取字符串中的信息
 StrStream = new StringReader(xmlStr);
 //获取StrStream中的数据
 Xmlrdr = new XmlTextReader(StrStream);
 //ds获取Xmlrdr中的数据
 ds.ReadXml(Xmlrdr);
 return ds;
 }
 catch (Exception e)
 {
 throw e;
 }
 finally
 {
 //释放资源
 if (Xmlrdr != null)
 {
 Xmlrdr.Close();
 StrStream.Close();
 StrStream.Dispose();
 }
 }
 }
 else
 {
 return null;
 }
 }
 /// <summary>
 /// 将Xml字符串转换成DataTable对象
 /// </summary>
 /// <param name="xmlStr">Xml字符串</param>
 /// <param name="tableIndex">Table表索引</param>
 /// <returns>DataTable对象</returns>
 public static DataTable CXmlToDatatTable(string xmlStr, int tableIndex)
 {
 return CXmlToDataSet(xmlStr).Tables[tableIndex];
 }
 /// <summary>
 /// 将Xml字符串转换成DataTable对象
 /// </summary>
 /// <param name="xmlStr">Xml字符串</param>
 /// <returns>DataTable对象</returns>
 public static DataTable CXmlToDatatTable(string xmlStr)
 {
 return CXmlToDataSet(xmlStr).Tables[0];
 }
 /// <summary>
 /// 读取Xml文件信息,并转换成DataSet对象
 /// </summary>
 /// <remarks>
 /// DataSet ds = new DataSet();
 /// ds = CXmlFileToDataSet("/XML/upload.xml");
 /// </remarks>
 /// <param name="xmlFilePath">Xml文件地址</param>
 /// <returns>DataSet对象</returns>
 public static DataSet CXmlFileToDataSet(string xmlFilePath)
 {
 if (!string.IsNullOrEmpty(xmlFilePath))
 {
 string path = HttpContext.Current.Server.MapPath(xmlFilePath);
 StringReader StrStream = null;
 XmlTextReader Xmlrdr = null;
 try
 {
 XmlDocument xmldoc = new XmlDocument();
 //根据地址加载Xml文件
 xmldoc.Load(path);

 DataSet ds = new DataSet();
 //读取文件中的字符流
 StrStream = new StringReader(xmldoc.InnerXml);
 //获取StrStream中的数据
 Xmlrdr = new XmlTextReader(StrStream);
 //ds获取Xmlrdr中的数据
 ds.ReadXml(Xmlrdr);
 return ds;
 }
 catch (Exception e)
 {
 throw e;
 }
 finally
 {
 //释放资源
 if (Xmlrdr != null)
 {
 Xmlrdr.Close();
 StrStream.Close();
 StrStream.Dispose();
 }
 }
 }
 else
 {
 return null;
 }
 }
 /// <summary>
 /// 读取Xml文件信息,并转换成DataTable对象
 /// </summary>
 /// <param name="xmlFilePath">xml文江路径</param>
 /// <param name="tableIndex">Table索引</param>
 /// <returns>DataTable对象</returns>
 public static DataTable CXmlToDataTable(string xmlFilePath, int tableIndex)
 {
 return CXmlFileToDataSet(xmlFilePath).Tables[tableIndex];
 }
 /// <summary>
 /// 读取Xml文件信息,并转换成DataTable对象
 /// </summary>
 /// <param name="xmlFilePath">xml文江路径</param>
 /// <returns>DataTable对象</returns>
 public static DataTable CXmlToDataTable(string xmlFilePath)
 {
 return CXmlFileToDataSet(xmlFilePath).Tables[0];
 }
 }

本文链接

aspnetpager 详解

2010-08-23T13:11:00Z

分页是Web应用程序中最常用到的功能之一，在ASP.NET中，虽然自带了一个可以分页的DataGrid（asp.net 1.1）和GridView（asp.net 2.0）控件，但其分页功能并不尽如人意，如可定制性差、无法通过Url实现分页功能等，而且有时候我们需要对DataList和Repeater甚至自定义数据绑定控件进行分页，手工编写分页代码不但技术难度大、任务繁琐而且代码重用率极低，因此分页已成为许多ASP.NET程序员最头疼的问题之一。
今天闲来无事就学习学习了aspNetPager分页控件的用法:
AspNetPager针对ASP.NET分页控件的不足，提出了与众不同的解决asp.net中分页问题的方案，即将分页导航功能与数据显示功能完全独立开来，由用户自己控制数据的获取及显示方式，因此可以被灵活地应用于任何需要实现分页导航功能的地方，如为GridView、DataList以及Repeater等数据绑定控件实现分页、呈现自定义的分页数据以及制作图片浏览程序等，因为AspNetPager控件和数据是独立的，因此要分页的数据可以来自任何数据源，如SQL Server、Oracle、Access、mysql、DB2等数据库以及XML文件、内存数据或缓存中的数据、文件系统等等。
1.首先下载aspnetpager控件,我这儿的版本是6.0.0.0 点击下载
2.把控件加到项目中(添加自定义控件的方法),并把它拖放到页面上:

<webdiyer:AspNetPager ID="AspNetPager1" runat="server"
AlwaysShow="True" //总是显示分页控件，即使要分页的数据只有一页
OnPageChanged="AspNetPager1_PageChanged" //分页发生改变时触发事件
UrlPaging="true" //通过URL传递分页信息的方式来分页。如果设为true，禁用ViewState也能达到效果。如果设置为false，禁用了viewstate则无法实现分页.
NumericButtonTextFormatString="[{0}]" //页索引数字显示的格式
ShowCustomInfoSection="Left"> //显示当前页和总页数信息，默认值不显示，为left则将显示在页索引前，为right则为页索引后 </webdiyer:AspNetPager>

3.Page_Load事件:

  protected void Page_Load(object sender, EventArgs e)
        {
            if (!Page.IsPostBack)
            {
                BindGridView();
            }
        }

BindGridView方法如下:

public void BindGridView()
 {
 string sql = "select * from gw_newsletter_group";//自定义的SQL语句
 int recordcount;
 DataSet ds = GetPage(sql, this.AspNetPager1.CurrentPageIndex, this.AspNetPager1.PageSize,out recordcount);
 this.AspNetPager1.RecordCount = recordcount;
 this.GridView1.DataSource = ds;
 this.GridView1.DataBind();
 AspNetPager1.CustomInfoHTML = "记录总数：" + AspNetPager1.RecordCount.ToString() + "";
 AspNetPager1.CustomInfoHTML += " 总页数：" + AspNetPager1.PageCount.ToString() + "";
 AspNetPager1.CustomInfoHTML += " 当前页：" + AspNetPager1.CurrentPageIndex.ToString() + "";
 }

其中的GetPage方法代码如下:(GetConnection()是返回一个SqlConnection对象)

/// <summary>
 /// Get Data By CurrentPage
 /// </summary>
 /// <param name="sql">SQL</param>
 /// <param name="currentPage">current Page</param>
 /// <param name="pagesize">Page Size</param>
 /// <param name="recordcount">Total Record</param>
 /// <returns></returns>
 public DataSet GetPage(string sql, int currentPage, int pagesize,out int recordcount)
 {
 SqlDataAdapter ada = new SqlDataAdapter(sql, GetConnection());
 DataSet ds = new DataSet();
 int startRow = (currentPage - 1) * pagesize;
 ada.Fill(ds, startRow, pagesize, "table");
 recordcount = GetPageRecord(sql);
 return ds;
 }

GetPageRecord方法:(返回总的记录数)

  public int GetPageRecord(string sql)
        {
            sql = System.Text.RegularExpressions.Regex.Replace(sql, "ORDER BY.*", "");
            sql = "select count(*) from (" + sql + ") as temp";
            SqlCommand cmd = new SqlCommand(sql, GetConnection());
            cmd.Connection.Open();
            int recordcount = (int)cmd.ExecuteScalar();
            return recordcount;
        }

这里注意要去掉”Order By“的字符串(聚合函数不能和"ORDER BY"连用)
4.另外：还有个事件：

    protected void AspNetPager1_PageChanged(object sender, EventArgs e)
        {
            BindGridView();

        }

到目前为止就可以运行看到效果:
地址栏显示效果:
注意这里是把属性:urlpaging=true,而且如果禁止了ViewState也能实现。
如果把urlpaging=false 的话
如果禁止了ViewState就无法实现分页功能了。
上面的代码中有这样一句话:

AspNetPager1.CustomInfoHTML += " 总页数：" + AspNetPager1.PageCount.ToString() + "";

这里就有一个问题是aspNetPage1.PageCount怎样得出来的呢？我们并没有为它赋值。(这里而且这个属性是只读的)
实际上它的值是本身的控件就实现了：我分析觉得代码可能如下:

public int GetPagerCount(string sql, int pagesize)
        {
            int recordcount = GetPageRecord(sql);//方法见上
            int pagecount=recordcount/pagesize;
            return (recordcount % pagesize == 0 ? pagecount : pagecount + 1);
        }

这样就可以得出到底分页的页数.
最后补充说明：由于我只是初步研究这个控件，不过上面的代码都是经过测试通过的。
而且我还发现这个控件还有很多属性可以改变它的样式外观的。而且还比较灵活的。希望能给朋友们带来一些帮助。
另外如果有什么地方不正确还希望高手能及时的提出来！

本文链接

.NET公共执行类

2010-08-14T23:05:00Z

using System;
using System.Collections;
using System.Collections.Specialized;
using System.Data;
using System.Data.SqlClient;
using System.Configuration;
namespace LiTianPing.DBUtility
{
 /// <summary>
 /// 数据访问抽象基础类
 /// Copyright (C) 2004-2008 LiTianPing
 /// All rights reserved
 /// </summary>
 public abstract class DbHelperSQL
 {
 //数据库连接字符串(web.config来配置)
 //public static string connectionString = ConfigurationManager.AppSettings["ConnectionString"];
 public static string connectionString = LTP.Common.DEncrypt.DESEncrypt.Decrypt(LTP.Common.ConfigHelper.GetConfigString("ConnectionString"));
 public DbHelperSQL()
 {
 }

#region 公用方法

public static int GetMaxID(string FieldName, string TableName)
        {
            string strsql = "select max(" + FieldName + ")+1 from " + TableName;
            object obj = DbHelperSQL.GetSingle(strsql);
            if (obj == null)
            {
                return 1;
            }
            else
            {
                return int.Parse(obj.ToString());
            }
        }
        public static bool Exists(string strSql)
        {
            object obj = DbHelperSQL.GetSingle(strSql);
            int cmdresult;
            if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
            {
                cmdresult = 0;
            }
            else
            {
                cmdresult = int.Parse(obj.ToString());
            }
            if (cmdresult == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        public static bool Exists(string strSql, params SqlParameter[] cmdParms)
        {
            object obj = DbHelperSQL.GetSingle(strSql, cmdParms);
            int cmdresult;
            if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
            {
                cmdresult = 0;
            }
            else
            {
                cmdresult = int.Parse(obj.ToString());
            }
            if (cmdresult == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        #endregion

#region 执行简单SQL语句

/// <summary>
 /// 执行SQL语句，返回影响的记录数
 /// </summary>
 /// <param name="SQLString">SQL语句</param>
 /// <returns>影响的记录数</returns>
 public static int ExecuteSql(string SQLString)
 {
 using (SqlConnection connection = new SqlConnection(connectionString))
 {
 using (SqlCommand cmd = new SqlCommand(SQLString, connection))
 {
 try
 {
 connection.Open();
 int rows = cmd.ExecuteNonQuery();
 return rows;
 }
 catch (System.Data.SqlClient.SqlException E)
 {
 connection.Close();
 throw new Exception(E.Message);
 }
 }
 }
 }

/// <summary>
 /// 执行SQL语句，设置命令的执行等待时间
 /// </summary>
 /// <param name="SQLString"></param>
 /// <param name="Times"></param>
 /// <returns></returns>
 public static int ExecuteSqlByTime(string SQLString, int Times)
 {
 using (SqlConnection connection = new SqlConnection(connectionString))
 {
 using (SqlCommand cmd = new SqlCommand(SQLString, connection))
 {
 try
 {
 connection.Open();
 cmd.CommandTimeout = Times;
 int rows = cmd.ExecuteNonQuery();
 return rows;
 }
 catch (System.Data.SqlClient.SqlException E)
 {
 connection.Close();
 throw new Exception(E.Message);
 }
 }
 }
 }

/// <summary>
 /// 执行多条SQL语句，实现数据库事务。
 /// </summary>
 /// <param name="SQLStringList">多条SQL语句</param>
 public static void ExecuteSqlTran(ArrayList SQLStringList)
 {
 using (SqlConnection conn = new SqlConnection(connectionString))
 {
 conn.Open();
 SqlCommand cmd = new SqlCommand();
 cmd.Connection = conn;
 SqlTransaction tx = conn.BeginTransaction();
 cmd.Transaction = tx;
 try
 {
 for (int n = 0; n < SQLStringList.Count; n++)
 {
 string strsql = SQLStringList[n].ToString();
 if (strsql.Trim().Length > 1)
 {
 cmd.CommandText = strsql;
 cmd.ExecuteNonQuery();
 }
 }
 tx.Commit();
 }
 catch (System.Data.SqlClient.SqlException E)
 {
 tx.Rollback();
 throw new Exception(E.Message);
 }
 }
 }
 /// <summary>
 /// 执行带一个存储过程参数的的SQL语句。
 /// </summary>
 /// <param name="SQLString">SQL语句</param>
 /// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param>
 /// <returns>影响的记录数</returns>
 public static int ExecuteSql(string SQLString, string content)
 {
 using (SqlConnection connection = new SqlConnection(connectionString))
 {
 SqlCommand cmd = new SqlCommand(SQLString, connection);
 System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter("@content", SqlDbType.NText);
 myParameter.Value = content;
 cmd.Parameters.Add(myParameter);
 try
 {
 connection.Open();
 int rows = cmd.ExecuteNonQuery();
 return rows;
 }
 catch (System.Data.SqlClient.SqlException E)
 {
 throw new Exception(E.Message);
 }
 finally
 {
 cmd.Dispose();
 connection.Close();
 }
 }
 }
 /// <summary>
 /// 执行带一个存储过程参数的的SQL语句。
 /// </summary>
 /// <param name="SQLString">SQL语句</param>
 /// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param>
 /// <returns>影响的记录数</returns>
 public static object ExecuteSqlGet(string SQLString, string content)
 {
 using (SqlConnection connection = new SqlConnection(connectionString))
 {
 SqlCommand cmd = new SqlCommand(SQLString, connection);
 System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter("@content", SqlDbType.NText);
 myParameter.Value = content;
 cmd.Parameters.Add(myParameter);
 try
 {
 connection.Open();
 object obj = cmd.ExecuteScalar();
 if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
 {
 return null;
 }
 else
 {
 return obj;
 }
 }
 catch (System.Data.SqlClient.SqlException E)
 {
 throw new Exception(E.Message);
 }
 finally
 {
 cmd.Dispose();
 connection.Close();
 }
 }
 }
 /// <summary>
 /// 向数据库里插入图像格式的字段(和上面情况类似的另一种实例)
 /// </summary>
 /// <param name="strSQL">SQL语句</param>
 /// <param name="fs">图像字节,数据库的字段类型为image的情况</param>
 /// <returns>影响的记录数</returns>
 public static int ExecuteSqlInsertImg(string strSQL, byte[] fs)
 {
 using (SqlConnection connection = new SqlConnection(connectionString))
 {
 SqlCommand cmd = new SqlCommand(strSQL, connection);
 System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter("@fs", SqlDbType.Image);
 myParameter.Value = fs;
 cmd.Parameters.Add(myParameter);
 try
 {
 connection.Open();
 int rows = cmd.ExecuteNonQuery();
 return rows;
 }
 catch (System.Data.SqlClient.SqlException E)
 {
 throw new Exception(E.Message);
 }
 finally
 {
 cmd.Dispose();
 connection.Close();
 }
 }
 }

/// <summary>
 /// 执行一条计算查询结果语句，返回查询结果（object）。
 /// </summary>
 /// <param name="SQLString">计算查询结果语句</param>
 /// <returns>查询结果（object）</returns>
 public static object GetSingle(string SQLString)
 {
 using (SqlConnection connection = new SqlConnection(connectionString))
 {
 using (SqlCommand cmd = new SqlCommand(SQLString, connection))
 {
 try
 {
 connection.Open();
 object obj = cmd.ExecuteScalar();
 if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
 {
 return null;
 }
 else
 {
 return obj;
 }
 }
 catch (System.Data.SqlClient.SqlException e)
 {
 connection.Close();
 throw new Exception(e.Message);
 }
 }
 }
 }

/// <summary>
 /// 执行查询语句，返回SqlDataReader(使用该方法切记要手工关闭SqlDataReader和连接)
 /// </summary>
 /// <param name="strSQL">查询语句</param>
 /// <returns>SqlDataReader</returns>
 public static SqlDataReader ExecuteReader(string strSQL)
 {
 SqlConnection connection = new SqlConnection(connectionString);
 SqlCommand cmd = new SqlCommand(strSQL, connection);
 try
 {
 connection.Open();
 SqlDataReader myReader = cmd.ExecuteReader();
 return myReader;
 }
 catch (System.Data.SqlClient.SqlException e)
 {
 throw new Exception(e.Message);
 }
 //finally //不能在此关闭，否则，返回的对象将无法使用
 //{
 // cmd.Dispose();
 // connection.Close();
 //}

}
 /// <summary>
 /// 执行查询语句，返回DataSet
 /// </summary>
 /// <param name="SQLString">查询语句</param>
 /// <returns>DataSet</returns>
 public static DataSet Query(string SQLString)
 {

 using (SqlConnection connection = new SqlConnection(connectionString))
 {
 DataSet ds = new DataSet();
 try
 {
 connection.Open();
 SqlDataAdapter command = new SqlDataAdapter(SQLString, connection);
 command.Fill(ds, "ds");
 }
 catch (System.Data.SqlClient.SqlException ex)
 {
 throw new Exception(ex.Message);
 }
 return ds;
 }
 }
 /// <summary>
 /// 执行查询语句，返回DataSet,设置命令的执行等待时间
 /// </summary>
 /// <param name="SQLString"></param>
 /// <param name="Times"></param>
 /// <returns></returns>
 public static DataSet Query(string SQLString, int Times)
 {
 using (SqlConnection connection = new SqlConnection(connectionString))
 {
 DataSet ds = new DataSet();
 try
 {
 connection.Open();
 SqlDataAdapter command = new SqlDataAdapter(SQLString, connection);
 command.SelectCommand.CommandTimeout = Times;
 command.Fill(ds, "ds");
 }
 catch (System.Data.SqlClient.SqlException ex)
 {
 throw new Exception(ex.Message);
 }
 return ds;
 }
 }

#endregion

#region 执行带参数的SQL语句

/// <summary>
 /// 执行SQL语句，返回影响的记录数
 /// </summary>
 /// <param name="SQLString">SQL语句</param>
 /// <returns>影响的记录数</returns>
 public static int ExecuteSql(string SQLString, params SqlParameter[] cmdParms)
 {
 using (SqlConnection connection = new SqlConnection(connectionString))
 {
 using (SqlCommand cmd = new SqlCommand())
 {
 try
 {
 PrepareCommand(cmd, connection, null, SQLString, cmdParms);
 int rows = cmd.ExecuteNonQuery();
 cmd.Parameters.Clear();
 return rows;
 }
 catch (System.Data.SqlClient.SqlException E)
 {
 throw new Exception(E.Message);
 }
 }
 }
 }

/// <summary>
 /// 执行多条SQL语句，实现数据库事务。
 /// </summary>
 /// <param name="SQLStringList">SQL语句的哈希表（key为sql语句，value是该语句的SqlParameter[]）</param>
 public static void ExecuteSqlTran(Hashtable SQLStringList)
 {
 using (SqlConnection conn = new SqlConnection(connectionString))
 {
 conn.Open();
 using (SqlTransaction trans = conn.BeginTransaction())
 {
 SqlCommand cmd = new SqlCommand();
 try
 {
 //循环
 foreach (DictionaryEntry myDE in SQLStringList)
 {
 string cmdText = myDE.Key.ToString();
 SqlParameter[] cmdParms = (SqlParameter[])myDE.Value;
 PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
 int val = cmd.ExecuteNonQuery();
 cmd.Parameters.Clear();

trans.Commit();
                        }
                    }
                    catch
                    {
                        trans.Rollback();
                        throw;
                    }
                }
            }
        }

/// <summary>
 /// 执行一条计算查询结果语句，返回查询结果（object）。
 /// </summary>
 /// <param name="SQLString">计算查询结果语句</param>
 /// <returns>查询结果（object）</returns>
 public static object GetSingle(string SQLString, params SqlParameter[] cmdParms)
 {
 using (SqlConnection connection = new SqlConnection(connectionString))
 {
 using (SqlCommand cmd = new SqlCommand())
 {
 try
 {
 PrepareCommand(cmd, connection, null, SQLString, cmdParms);
 object obj = cmd.ExecuteScalar();
 cmd.Parameters.Clear();
 if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
 {
 return null;
 }
 else
 {
 return obj;
 }
 }
 catch (System.Data.SqlClient.SqlException e)
 {
 throw new Exception(e.Message);
 }
 }
 }
 }

/// <summary>
 /// 执行查询语句，返回SqlDataReader (使用该方法切记要手工关闭SqlDataReader和连接)
 /// </summary>
 /// <param name="strSQL">查询语句</param>
 /// <returns>SqlDataReader</returns>
 public static SqlDataReader ExecuteReader(string SQLString, params SqlParameter[] cmdParms)
 {
 SqlConnection connection = new SqlConnection(connectionString);
 SqlCommand cmd = new SqlCommand();
 try
 {
 PrepareCommand(cmd, connection, null, SQLString, cmdParms);
 SqlDataReader myReader = cmd.ExecuteReader();
 cmd.Parameters.Clear();
 return myReader;
 }
 catch (System.Data.SqlClient.SqlException e)
 {
 throw new Exception(e.Message);
 }
 //finally //不能在此关闭，否则，返回的对象将无法使用
 //{
 // cmd.Dispose();
 // connection.Close();
 //}

}

/// <summary>
 /// 执行查询语句，返回DataSet
 /// </summary>
 /// <param name="SQLString">查询语句</param>
 /// <returns>DataSet</returns>
 public static DataSet Query(string SQLString, params SqlParameter[] cmdParms)
 {
 using (SqlConnection connection = new SqlConnection(connectionString))
 {
 SqlCommand cmd = new SqlCommand();
 PrepareCommand(cmd, connection, null, SQLString, cmdParms);
 using (SqlDataAdapter da = new SqlDataAdapter(cmd))
 {
 DataSet ds = new DataSet();
 try
 {
 da.Fill(ds, "ds");
 cmd.Parameters.Clear();
 }
 catch (System.Data.SqlClient.SqlException ex)
 {
 throw new Exception(ex.Message);
 }
 return ds;
 }
 }
 }

        private static void PrepareCommand(SqlCommand cmd, SqlConnection conn, SqlTransaction trans, string cmdText, SqlParameter[] cmdParms)
        {
            if (conn.State != ConnectionState.Open)
                conn.Open();
            cmd.Connection = conn;
            cmd.CommandText = cmdText;
            if (trans != null)
                cmd.Transaction = trans;
            cmd.CommandType = CommandType.Text;//cmdType;
            if (cmdParms != null)
            {

                foreach (SqlParameter parameter in cmdParms)
                {
                    if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) &&
                        (parameter.Value == null))
                    {
                        parameter.Value = DBNull.Value;
                    }
                    cmd.Parameters.Add(parameter);
                }
            }
        }

#endregion

#region 存储过程操作

/// <summary>
 /// 执行存储过程 (使用该方法切记要手工关闭SqlDataReader和连接)
 /// </summary>
 /// <param name="storedProcName">存储过程名</param>
 /// <param name="parameters">存储过程参数</param>
 /// <returns>SqlDataReader</returns>
 public static SqlDataReader RunProcedure(string storedProcName, IDataParameter[] parameters)
 {
 SqlConnection connection = new SqlConnection(connectionString);
 SqlDataReader returnReader;
 connection.Open();
 SqlCommand command = BuildQueryCommand(connection, storedProcName, parameters);
 command.CommandType = CommandType.StoredProcedure;
 returnReader = command.ExecuteReader();
 //Connection.Close(); 不能在此关闭，否则，返回的对象将无法使用
 return returnReader;

}

/// <summary>
 /// 执行存储过程
 /// </summary>
 /// <param name="storedProcName">存储过程名</param>
 /// <param name="parameters">存储过程参数</param>
 /// <param name="tableName">DataSet结果中的表名</param>
 /// <returns>DataSet</returns>
 public static DataSet RunProcedure(string storedProcName, IDataParameter[] parameters, string tableName)
 {
 using (SqlConnection connection = new SqlConnection(connectionString))
 {
 DataSet dataSet = new DataSet();
 connection.Open();
 SqlDataAdapter sqlDA = new SqlDataAdapter();
 sqlDA.SelectCommand = BuildQueryCommand(connection, storedProcName, parameters);
 sqlDA.Fill(dataSet, tableName);
 connection.Close();
 return dataSet;
 }
 }
 public static DataSet RunProcedure(string storedProcName, IDataParameter[] parameters, string tableName, int Times)
 {
 using (SqlConnection connection = new SqlConnection(connectionString))
 {
 DataSet dataSet = new DataSet();
 connection.Open();
 SqlDataAdapter sqlDA = new SqlDataAdapter();
 sqlDA.SelectCommand = BuildQueryCommand(connection, storedProcName, parameters);
 sqlDA.SelectCommand.CommandTimeout = Times;
 sqlDA.Fill(dataSet, tableName);
 connection.Close();
 return dataSet;
 }
 }

/// <summary>
 /// 构建 SqlCommand 对象(用来返回一个结果集，而不是一个整数值)
 /// </summary>
 /// <param name="connection">数据库连接</param>
 /// <param name="storedProcName">存储过程名</param>
 /// <param name="parameters">存储过程参数</param>
 /// <returns>SqlCommand</returns>
 private static SqlCommand BuildQueryCommand(SqlConnection connection, string storedProcName, IDataParameter[] parameters)
 {
 SqlCommand command = new SqlCommand(storedProcName, connection);
 command.CommandType = CommandType.StoredProcedure;
 foreach (SqlParameter parameter in parameters)
 {
 if (parameter != null)
 {
 // 检查未分配值的输出参数,将其分配以DBNull.Value.
 if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) &&
 (parameter.Value == null))
 {
 parameter.Value = DBNull.Value;
 }
 command.Parameters.Add(parameter);
 }
 }

return command;
}

/// <summary>
 /// 执行存储过程，返回影响的行数
 /// </summary>
 /// <param name="storedProcName">存储过程名</param>
 /// <param name="parameters">存储过程参数</param>
 /// <param name="rowsAffected">影响的行数</param>
 /// <returns></returns>
 public static int RunProcedure(string storedProcName, IDataParameter[] parameters, out int rowsAffected)
 {
 using (SqlConnection connection = new SqlConnection(connectionString))
 {
 int result;
 connection.Open();
 SqlCommand command = BuildIntCommand(connection, storedProcName, parameters);
 rowsAffected = command.ExecuteNonQuery();
 result = (int)command.Parameters["ReturnValue"].Value;
 //Connection.Close();
 return result;
 }
 }

/// <summary>
 /// 创建 SqlCommand 对象实例(用来返回一个整数值)
 /// </summary>
 /// <param name="storedProcName">存储过程名</param>
 /// <param name="parameters">存储过程参数</param>
 /// <returns>SqlCommand 对象实例</returns>
 private static SqlCommand BuildIntCommand(SqlConnection connection, string storedProcName, IDataParameter[] parameters)
 {
 SqlCommand command = BuildQueryCommand(connection, storedProcName, parameters);
 command.Parameters.Add(new SqlParameter("ReturnValue",
 SqlDbType.Int, 4, ParameterDirection.ReturnValue,
 false, 0, 0, string.Empty, DataRowVersion.Default, null));
 return command;
 }
 #endregion

}

本文链接

asp.net的Login.aspx.cs出错解决办法

2010-06-02T04:58:00Z

在做CRM的时候，帐户登录界面的文件叫Login.aspx，后台代码为Login.aspx.cs

在VS.NET 2005下测试通过，可发布后，在IIS下运行，则有如下错误提示。

===============================================================================

Description: An error occurred during the compilation of a resource required to service this request. Please review the following specific error details and modify your source code appropriately.

Compiler Error Message: CS0030: Cannot convert type 'ASP.login_aspx' to 'System.Web.UI.WebControls.Login'

Source Error:

Line 114:        public login_aspx() {
Line 115:            string[] dependencies;
Line 116:            ((Login)(this)).AppRelativeVirtualPath = "~/Login.aspx";
Line 117:            if ((global::ASP.login_aspx.@__initialized == false)) {
Line 118:                global::ASP.login_aspx.@__stringResource = this.ReadStringResource();

Source File: c:\WINNT\Microsoft.NET\Framework\v2.0.50727\Temporary ASP.NET Files\root\21f002dd\13ab9d48\App_Web_login.aspx.cdcab7d2.vqjr2cxo.0.cs Line: 116

Compiler Warning Messages:

Server Error in '/' Application.

Compilation Error

Show Detailed Compiler Output:

Show Complete Compilation Source:

Version Information: Microsoft .NET Framework Version:2.0.50727.42; ASP.NET Version:2.0.50727.42

===========================================================================

这是因为.NET Framework 2.0 版中新增Login类.而我们又增加Login.aspx，就会有冲突。

解决法办：

把原来这个

public partial class Login : System.Web.UI.Page
{

...

}

改为别的，如

public partial class AccountLogin : System.Web.UI.Page
{

...

}

aspx文件里的也要改动，如下：

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Login.aspx.cs" Inherits="Login" Culture="auto" UICulture="auto" %>

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Login.aspx.cs" Inherits="AccountLogin" Culture="auto" UICulture="auto" %>

再试试就没问题了。

本文链接

把sql server所有表的所有者改为dbo

2010-06-01T08:15:00Z

--执行这个语句,就可以把当前库的所有表的所有者改为dbo
exec sp_msforeachtable 'sp_changeobjectowner ''?'', ''dbo'''

--如果是要用户表/存储过程/视图/触发器/自定义函数一齐改,则用游标(不要理会错误提示)
declare tb cursor local for
select 'sp_changeobjectowner ''['+replace(user_name(uid),']',']]')+'].['+replace(name,']',']]')+']'',''dbo'''
from sysobjects
where xtype in('U','V','P','TR','FN','IF','TF') and status>=0
open tb
declare @s nvarchar(4000)
fetch tb into @s
while @@fetch_status=0
begin
exec(@s)
fetch tb into @s
end
close tb
deallocate tb

以SA登陆查询分析器，选中你要的数据库
执行存储过程
执行exec Changename ‘原所有者','dbo'
或exec Changename ‘dbo,'数据库所有者' 网管网ofAdmin.Com

修改MS SQL表用户属性的命令 IT技术网Www.ofAdmin.Com

可以用exec sp_changeobjectowner ‘dataname.数据表','dbo'　把表或存储过程中的所有者都改成dbo 华夏网管Www.ofAdmin.Com

本文链接