Wondering how to Detect and Release Locks in Amazon Redshift? We can help you.

Generally, we may come across an issue where the table lock blocks the queries in Amazon Redshift.

Here, at Bobcares, we assist our customers with several AWS queries as part of our AWS Support Services.

Today, let us see how to find and resolve this.

Detect and Release Locks in Amazon Redshift

Locks are a protection mechanism that controls how many sessions can access a table at the same time.

In addition, it determines the operations to perform in those sessions.

While most relational databases use row-level locks, Amazon Redshift uses table-level locks.

Generally, Amazon Redshift has three lock modes. They are:

• AccessExclusiveLock
• AccessShareLock
• ShareRowExclusiveLock

When a query or transaction acquires a lock on a table, it remains for the duration of the query or transaction.

However, other queries or transactions that are waiting to acquire the same lock are blocked.

Suppose we have an issue with the locks. In such a case, we need to identify the session (PID) that holds the lock and then terminate the session.

If the session doesn’t terminate, we reboot the cluster.

How to Fix it?

Moving ahead, let us see how our Support Techs identify the session and terminate it.

Initially, we run a query to identify sessions that are holding locks:

select a.txn_owner, a.txn_db, a.xid, a.pid, a.txn_start, a.lock_mode, a.relation as table_id,nvl(trim(c."name"),d.relname) as tablename, a.granted,b.pid as blocking_pid ,datediff(s,a.txn_start,getdate())/86400||' days '||datediff(s,a.txn_start,getdate())%86400/3600||' hrs '||datediff(s,a.txn_start,getdate())%3600/60||' mins '||datediff(s,a.txn_start,getdate())%60||' secs' as txn_duration
from svv_transactions a
left join (select pid,relation,granted from pg_locks group by 1,2,3) b
on a.relation=b.relation and a.granted='f' and b.granted='t'
left join (select * from stv_tbl_perm where slice=0) c
on a.relation=c.id
left join pg_class d on a.relation=d.oid
where a.relation is not null;

This will result in an output like this:

txn_owner | txn_db | xid | pid | txn_start | lock_mode | table_id | tablename | granted | blocking_pid | txn_duration |
----------+--------+---------+-------+----------------------------+---------------------+----------+-----------+---------+--------------+-----------------------------+
usr1 | db1 | 5559898 | 19813 | 2018-06-30 10:51:57.485722 | AccessExclusiveLock | 351959 | lineorder | t | | 0 days 0 hrs 0 mins 52 secs |
usr1 | db1 | 5559927 | 20450 | 2018-06-30 10:52:19.761199 | AccessShareLock | 351959 | lineorder | f | 19813 | 0 days 0 hrs 0 mins 30 secs |
usr1 | db1 | 5559898 | 19813 | 2018-06-30 10:51:57.485722 | AccessShareLock | 351959 | lineorder | t | | 0 days 0 hrs 0 mins 52 secs |

Here, we can see a column, ‘granted’. If it is f (false), it means that a transaction in another session holds the lock.

The blocking_pid column shows the process ID of the session that holds the lock.

To release a lock, we wait for the transaction that holds the lock to finish.

On the other hand, to manually terminate the session we run the below command:

select pg_terminate_backend(PID);

If we terminate a PID, it rolls back all running transactions and releases all locks in the session.

Then other transactions that are waiting to acquire the lock will claim those locks.

We need to also make note that when PG_TERMINATE_BACKEND(PID) returns “1”, it indicates a successful termination request to the PID.

However, this doesn’t wholly guarantee termination.

In few cases, we cannot determine the PID depending on its internal status.

Therefore, it’s a best practice to also check STV_SESSIONS to confirm termination.

If PG_TERMINATE_BACKEND(PID) did not successfully terminate, then we reboot the cluster to terminate the process.

[Need help with the process? We are here for you]

Conclusion

In short, we saw how our Support Techs go about detecting and releasing locks in Amazon Redshift.