In this post, I am sharing a script to find a list of blocked and deadlock queries by other blocking queries of Greenplum Database Server.

You can visit below article to know more about, what is a lock, deadlock, block and timeout?

Database Theory: What is Timeout, Lock, Block, and Deadlock in a Database System?

If two queries are trying to get the same resource, both are depended on each other and generates block state first and then deadlock.

In the below script, you can find a list of blocked queries and blocker queries with a value of time age.
You can find a process_id of blocker query which we can kill for avoiding the deadlock situation.

SELECT
	kl.pid as blocking_pid
	,ka.usename as blocking_user
	,ka.current_query as blocking_query
	,bl.pid as blocked_pid
	,a.usename as blocked_user
	,a.current_query as blocked_query
	,to_char(age(now(), a.query_start),'HH24h:MIm:SSs') as age
FROM pg_catalog.pg_locks bl
JOIN pg_catalog.pg_stat_activity a
	ON bl.pid = a.procpid
JOIN pg_catalog.pg_locks kl
	ON bl.locktype = kl.locktype
	and bl.database is not distinct from kl.database
	and bl.relation is not distinct from kl.relation
	and bl.page is not distinct from kl.page
	and bl.tuple is not distinct from kl.tuple
	and bl.transactionid is not distinct from kl.transactionid
	and bl.classid is not distinct from kl.classid
	and bl.objid is not distinct from kl.objid
	and bl.objsubid is not distinct from kl.objsubid
	and bl.pid <> kl.pid
JOIN pg_catalog.pg_stat_activity ka
	ON kl.pid = ka.procpid
WHERE kl.granted and not bl.granted
ORDER BY a.query_start;

In this post, I am sharing an important parameter which we can use for setting a wait time before deadlock occurs in PostgreSQL.

The parameter is deadlock_timeout (integer). The default is one second which is very less time.

Before any deadlock, there is a blocked transaction situation. In most of the cases, we can avoid the deadlock by checking or solving the blocking situation. So in this situation, database engine has to wait before generating the deadlock.

Using deadlock_timeout parameter, we can set the wait time for deadlock situation.

Increasing this value reduces the amount of time wasted in needless deadlock checks, but slows down reporting of real deadlock errors.

Change the value of the deadlock_timeout parameter in postgresql.conf file.

PostgreSQL: Script to find information about the Locks held by Open Transactions (pg_locks)

PostgreSQL 10 introduced many useful features that we can use in day to day work.

Now, we can trace the status of the running transaction in PostgreSQL 10. If we have transaction IDs of our sessions and suddenly database crashed or shutdown, we can check the status of those transactions.

We can check the status like Committed, In Progress, Rollback or Aborted. This facility will help a lot for taking a necessary decision on crashed transactions.

PostgreSQL 10 introduced two functions:

txid_current() – will return the current transaction id of a session
txid_status() – will return the status of transaction

Please check the below sample:

Create a sample table:

CREATE TABLE tbl_stud
(Rno INT, Name Character Varying);

Open a transaction, and insert a record:

BEGIN TRANSACTION;

INSERT INTO tbl_stud
VALUES (1,'Anvesh');

Check the current transaction id:

SELECT *FROM txid_current();

txid_current
------------
    587

Check the status of above transaction id:
It is showing “in progress” because I didn’t commit the transaction yet.

SELECT txid_status(BIGINT '587');

txid_status
-----------
in progress

Now, execute the COMMIT:

COMMIT TRANSACTION;

Now, check the status again:

SELECT txid_status(BIGINT '587');

txid_status
-----------
committed

You can also return transaction id, with the insert statement: (Using RETURNING)

SELECT txid_status(BIGINT '587');

txid_status
-----------
committed

In this post, I am sharing a T-SQL script to find out a list of open transactions in SQL Server. If application developers are not closed database transactions correctly, there are a chance for deadlock/lock in the database.

All application/database developers should make sure that all transactions are closed which are opened earlier.
DBA can use below script to find out a list of Open Transaction in SQL Server:

SELECT
	[tst].[session_id] AS SessionID
	,[des].[login_name] AS LoginName
	,DB_NAME (tdt.database_id) AS DatabaseName
	,[tdt].[database_transaction_begin_time] AS TransactionBeginTime
	,[tdt].[database_transaction_log_bytes_used] AS LogBytesUsed    
	,[mrsh].text AS QueryText
	,[ph].[query_plan] AS QueryPlan
FROM sys.dm_tran_database_transactions [tdt]
JOIN sys.dm_tran_session_transactions [tst]
	ON [tst].[transaction_id] = [tdt].[transaction_id]
JOIN sys.[dm_exec_sessions] [des]
	ON [des].[session_id] = [tst].[session_id]
JOIN sys.dm_exec_connections [dec]
	ON [dec].[session_id] = [tst].[session_id]
LEFT OUTER JOIN sys.dm_exec_requests [der]
	ON [der].[session_id] = [tst].[session_id]
CROSS APPLY sys.dm_exec_sql_text ([dec].[most_recent_sql_handle]) AS [mrsh]
OUTER APPLY sys.dm_exec_query_plan ([der].[plan_handle]) AS [ph]
ORDER BY [TransactionBeginTime] ASC
GO

I shared a couple of articles on SQL Server database locking and how to detect a deadlock. Please access few of them.

Different ways to detect a deadlock
What happens after the Deadlock?

I recently found an undocumented function %%lockres%% which we can use to locate the page information of records especially for those records which hold a Lock.

It returns a hash value same as like column “resource_description” of table sys.dm_tran_locks, but the good thing is you can use it in your SELECT statement and can correlate the column resource_description of table sys.dm_tran_locks.

By this way, you can get the exact record, and it’s page info which currently held by a Lock.

Let me demonstrate this,
Prerequisites:
Use below article and generate a sample deadlock situation in your database server.

SQL Server: T-SQL script to generate a DeadLock in a Database

Check the result of below query and note down the result of column “resource_description”:

select *from sys.dm_tran_locks

Use %%lockres%% and SELECT both the tables:
You can easily correlate the result of sys.dm_tran_locks column resource_description and the result of %%lockres%%. You can find an exact record which held by a Lock.

SELECT %%lockres%% AS RecordPageInfo,* 
FROM tbl_SampleTable_A

SELECT %%lockres%% AS RecordPageInfo,* 
FROM tbl_SampleTable_B

After this exercise, Please COMMIT all your open transactions.

In the previous post, I have shared important details about SQL Server DBCC INPUTBUFFER and how we can use it to find a lead blocker transaction.

SQL Server: DBCC INPUTBUFFER to find the last statement executed by a SPID

SQL Server 2016 introduced sys.dm_exec_input_buffer which is a extended version of DBCC INPUTBUFFER.
It is also serving the same service like DBCC INPUTBUFFER.

You can build your full query using this new system dmv.

Prepared a script to find the last statement executed by SPID.

SELECT
	der.session_id
	,ib.event_info AS QueryText
FROM sys.dm_exec_requests AS der
JOIN sys.dm_exec_sessions AS des 
	ON des.session_id = der.session_id
CROSS APPLY sys.dm_exec_input_buffer(der.session_id, der.request_id) AS ib
WHERE
	des.is_user_process = 1
GO

Are you SQL Server DBA?
Have you ever faced deadlock situations?
What are your steps to remove a deadlock?
Do you know, how to get the last statement executed by lead blocker transaction?

If you are a SQL DBA, you must know about this.
You can access few related articles:

SQL Server: Database Lock, Deadlock, Block and Isolation Interview Questions and Answers (Day-1)

SQL Server: 8 different ways to Detect a DeadLock in a Database

DBCC INPUTBUFFER:
Using this DBCC command, you can get the last statement executed by a particular SPID which is playing a lead blocker role.

Please do not blindly kill the connections by SPID. You must know the root cause of deadlock and its previous lead blocker transaction.

Prepared a one example demonstration on this.

Create a table with sample data:

CREATE TABLE tbl_Students 
(
	StudID INT
	,StudName VARCHAR(20)
)
GO

INSERT INTO tbl_Students
VALUES 
(1,'Anvesh'),(2,'Neevan')
,(3,'Jeeny'),(4,'Roy');

BEGIN TRANSACTION 
UPDATE tbl_Students SET StudName = 'Meera' 
WHERE StudID = 1
GO

UPDATE tbl_Students SET StudName = 'Anvesh' 
WHERE StudID = 1
GO

SP_WHO2

DBCC INPUTBUFFER (151)

EventType      Parameters EventInfo
-------------- ---------- --------------------
Language Event 0          BEGIN TRANSACTION 
UPDATE tbl_Students SET StudName = 'Meera' 
WHERE StudID = 1

In this post, I am sharing one script to find a list of queries which are blocked by other running queries of SQL Server.

DBAs are always seeking for long running queries, most resources consumed query. Using this script DBA can find list of waiting queries which are not under any type of execution.

DBAs can use this query to prevent the deadlock also because long running block transactions can occur a deadlock situation.

SELECT
	dowt.session_id
	,dowt.wait_duration_ms
	,dowt.wait_type
	,dowt.blocking_session_id
	,dese.host_name as HostName
	,der.command
	,der.percent_complete
	,der.cpu_time
	,der.total_elapsed_time
	,der.reads
	,der.writes
	,der.logical_reads
	,der.row_count
	,dest.text AS QueryText
	,dest.dbid AS DatabaseID
	,deqp.query_plan
	,der.plan_handle
FROM sys.dm_os_waiting_tasks as dowt
INNER JOIN sys.dm_exec_sessions as dese
	ON dowt.session_id = dese.session_id
INNER JOIN sys.dm_exec_requests as der
	ON dese.session_id = der.session_id
CROSS APPLY sys.dm_exec_sql_text(der.plan_handle) as dest
CROSS APPLY sys.dm_exec_query_plan(der.plan_handle) as deqp
WHERE dowt.session_id > 50

Here, You can also access few related articles:

SQL Server: Script to find TOP 20 most used or executed SQL Queries

SQL Server: Script to find top 20 running query, which are utilizing more CPU

SQL Server: 8 different ways to Detect a DeadLock in a Database

The DeadLock in a database system is a very common thing and all Database Administrator responsible to detect and manage a DeadLock situation.

In this post, I am sharing one small demonstration t to generate a DeadLock situation in a PostgreSQL.

Database Theory: What is Timeout, Lock, Block, and Deadlock in a Database System?

Most of the time, We are facing DeadLock problem in our Production Database Server.
But What happen, when Database Administrator wants to generate DeadLock situation and wants to create a script for detecting a DeadLock.

First create two sample tables:

CREATE TABLE ABC (ID INT PRIMARY KEY);
CREATE TABLE XYZ (ID INT PRIMARY KEY);

Open Session – 1 and execute below code:

BEGIN;
INSERT INTO ABC VALUES (1);

Open Session – 2 and execute below code:

BEGIN;
INSERT INTO XYZ VALUES (1);
INSERT INTO ABC VALUES (1);

Again open Session – 1 and execute below Insert Statement:

INSERT INTO XYZ VALUES (1);

You will get a below deadlock message:

ERROR:  deadlock detected
DETAIL:  Process 5944 waits for ShareLock on transaction 892; blocked by process 4884.
Process 4884 waits for ShareLock on transaction 891; blocked by process 5944.
HINT:  See server log for query details.
CONTEXT:  while inserting index tuple (0,2) in relation "xyz_pkey"

Please visit other related articles:

PostgreSQL 9.5: Using FOR UPDATE SKIP LOCKED Option SELECT only Committed Records

PostgreSQL: Script to find information about the Locks held by Open Transactions (pg_locks)

Script to find sessions that are blocking other sessions in PostgreSQL

In this post, I am sharing one script to find information about the Locks which are held by Open Transactions of PostgreSQL Database Server.

Database Theory: What is Timeout, Lock, Block, and Deadlock in a Database System?

PostgreSQL view pg_locks contains the main information about the all types of lock of Database Server.
It contains one row per active lockable object.

This script is very helpful to all PostgreSQL Database Administrators.

Below is a script:

SELECT 
	pl.pid AS ProcessID
	,psa.datname AS DatabaseName
	,psa.usename AS UserName
	,psa.application_name AS ApplicationName
	,ps.relname AS ObjectName
	,psa.query_start AS QueryStartTime
	,psa.state AS QueryState
	,psa.query AS SQLQuery
	,pl.locktype
	,pl.tuple AS TupleNumber
	,pl.mode AS LockMode
	,pl.granted -- True if lock is held, false if lock is awaited
FROM pg_locks AS pl 
LEFT JOIN pg_stat_activity AS psa
	ON pl.pid = psa.pid
LEFT JOIN pg_class AS ps
	ON pl.relation = ps.oid