“NORMALIZATION IS A PROCESS BY WHICH WE LOOK FORWARD OVER TWO FACTS : 1. REDUNDANT DATA ELIMINATION. 2.DATA DEPENDENCIES WILL MAKE SENSE. WHICH HELPS TO REDUCES THE DATABASE SPACE CONSUMPTION.”

Their are some series of guidelines are developed by the communities of database, known as first, second, third and fourth some how fifth normalization forms. But i am going to discuss only three of them :

1. First Normal Form :
Their are only two root rules
1.1 Their should be no duplicate columns.
1.2 For each group of related data their should be separate tables, in which identify each row uniquely by a column or set of column.
Example : This is EmployeeMaster as

So apply the first normal form, Emp City will come in one column and Emp Name will break in two fiels:

Now the given record set is in the first normal form.

2. Second Normal Form :
This form state that after fulfilling all the condition of first normal form, their are two more conditions
2.1 Place those data in separate tables which are not directly related to the primary key of that table.
2.2 Create relationship between these tables using new table key (Foreign Key).

And City Master become in scene

That is now takes our database to a second normal form.

3. Third Normal Form :

So now meet all the fundamentals for IInd normal form and then

3.1 Remove all the non key fields which are depend on other non key fields.
In our table “Total Salary” is a kind of field. So :

So the “Total Salary” field is removed which can be easily get by “Basic Salary” + “Var Salary”.
Ok Now our Database is normalized at the stage of Third normal form.

These are most applicable normal forms of database. I am not giving the idea about fourth and fifth normal forms. I apologies for that. But they have been rarely used in database normalization.

Now Happy reading. Cheers.
Neeraj Tripathi

………. Still Working. Apologies for inconvenience.

Kind Of UDF’s :
1. Scaler Functions – Return a single data value , defined in return clause.
Usable Data Types: Including bigint and sql_variant all scaler data type can be used.
Unusable Data Types : Timestamp , table , cursor and User Defind Data Type they are not supported.
Return support Data Types : Excluding text, ntext, Table, Cursor, timestamp and image.
1. Table Valued Functions – These user defined functions return tables data type.
1.1 Inline Table Valued Function having no table body, is the result set of a single select statement.
* The RETURNS clause contains only the keyword table.
* You do not have to define the format of a return variable because it is set by the format of the result set of the SELECT statement in the RETURN clause.
* There is no function_body delimited by BEGIN and END.
* The RETURN clause contains a single SELECT statement in parentheses. The result set of the SELECT statement forms the table returned by the function.
* The table-valued function accepts only constants or @local_variable arguments.
Example :
CREATE FUNCTION udfUserNameOfARegion
( @RegionIDPara integer(25) )
RETURNS table
AS
RETURN (
SELECT CustomerID, CompanyName FROM dbo.UserMaster WHERE RegionID = @RegionIDPara
)
GO

Now compile the the function and then try to access the result by function…
SELECT * FROM udfUserNameOfARegion(’10015′)
well you may get the desired result.

1.2 Multi-statement table-valued function, the function body, defined in a BEGIN…END block, contains the some TRANSACT-SQL statements that build and insert rows into the temp table and lastly that will be returned.
* UDF that return a table may be a powerful alternatives to views.
* They can be used where table or view expressions are allowed in Transact-SQL queries,While views are limited to a single SELECT statement and more user-defined functions can contain additional statements that allow more powerful logic than is possible in views.
* Also can replace stored procedures that return a single result set. Because the table returned by a user-defined function can be referenced in the FROM clause of a Transact-SQL statement, but stored procedures that return result sets cannot.
Example : SELECT * FROM tab_1 AS T1 INNER JOIN dbo.udf_temp(‘para’) AS T2 ON T1.fieldOne = T2.fieldOne.
* The RETURNS clause defines a local return variable name for the table returned by the function. The RETURNS clause also defines the format of the table. The scope of the local return variable name is local within the function.
* The Transact-SQL statements in the function body build and insert rows into the return variable defined by the RETURNS clause.
* When a RETURN statement is executed, the rows inserted into the variable are returned as the tabular output of the function.

CREATE FUNCTION udfReturnUserName( @TotalSalary money )
RETURNS @UserHaveHighPkgTab TABLE
(
UserID int,
UserName nvarchar(50),
UserCreationDate datetime,
TotalSalary money
)
AS
BEGIN
INSERT @UserHaveHighPkgTab
SELECT S.UserID, S.UserName, O.UserCreationDate , O.TotalSalary
FROM UserMaster AS UM INNER JOIN UserDetails AS UD
ON UM.UserID = UD.UserID
WHERE UD.Total > @TotalSalary
RETURN
END

• Attempt to avoid the HAVING clause possibly. The HAVING clause is used to restrict the output returned by the GROUP BY clause. When we use GROUP BY with the HAVING clause, the GROUP BY clause divides the rows into sets of grouped rows and aggregates their values, and then the HAVING clause eliminates undesired aggregated groups.

• If you need to return the total table’s row count, you can use alternative way instead of SELECT COUNT(*) statement. Because SELECT COUNT(*) statement make a full table scan to return the total table’s row count, it can take very many time for the large table. You can use sysindexes system table, to determine the total row count. There is ROWS column in the sysindexes table. This column contains the total
row count for each table in your database. So, you can use

SELECT rows FROM sysindexes WHERE id = OBJECT_ID(‘table_name’) AND indid < 2

• Always SET NOCOUNT ON statement into your stored procedures to stop the message indicating the number of rows affected by a T-SQL statement. This can reduce network traffic, because your client will not receive the message indicating the number of rows affected by a T-SQL statement.

• We could prefer to use views and stored procedures instead of heavy-duty queries. This can reduce network traffic, because your client will send to server only stored procedure or view name (perhaps with some parameters) instead of large heavy-duty queries text. This can be used to facilitate permission management also, because you can restrict user access to table columns they should not see.

• Try to use constraints instead of triggers, whenever possible. Constraints are much more efficient than triggers and can boost performance.

• Always use Table Variables instead of temporary tables. Table variables require less locking and logging resources than temporary tables, so table variables should be used whenever possible. The table variables are available in SQL Server 2000 only.

• Try to use UNION ALL statement instead of UNION as possible. Because UNION ALL statement does not look for duplicate rows, whether or not they exist, So UNION ALL is fast.

• Try to avoid using SQL Server cursors, whenever possible. SQL Server cursors can result in some performance degradation in comparison with select statements.

• Use the select statements with TOP keyword or the SET ROWCOUNT statement, if you need to return only the first n rows. This can improve performance of your queries and traffic between the server and the clients.

Few Index Optimization tips

• Keep your indexes as narrow as possible. This reduces the size of
the index and reduces the number of reads required to read the index.

• Attempt to create indexes on columns that have integer values rather than character values.

• Create surrogate integer primary key (identity for example) if your table will not have many insert operations.

• The number of indexes should not be very much Because Every index increases the time in takes to perform INSERTS, UPDATES and DELETES. Try to use maximum 3-5 indexes on one table, not more.
If you have read-only table, then the number of indexes may be increased.

• See if you want to join several tables, try to create surrogate integer keys for this purpose and create indexes on their columns.

For Surrogate key Vs. Natural Key Refer

• In case of a composite (multi-column) index, the order of the columns in the key are very important. Try to order the columns in the key as to enhance selectivity, with the most selective columns to the leftmost of the key.

• Clustered indexes are more preferable than nonclustered, if you need to select by a range of values or you need to sort results set with GROUP BY or ORDER BY.

• If your application will be performing the same query over and over on the same table, consider creating a covering index on the table.

• You can use the SQL Server Profiler Create Trace Wizard with “Identify Scans of Large Tables” trace to determine which tables in your database may need indexes. This trace will show which tables are being scanned by queries instead of using an index.

• You can use sp_MSforeachtable undocumented stored procedure to rebuild all indexes in your database.

1. Duplicate record deletion : You have a CountryMaster Table having fields as CountyName, CountryID

SET ROWCOUNT 1
DELETE CountryMaster
FROM CountryMaster a
WHERE (SELECT COUNT(*) FROM CountryMaster b WHERE b.CountryName = a.CountryName) > 1
WHILE @@rowcount > 0
DELETE CountryMaster
FROM CountryMaster a
WHERE (SELECT COUNT(*) FROM CountryMaster b WHERE b.CountryName = a.CountryName) > 1
SET ROWCOUNT 0

OR

DELETE FROM [TestNeeraj].[dbo].[CountryMaster] WHERE CountryId NOT IN
(SELECT MAX(CountryID) FROM CountryMaster GROUP BY CountryName)

NOTE : SET ROWCOUNT statement simply limits the number of records returned to the client during a single connection and This can not be used in UDF.

2. Using ROLLUP For Total And Sub Totals in fetched records : Having Table WorkOrderRouting and fields as OperationSequence , WorkOrderRouting

SELECT CASE WHEN OperationSequence IS NULL THEN 9999999 ELSE OperationSequence END SEQ, SUM(ActualResourceHrs) AS HRS FROM [WorkOrderRouting]
GROUP BY OperationSequence WITH ROLLUP ORDER BY OperationSequence

3. How to find 2nd highest salary

SELECT TOP 1 salary FROM (SELECT DISTINCT TOP 2 salary
FROM employee ORDER BY salary DESC) a ORDER BY salary

4. Select First day of month :

SELECT DATENAME(dw, DATEADD(dd, – DATEPART(dd, GETDATE()) + 1, GETDATE())) AS FirstDay

For DATEPART abbreviations
you may refer