Adventures in Machine Learning

Simplify Exception Handling with SQL Server’s TRY CATCH

SQL Server TRY CATCH: Exception Handling Made Easy

Have you ever been in a situation where your SQL script failed to execute due to exceptions being thrown? It can be frustrating, especially when the error messages are difficult to understand.

Fortunately, SQL Server comes with the TRY CATCH construct, making exception handling a breeze.


The TRY CATCH construct is used to handle exceptions in SQL Server. It is a block of code that contains two sections: the TRY section and the CATCH section.

The TRY section contains the code that may throw an exception, while the CATCH section contains the code that handles the exception if it occurs.

CATCH Block Functions

There are six functions that can be used in the CATCH block to handle exceptions. They are:

  1. ERROR_LINE: Returns the line number where the exception occurred.
  2. ERROR_MESSAGE: Returns the description of the exception.
  3. ERROR_PROCEDURE: Returns the name of the stored procedure or trigger where the exception occurred.
  4. ERROR_NUMBER: Returns the identification number of the exception.
  5. ERROR_SEVERITY: Returns the severity level of the exception.
  6. ERROR_STATE: Returns the state number of the exception.

Nested TRY CATCH Constructs

Sometimes, you might want to handle exceptions at different levels of a stored procedure or trigger. This is where nested TRY CATCH constructs come in.

A nested TRY CATCH construct is a TRY CATCH block within another TRY CATCH block. The inner TRY CATCH block handles exceptions that occur within the outer TRY CATCH block.


To demonstrate the usage of TRY CATCH, we will set up tables using the following SQL code:

  CREATE TABLE sales.persons (
     person_id INT PRIMARY KEY,
     first_name VARCHAR(50),
     last_name VARCHAR(50)
     deal_id INT PRIMARY KEY,
     person_id INT FOREIGN KEY REFERENCES sales.persons(person_id),
     amount DECIMAL(10,2),
     deal_date DATE

Next, we will create a stored procedure called usp_report_error, which simply reports the error message. Here is the code:

CREATE PROCEDURE usp_report_error



     ERROR_NUMBER() AS ErrorNumber,
     ERROR_MESSAGE() AS ErrorMessage,
     ERROR_PROCEDURE() AS ErrorProcedure,
     ERROR_LINE() AS ErrorLine,
     ERROR_SEVERITY() AS ErrorSeverity,
     ERROR_STATE() AS ErrorState;


Now, let’s create another stored procedure called usp_delete_person, which deletes a person from the persons table and all their associated deals from the deals table. Here is the code:

CREATE PROCEDURE usp_delete_person

  @person_id INT



     DELETE FROM WHERE person_id = @person_id;
     DELETE FROM sales.persons WHERE person_id = @person_id;
     EXEC usp_report_error;


Testing usp_delete_person

Now, let’s test usp_delete_person with and without an exception to see how TRY CATCH handles the exception. First, we will delete a person who has no deals:

  EXEC usp_delete_person @person_id = 1;

If we run this code, everything should execute without any issues.

However, if we try to delete a person who has deals, it will cause a constraint violation and trigger an exception:

  EXEC usp_delete_person @person_id = 2;

TRY CATCH should handle this exception and the error message should be reported using the usp_report_error stored procedure.


In conclusion, the SQL Server TRY CATCH construct is an essential tool for dealing with exceptions when writing SQL scripts. It allows you to handle exceptions in a more robust and organized manner.

With the right knowledge of the TRY CATCH block and its functions, you can avoid frustration and improve the stability of your SQL Server scripts. In this article, we explored the SQL Server TRY CATCH construct and its importance in handling exceptions in SQL scripts.

The TRY CATCH block consists of two sections: the TRY section and the CATCH section. The CATCH block functions include ERROR_LINE, ERROR_MESSAGE, ERROR_PROCEDURE, ERROR_NUMBER, ERROR_SEVERITY, and ERROR_STATE.

Nested TRY CATCH constructs are useful for handling exceptions in different levels of stored procedures or triggers. We also demonstrated the usage of TRY CATCH through setting up tables, creating stored procedures, and testing them with and without exceptions.

Overall, mastering the TRY CATCH construct can improve the stability and robustness of SQL scripts and minimize frustration while debugging them.

Popular Posts