Author: Alexandr Omelchenko

SQL Server’s error “Violation of … constraint ‘…’. Cannot insert duplicate key in object ‘…’” can appear when a user tries to insert a non-unique value into a table’s unique column such as the primary key. Look at the following syntax:

CREATE TABLE Table_1
(ID INT NOT NULL PRIMARY KEY, 
 NAME VARCHAR(10) NOT NULL, 
 AGE date);

The user created the new table Table_1, and started to fill it adding a row:

INSERT INTO Table_1 (id, name, age) VALUES (1, 'John','30');

then the next row:

INSERT INTO Table_1 (id, name, age) VALUES (1, 'John','30');

After execution of this command the following error appeared:

Msg 2627, Level 14, State 1, Line 10
Violation of PRIMARY KEY constraint 'PK__Table_1__3214EC27204DF2A8'. Cannot insert duplicate key in object 'dbo.Table_1'. The duplicate key value is (2).

This message says that the user tries to insert duplicate values into a unique column. To avoid this error just select an unique value, for example, 2:

INSERT INTO Table_1 (id, name, age) VALUES (2, 'John','30');

“Invalid filegroup ‘…’ specified.” error can appear in the case when the name of Filegroup where the new Table_1 will be stored is invalid. Look at the syntax bellow:

CREATE TABLE Table_1
(Column1 int primary key, Column2 char(8))
ON [SecondaryFilegroup];

In this case, the user tried to store the new Table_1 into SecondaryFilegroup and received the following error message from SQL Server:

Msg 1921, Level 16, State 1, Line 1
Invalid filegroup 'SecondaryFilegroup' specified.

It means that such filegroup does not exist. The user has to create such filegroup or use another existing one to store the Table_1.

The error “CREATE DATABASE failed. Some file names listed could not be created. Check related errors.” can occur when the user tries to create a database with file names specified. To understand when this error can appear and how to avoid it, let’s consider the following syntax:

CREATE DATABASE Adventureworks 
ON PRIMARY
( NAME = Adventureworks_Data,
  FILENAME = 'Adventureworks_Data.mdf',
  SIZE = 0,
  MAXSIZE = 30,
  FILEGROWTH = 10% )
LOG ON
( NAME = Adventureworks_Log,
  FILENAME = 'Adventureworks_Log.ldf',
  SIZE = 3MB,
  MAXSIZE = 20MB,
  FILEGROWTH = 3MB );
GO

In this case, the SQL Server will send the following errors:

Msg 5174, Level 16, State 1, Line 2
Each file size must be greater than or equal to 512 KB.
Msg 1802, Level 16, State 1, Line 2
CREATE DATABASE failed. Some file names listed could not be created. Check related errors.

The reason why this error appeared is that one of the file parameters is incorrect. In this case, the user set up the size of the data file to zero. Msg 5174 gives a hint that Each file size must be greater than or equal to 512 KB.

“Transaction was deadlocked” error occurs when two or more sessions are waiting to get a lock on a resource which has already locked by another session in the same blocking chain.  As a result, none of the sessions can be completed and SQL Server has to intervene to solve this problem. It gets rid of the deadlock by automatically choosing one of the sessions as a victim and kills it allowing the other session to continue. In such case, the client receives the following error message:

Transaction (Process ID) was deadlocked on lock resources with another process and has been chosen as the deadlock victim. Rerun the transaction.

and the killed session is rolled back. As a rule, the victim is the session that requires the least amount of overhead to rollback.

Why SQL Server Deadlocks Happen?

To understand how “Transaction (Process ID) was deadlocked on lock resources with another process and has been chosen as the deadlock victim. Rerun the transaction” error happens let’s consider a very simple example.

Let’s create two tables “t1” and “t2” containing only one integer column:

CREATE TABLE t1 (id int)
CREATE TABLE t2 (id int)

and fill them with some data:

INSERT INTO t1 (id) 
SELECT 1 UNION ALL
SELECT 2 UNION ALL
SELECT 3
GO
INSERT INTO t2 (id)
SELECT 1 UNION ALL
SELECT 2 UNION ALL
SELECT 3

Now, suppose we started a transaction that deletes rows with id=2 from t1:

BEGIN TRAN
DELETE FROM t1 WHERE id = 2

Then, assume that the other transaction is going to delete the same rows from both tables:

BEGIN TRAN
DELETE FROM t2 WHERE id = 2
DELETE FROM t1 WHERE id = 2

It needs to be waiting for the first transaction to complete and release table t1.

But, assume that the first transaction now deletes the same row from the second table:

DELETE FROM t2 WHERE id = 2

After executing this statement you should receive the following error message:

Transaction (Process ID) was deadlocked on lock resources with another process and has been chosen as the deadlock victim. Rerun the transaction.

It is caused by a situation when the first transaction is waiting for the second one (to release t2) while the second transaction is also waiting the first (to release t1) one in the same time.

How to Analyze Deadlock Graphs

A deadlock graph is a block of information showing what resources and sessions are involved in a deadlock. It helps to understand why the deadlock happened.

Before SQL Servers 2008, in order to capture this information you had to set up a server-side tracing or enable trace flags and then wait while the deadlock occurs. Starting from SQL Server 2008 everything is much easier. You can retrieve a deadlock graphs retrospectively from the extended events “system_health” session. To do this, go to “Management” > “Extended Events” > “Sessions” > “system_health” > “package0.event_file” and click “View Target Data…”

 

 

Thousands of events will be shown in the opened window. There you can find deadlock reports which marked as “xml_deadlock_report”. Let’s choose one we’ve just simulated

and look at its deadlock graph (in form of XML) details consisting of resources and processes sections.

Resources section displays the lists with all the resources which were involved in the deadlock:

It shows what processes were fighting over and what types of locks they were causing. It has two or more entries. Each entry has a description of the resource followed by the lists of the processes that held a lock or requested a lock on that resource. Locks in that section mainly will relate to a key, RID, a page or a table.

After the resources section let’s turn to the processes section to find out what those processes were doing.

Processes section displays the details of all the processes which were involved in the deadlock

This section contains entries about the threads involved in the deadlock and provides such crucial information like host names, login names, isolation level, times, session settings and so on. But the most valuable information is the isolation level under which each query was running and the details about statement caused the deadlock.

How to Choose a Deadlock Victim

If you can’t avoid deadlocks, there is an option to specify which process should die when a deadlock occurs. SQL Server chooses a deadlock victim based on two factors: DEADLOCK_PRIORITY set for each session and the amount of work which SQL Server has to do in order to roll back the transaction.

The DEADLOCK_PRIORITY option can be set by a user to HIGH, NORMAL, LOW or to an integer value from -10 to 10. By default, DEADLOCK_PRIORITY is set to NORMAL (0). Use the following syntax to set deadlock priority:

SET DEADLOCK_PRIORITY { LOW | NORMAL | HIGH | <numeric-priority> | @deadlock_var | @deadlock_intvar } <numeric-priority> ::= { -10 | -9 | -8 | … | 0 | … | 8 | 9 | 10 }

For example, a session with NORMAL deadlock priority will be chosen as a deadlock victim if it involved in a deadlock chain with other sessions having deadlock priority set to HIGH or integer value greater than 0. And it will survive if the other sessions have LOW deadlock priority or its integer value less than zero.

LOW is equal to -5, NORMAL is the same as o, HIGH equals to 5. In other words, run the following commands to set a deadlock priority to NORMAL:

SET DEADLOCK_PRIORITY NORMAL;
GO

or

SET DEADLOCK_PRIORITY 0; 
GO

To check the deadlock priority of the session you can use the following query:

SELECT session_id, DEADLOCK_PRIORITY FROM sys.dm_exec_sessions WHERE SESSION_ID = @@SPID

How to Avoid Deadlocks in SQL Server

As a developer, you need to design database modules in a way that minimizes risks of deadlocks. Here are some useful tips on how to do that:

Make sure the applications access all shared objects in the same order

Consider the following two applications (bad practice): 

APPLICATION 1	APPLICATION 2
1. Begin Transaction	1. Begin Transaction
2. Update Part Table	2. Update Supplier Table
3. Update Supplier Table	3. Update Part Table
4. Commit Transaction	4. Commit Transaction

These two applications may deadlock frequently. If both are about to execute step 3, they may each end up blocked by the other, because they both need access to an object that the other application locked in step 2 and was not to release it till the end of the transaction.

Please see the following correction of the above example, changing the order of the statements (good practice):

APPLICATION 1	APPLICATION 2
1. Begin Transaction	1. Begin Transaction
2. Update Supplier Table	2. Update Supplier Table
3. Update Part Table	3. Update Part Table
4. Commit Transaction	4. Commit Transaction

It is a very good idea to define some programming policy that defines the order in which database objects and resources have to be accessed by the applications (also it is a good policy to release locks in the opposite order to that in which the applications locked them).

Keep transactions short and simple

Please consider the previous example:
the applications have two statements in a transaction (bad example)

APPLICATION 1	APPLICATION 2
1. Begin Transaction	1. Begin Transaction
2. Update Supplier	2. Update Part
5. Update Part	5. Update Supplier
6. Commit Transaction	6. Commit Transaction

Please consider the following changes in the above example  (good example):

APPLICATION 1	APPLICATION 2
1. Begin Transaction	1. Begin Transaction
2. Update Supplier	2. Update Part
3. Commit Transaction	3. Commit Transaction
4. Begin Transaction	4. Begin Transaction
5. Update Part	5. Update Supplier
6. Commit Transaction	6. Commit Transaction

In this case you have everywhere one update at a time, thе transactions are very short, and there will be no deadlocks here at all.

Make sure the applications use the minimum necessary transaction isolation level.

The lower isolation level, the lower possibility of deadlocks (and the higher possibility of violation of data integrity, although).

For example, when the lowest isolation level possible (READ UNCOMMITTED) is used, there are no deadlocks at all. Although in this case you have to take special care of data integrity,
as READ UNCOMMITTED isolation level allows a transaction to read a table before another transaction finishes writing to the table (i.e. before the writing commits), and in this situation some data can be read before an update finishes, so you have to be careful about reading possibly outdated or inconsistent data.

Use “manual” lock/unlock possibilities to lock/unlock objects by yourself, not leaving it to the system, i.e. not using high level transaction isolation levels

Consider again the above two applications (bad practice):

APPLICATION 1	APPLICATION 2
1. Begin Transaction	1. Begin Transaction
2. Update Part Table	2. Update Supplier Table
3. Update Supplier Table	3. Update Part Table
4. Commit Transaction	4. Commit Transaction

Here the situation is prone to deadlocks, but if all of the ‘update’ statements are wrapped up with special lock/unlock procedures, then there will be no deadlocks.

Consider the applications changed this way (good practice).

APPLICATION 1	APPLICATION 2
Begin Transaction	Begin Transaction
‘Manual Lock’ of Part	‘Manual Lock’ of Supplier
Update Part	Update Supplier
‘Manual Release’ of Part	‘Manual Release’ of Supplier
‘Manual Lock’ of Supplier	‘Manual Lock’ of Part
Update Supplier	Update Part
‘Manual Release’ of Supplier	‘Manual Release’ of Part
Commit Transaction	Commit Transaction

To implement ‘Manual Lock’ use  sp_getapplock procedure.
For ‘Manual Release’ usesp_releaseapplock procedure.
In the example above there will be no deadlocks (and no ‘lost updates’ etc) even using the lowest transaction isolation level, as each transaction do not ask for access to another object before releasing the previous one.

In case Repeatable read or Serializable isolation levels are required, and two applications use the same database object very frequently, use UPDLOCK hint

Consider the following two transactions (bad practice):

APPLICATION 1	APPLICATION 2
1. Begin Transaction	1. Begin Transaction
2. Read Part table (S-lock #1 is set by the Read)	2. Read Part  table (S-lock #2 is set by the Read)
3. Change structure of Part table  (waiting for S-lock #2 release)	3. Change structure of Part table  (waiting for S-lock #1 release)
4. Commit Transaction	4. Commit Transaction

Here are the two transactions just checking some data up before changing them
(e.g. counting a number of records of a table before inserting a new record in it).

On step 2 both transactions apply S-lock to the same database object and then on step 3 they both wait for release of the S-locks for changing something in the structure of the object (e.g. inserting a row to the table).

Please see the changes in the two transactions (good practice):

APPLICATION 1	APPLICATION 2
1. Begin Transaction	1. Begin Transaction
2. Select Part table with UPDLOCK optimizer hint	2. Select Part  table with UPDLOCK optimizer hint
3. Access Part table	3. Access Part table
4. Commit Transaction	4. Commit Transaction

The advice is to start all relevant transactions with SELECT statement with UPDLOCK optimizer hint for making the two applications to deal with the same database object one after another in turn:

SELECT * FROM Part WITH (UPDLOCK)

Other advices on how to avoid deadlocks in SQL Server

There are also other general advices related to the matter, such as

• have normalized database design,
• use bound connections and sessions,
• reduce lock time (e.g. don’t allow users input during transactions),
• avoid cursors,
• use row versioning-based Isolation levels,
• use ROWLOCK optimizer hint,

etc.

 

To understand how to avoid “Database ‘Adventureworks’ cannot be opened. It is in the middle of a restore” error let’s consider the following example:

Assume, in the database some crucial data were deleted, and the restore operation was started

RESTORE DATABASE Adventureworks FROM DISK = 'Adventureworks_full.bak' WITH NORECOVERY, REPLACE 

Note, that even if  the full backup was restored the database still is in the NORECOVERY state and there is no way to use it. But if you try to run this database the SQL Server will send this error message:

Msg 927, Level 14, State 2, Line 3
Database 'Adventureworks' cannot be opened. It is in the middle of a restore.

Here are some ways how to avoid this error.

• The first one is to restore only full backup WITH RECOVERY option:

RESTORE DATABASE Adventureworks FROM DISK = 'Adventureworks_full.bak' WITH RECOVERY

• The other way is applicable when you need to restore several backups, such as differential and transaction log. Doing this you need to restore the last backup WITH RECOVERY option in order to restore the database to its working state.

“Database ‘Adventureworks’ does not exist. Make sure that the name is entered correctly” can occur if there is a mistake in the name of the database. Assume that there is a need to run database “Adventureworks”. The next syntax was used to issue the database:

USE Advantureworks

and the following error was received:

Msg 911, Level 16, State 1, Line 1
Database 'Advantureworks ' does not exist. Make sure that the name is entered correctly.

If the database name is read carefully, to notice the error will not take many efforts. In this case, it is necessary to change letter “a” to “e”:

USE Adventureworks

Let’s consider the error “Unknown object type ‘…’ used in a CREATE, DROP, or ALTER statement” on the following example:

There is a need to add one more column “Column4” in the table “Table_1” which located in the database “Adventureworks”. To execute this operation was used next syntax

ALTER Table_1 
ADD Column4 INT;

But column was not added and from the SQL Server was received the following message:

Msg 343, Level 15, State 1, Line 3
Unknown object type 'Table_1' used in a CREATE, DROP, or ALTER statement.

This error occurs because SQL Server does not understand what to ALTER. In this case, it is necessary just to add TABLE after ALTER

ALTER TABLE Table_1 
ADD Column4 INT;