• TRUNCATE
• DELETE

The two commands achieve the same result; however, each of the commands acts a little bit different. Each of the two commands have advantages, limitations, and consequences, which have to be considered when deciding which method to use.

In this post we will concentrate in one aspect of these commands usage – the ability to rollback each operation.

DELETE statements delete rows one at a time, logging each row in the transaction log and maintaining the log sequence number (LSN) information.
Even though it will consumes more database resources, it comes in handy as these transactions can be rolled back if necessary by using the log files, when the recovery model of the database is set to full.

But what happens when you issue the TRUNCATE command?

The TRUNCATE statement is much faster statement than the DELETE command.
It deletes all records in a table by deallocating the data pages used to store the table’s data. This operation has a limited logging in the transaction log (only the page deallocations are recorded in the transaction log). In addition fewer locks are acquired with this statement in compare to the DELETE statement.
As a result of the above it is commonly believed that records removed by the TRUNCATE statement cannot be restored – rolled back.

It is true in most cases, however DELETE and TRUNCATE can both be rolled back when they are executed inside a ‘BEGIN TRANSACTION’ block and the current session has not yet ended.
In other words, when the TRUNCATE statement has not been committed yet, it can be rolled back

The following code demonstrates a scenario when a TRUNCATE can be rolled back for that particular session.

--Creating a testTable for the demonstration
CREATE TABLE TESTTABLE (ID INT)

--Inserting rows into the testTable.
INSERT INTO TESTTABLE
SELECT TOP 1000 OBJECT_ID FROM SYS.OBJECTS
BEGIN TRAN
   --Truncating the table
   TRUNCATE TABLE TESTTABLE
   --No rows will return
   SELECT * FROM TESTTABLE
ROLLBACK

--The original rows from testTable will return
SELECT * FROM TESTTABLE

--Dropping the testTable.
DROP TABLE TESTTABLE

To summarize,
DELETE can always be rolled back-

• When the recovery model of the database is set to SIMPLE, the statement can be rolled back – when the statement is executed inside a ‘BEGIN TRANSACTION’ block.
• When the recovery model of the database is set to FULL, the statement can also be recovered from the log files.

TRUNCATE can or cannot be rolled back, depends if it is executed from within a ‘BEGIN TRANSACTION’ block.

(I have written it for SQL 2005 but I guess it runs both on 2000 and 2008 versions)

declare @startupDate datetime
,		@days bigint
,		@hours bigint
,		@minutes bigint
,		@seconds bigint

select	@startupDate = CrDate
,		@seconds = DateDiff(second, CrDate, getdate())
,		@days = @seconds/60/60/24
,		@seconds = @seconds - (@days*60*60*24)
,		@hours = @seconds/60/60
,		@seconds = @seconds - (@hours*60*60)
,		@minutes = @seconds/60
,		@seconds = @seconds - (@minutes*60)

from	sysdatabases (nolock)
where	[name] = 'TempDb'

select	@startupDate startup_time
,		cast(@days as varchar) + ' days ' +
		case when @hours < 10 then '0' else '' end + cast(@hours as varchar) + ':' +
		case when @minutes < 10 then '0' else '' end + cast(@minutes as varchar) + ':' +
		case when @seconds < 10 then '0' else '' end + cast(@seconds as varchar)
		as online_duration