Wednesday, June 23, 2004

Delete Vs Truncate Statement

• Delete table is a logged operation, so the deletion of each row gets logged in the transaction log, which makes it slow.

• Truncate table also deletes all the rows in a table, but it won’t log the deletion of each row, instead it logs the de-allocation of the data pages of the table, which makes it faster. Truncate table can be rolled back if it happens within a Transaction.

• Truncate table is functionally identical to delete statement with no “where clause” both remove all rows in the table. But truncate table is faster and uses fewer system and transaction log resources than delete.

• Truncate table removes all rows from a table, but the table structure and its columns, constraints, indexes etc., remains as it is.

• In truncate table the counter used by an identity column for new rows is reset to the seed for the column.

• If you want to retain the identity counter, use delete statement instead.

• If you want to remove table definition and its data, use the drop table statement.

• You cannot use truncate table on a table referenced by a foreign key constraint; instead, use delete statement without a where clause. Because truncate table is not logged, it cannot activate a trigger.

• Truncate table may not be used on tables participating in an indexed view.

Friday, June 11, 2004

Comparing tables ...

There are times when we would like to check whether the content in two tables are same or not. As of now there isn’t any built-in function in SQL Server to do the same (who knows they might come up with something in Yukon!). At present we need to manually compare the contents of tables to find out whether they are matching or not. Won’t it be nice to have a stored procedure which would do the job for us? Read on …

Setting the environment

First let us create a test table and populate it with some test data.

Create table Student
[name] varchar(50),
[age] int

Insert into Student ([name],age) Values ('Vadivel',27)
Insert into Student ([name],age) Values ('Ash',30)

Let us now create a copy of this table with a new name:

Select * into StudentCopy from Student

Now both the table ‘Student’ and ‘StudentCopy’ has the same structure and values.


The stored procedure helps in comparing two tables:

Create Procedure usp_CompareTable
@FirstTableName varchar(128),
@SecondTableName varchar(128)

-- Variables to hold the dynamic query
Declare @TotalRowsFirstTable nchar(100),
@TotalRowsSecondTable nchar(100),
@TotalRowsUnion nchar(100)

-- Variables to hold the row count of different tables
Declare @RowCountFirstTable int,
@RowCountSecondTable int,
@RowCountUnion int

-- Variable which would hold the result of the comparison. 0 = Mismatch, 1 = Match
Declare @result bit
SET @TotalRowsFirstTable = 'Select @RowCountFirstTable=count(*) From ' + @FirstTableName

@TotalRowsFirstTable OUTPUT,
N'@RowCountFirstTable Int OUTPUT',
@RowCountFirstTable = @RowCountFirstTable OUTPUT

SET @TotalRowsSecondTable = 'Select @RowCountSecondTable=count(*) From ' + @SecondTableName

@TotalRowsSecondTable OUTPUT,
N'@RowCountSecondTable Int OUTPUT',
@RowCountSecondTable=@RowCountSecondTable OUTPUT

SET @TotalRowsUnion = 'Select @RowCountUnion=count(*) From (Select * From ' + @FirstTableName + ' Union Select * From ' + @SecondTableName + ') as AliasSecond '

@TotalRowsUnion OUTPUT,
N'@RowCountUnion INT OUTPUT',
@RowCountUnion=@RowCountUnion OUTPUT

If (@RowCountFirstTable = @RowCountSecondTable) and (@RowCountSecondTable = @RowCountUnion)

Set @result = 1
Print 'Success: Tables are matching'
Set @result = 0
Print 'Error: Tables are not matching'

To Test

Execute usp_CompareTable 'student', 'studentcopy'

Monday, June 07, 2004

Registry manipulation from SQL

Registry Manupulation from SQL Server is pretty easy. There are 4 extended stored procedure in SQL Server 2000 for the purpose of manupulating the server registry. They are:

1) xp_regwrite
2) xp_regread
3) xp_regdeletekey
4) xp_regdeletevalue

Let us see each one of them in detail!

About xp_regwrite

This extended stored procedure helps us to create data item in the (server’s) registry and we could also create a new key.


We must specify the root key with the @rootkey parameter and an individual key with the @key parameter. Please note that if the key doesn’t exist (without any warnnig) it would be created in the registry. The @value_name parameter designates the data item and the @type the type of the data item. Valid data item types include REG_SZ and REG_DWORD. The last parameter is the @value parameter, which assigns a value to the data item.

Let us now see an example which would add a new key called "TestKey", and a new data item under it called TestKeyValue:

Use Master

@type='REG_SZ', @value='Test'

About xp_regread

This extended stored procedure reads an individual registry key (OR) to read a data item in the key. The @rootkey parameter is the root key in the registry, and the @key parameter is the individual key.

Usage: We must specify the registry key’s root and key as shown below:

Use Master

As we are using @rootkey and @key alone it would test the existence of the key only. i.e., if the key exist it would return 1, if not it would return 0. To fetch the value stored inside the key (which we did it using xp_regwrite) use the below code snippet:

Use Master

Exec xp_regread

Assume that you have installed SQL Server in your machine and unfortunately you lost the CD Key. Won't it be useful if there is a means by which you could retrieve the CD Key used while installing? Obviously Yes right :) Execute the below script to fetch the CD KEY.

USE master

EXEC xp_regread
@rootkey = 'HKEY_LOCAL_MACHINE',
@key = 'SOFTWARE\Microsoft\Microsoft SQL Server\80\registration',
@value_name = 'CD_KEY'

About xp_regdeletekey

As the name say, this procedure allows us to delete a key from your registry. For your information this won't warn us before the procedure deletes the entire key.

Usage: Use the @rootkey parameter to specify the root registry key and @key parameter to tell which key you want to delete:

Use Master


About xp_regdeletevalue

You can also delete individual data items inside a registry key by using the xp_regdeletevalue procedure. The procedure uses the same parameters as the xp_regdeletekey procedure, but has an added @value_name parameter, which is the data item name:

Use Master


Points to Note:

1. You can replace the first 3 lines in the code snippet with master..

2. After running the scripts for testing go to START >> RUN >> And type regedit. This would open up the registry editor. Navigate to HKEY_LOCAL_MACHINE\SOFTWARE to find the rest we discussed above.

3. Once done run the below scripts to clear the entries we added to the registry

---Run this to Delete "TestKey" entry

---Run this to Delete "thinkingMS" entry

---Run this to Delete "RegistryExample" entry

---Run this to Delete "Vadivel" entry