Use Caution with Explicit Transactions in Stored Procedures
Explicit transactions are often used within stored procedures to guarantee all-or-nothing data integrity. However, a little known fact is that a query timeout will leave the transaction open unless non-default session settings and/or special exception handling are used. I’ll describe how to protect your application from problems following timeouts and other unexpected errors.
Consider the following stored procedure containing an explicit transaction:
CREATE PROCEDURE dbo.UpdateWithExplicitTransaction @MyKey int, @MyColumnValue int AS DECLARE @Error int BEGIN TRAN UPDATE dbo.Foo SET MyColumn = @MyColumnValue WHERE MyKey = @MyKey SET @Error = @@ERROR IF @Error <> 0 BEGIN GOTO Done END UPDATE dbo.Bar SET MyColumn = @MyColumnValue WHERE MyKey = @MyKey SET @Error = @@ERROR IF @Error <> 0 BEGIN GOTO Done END COMMIT Done: IF @Error <> 0 BEGIN ROLLBACK END RETURN @Error
You execute the script below from SQL Server Management Studio or Query Analyzer with the query timeout option set to 30 seconds and the second UPDATE statement in the proc times out.
timeout option set to 30 seconds and the second UPDATE statement in the proc times out.
EXEC dbo.UpdateWithExplicitTransaction PRINT ‘execution completed’ GO SELECT @@ERROR AS [@@ERROR], @@TRANCOUNT AS [@@TRANCOUNT] GO
Assuming default session settings, check all that apply:
a) Proc execution continues after the failed UPDATE
b) @@ERROR is zero
c) @@TRANCOUNT is zero
d) The PRINT statement is executed
Let me first mention something important about timeouts before I provide the correct answer(s). A command timeout occurs in the client application, not the SQL Server backend. A timeout is basically just a cancel request that is sent by the client API when a command executes longer than the specified interval. A timeout is very much like pressing the stop button in Query Analyzer or Management Studio because you feel a query has been running too long. The only difference is that the stop is issued by the client API on behalf of the application.
Both “A” (proc continues) and “D” (PRINT executes) are false because the attention event from the client instructed SQL Server to cancel the currently executing batch in its entirety. No code after the UPDATE executes, including the PRINT statement following the stored procedure execute. This is logical since a query cancel or timeout wouldn’t be much use if SQL Server continued executing statements afterward.
“B” (zero @@ERROR) is true. @@ERROR is zero because no error occurred on the backed; SQL Server successfully canceled the batch per the client cancel request after the timeout. The timeout error is raised only on the client by the API to notify the application (SSMS/QA in this example) that the command timed out. SSMS and QA simply catch the error and display the error message from the API.
“C” (zero @@TRANCOINT) is false because XACT_ABORT OFF is the default session setting. With XACT_ABORT OFF, it is the client application’s responsibility to trap the timeout error and rollback the transaction if necessary. The transaction is left open and uncommitted following the timeout error. This can have serious and undesirable consequences if the application performs other work on the connection, unaware of the open transaction.
Using SET XACT_ABORT
SET XACT_ABORT specifies what action SQL Server should take following run-time errors. The default session setting is SET XACT_ABORT OFF, which indicates that only the Transact-SQL statement that raised the error is rolled back and the transaction continues. Depending on the severity of the error, the entire transaction may be rolled back and batch aborted, even with SET XACT_ABORT is OFF.
A side effect of SET XACT_ABORT OFF is that a cancel/timeout error can leave an open transaction so it’s the client’s responsibility to cleanup following cancel/timeout. To safeguard against leaving an open transaction, applications that execute transactions with SET XACT_ABORT OFF need to roll back transactions and perhaps close the connection following SQL exceptions.
Note that with connection pooling, simply closing the connection without a rollback will only return the connection to the pool and the transaction will remain open until later reused or removed from the pool. This can result in locks begin held unnecessary and cause other timeouts and rolling blocks.
SET XACT_ABORT ON instructs SQL Server to rollback the entire transaction and abort the batch when a run-time error occurs. Compile errors (e.g. syntax errors) are not affected by SET XACT_ABORT.
In my experience, SET XACT_ABORT ON provides the desired behavior in most cases. I’ve never run into a situation where I wouldn’t want to rollback a transaction following a cancel or timeout. I nearly always specify SET XACT_ABORT ON in stored procedures that contain explicit transactions to ensure that transactions are rolled back even if the application code doesn’t clean up properly. The only time I don’t use XACT_ABORT is in rare cases where I need to trap and handle specific errors in Transact-SQL and continue.
I strongly recommend that SET XACT_ABORT ON be included in all stored procedures with explicit transactions unless you have a specific reason to do otherwise. The consequences of an application unwittingly performing work on a connection with an open transaction are disastrous.
SQL Server error handling in general is a huge topic I focused on only on timeout errors and SET XACT_ABORT here. For a thorough discussion of SQL Server error handling, I suggest perusing articles Implementing Error Handling with Stored Procedures and Error Handling in SQL Server – a Background by SQL Server MVP Erland Sommarskog.