we have a below procedure to update/insert a table. I have added exception handling in stored procedure as below.
CREATE PROCEDURE USP_UPDATESP
#Workstationlist worktable READONLY
AS
BEGIN
SET NOCOUNT ON
DECLARE #rerror As int
SET #rerror = 0
BEGIN TRY
BEGIN TRAN
MERGE [dbo].WORKTABLE AS [ofc]
USING #Workstationlist AS [Source] ON [ofc].officeid = [Source].id
WHEN MATCHED THEN
UPDATE
SET NumWorkStations = [Source].wsno,
ModifiedBy = [Source].modifiedby,
ModifiedByUsername = [Source].modifieduser,
ModifiedDate = GETDATE()
WHEN NOT MATCHED THEN
INSERT ( officeid, NumWorkStations, ModifiedBy, ModifiedByUsername, ModifiedDate )
VALUES ([Source].ID,[Source].wsno, [Source].modifiedby, [Source].modifieduser,GETDATE() );
SET #rerror = #rerror + ##error
If #rerror = 0
BEGIN
COMMIT TRAN
END
END TRY
BEGIN CATCH
SELECT #rerror AS ErrNum
ROLLBACK TRAN
End Catch
SET NOCOUNT off
END
GO
When I execute the procedure with an exception (passing null to id column) as below
declare #Workstationlist worktable
insert into #Workstationlist VALUES ( NULL,500,106720,106720)
EXEC USP_UPDATESP #Workstationlist
I got #error as 0 Always . Is there any problem this way of error handling?
to me it looks like you are mixing TRY...CATCH error handling with old style error handling.
the code:
SET #rerror = #rerror + ##error
cannot be reached because when an exception occurs the control is passed to the catch block so the #rerror variable will always be 0, the value initially set.
in the catch block you should leverage the proper structures/objects to access error information and drop all the old way completely.
something like this:
BEGIN CATCH;
DECLARE #ErrSev INT,
#ErrMsg NVARCHAR(MAX),
#ErrState INT;
SELECT #ErrSev = ERROR_SEVERITY(),
#ErrState = ERROR_STATE(),
#ErrMsg = isnull(ERROR_PROCEDURE(), '(unknown procedure)') + ': ' + isnull(ERROR_MESSAGE(), '(unknown message)');
RAISERROR(#ErrMsg, #ErrSev, #ErrState);
END CATCH;
Catch the error in proper way.
BEGIN TRY
BEGIN TRANSACTION;
COMMIT TRANSACTION;
SELECT 'Success' AS Result
END TRY
BEGIN CATCH
ROLLBACK TRANSACTION;
SELECT 'Failed' AS Result
,ERROR_NUMBER() AS ErrorNumber
,ERROR_MESSAGE() AS ErrorMessage
END CATCH;
END
Related
I'm doing a code review for a new procedure in sql
and i have two question please:
The commit transaction is encapsulated in the whole procedure - i think it should be only in the insert statement.
If there is a begin transaction, there should be also a error handling.
I am adding the code before
BEGIN
DECLARE #paymentSpecificationId BIGINT ;
BEGIN TRANSACTION
SET #paymentSpecificationId = (SELECT Id FROM [dbo].[PaymentSpecifications]
WHERE PaymentSpecificationGuid = #PaymentSpecificationGuid) ;
IF(#paymentSpecificationId > 0)
BEGIN
SELECT #paymentSpecificationId AS Results;
COMMIT TRANSACTION;
RETURN;
END
INSERT INTO [dbo].[PaymentSpecifications]
(
[CurrencyBalanceId],
[PaymentSpecificationGuid],
[PaymentSpecificationTypeId],
[ExternalId],
[Reference],
[ExternalOriginatorId],
[EventTimestamp],
[Created]
)
VALUES
(
#CurrencyBalanceId,
#PaymentSpecificationGuid,
#PaymentSpecificationTypeId,
#ExternalId,
#Reference,
#ExternalOriginatorId,
#EventTimestamp,
#Created
)
SELECT SCOPE_IDENTITY() AS Results;
COMMIT TRANSACTION;
END
and the code after my suggestion fix
BEGIN
BEGIN TRY
DECLARE #paymentSpecificationId BIGINT ;
SET #paymentSpecificationId = (SELECT Id FROM [dbo].[PaymentSpecifications]
WHERE PaymentSpecificationGuid = #PaymentSpecificationGuid) ;
IF(#paymentSpecificationId > 0)
BEGIN
SELECT #paymentSpecificationId AS Results;
RETURN;
END
BEGIN TRANSACTION
INSERT INTO [dbo].[PaymentSpecifications]
(
[CurrencyBalanceId],
[PaymentSpecificationGuid],
[PaymentSpecificationTypeId],
[ExternalId],
[Reference],
[ExternalOriginatorId],
[EventTimestamp],
[Created]
)
VALUES
(
#CurrencyBalanceId,
#PaymentSpecificationGuid,
#PaymentSpecificationTypeId,
#ExternalId,
#Reference,
#ExternalOriginatorId,
#EventTimestamp,
#Created
)
SELECT SCOPE_IDENTITY() AS Results;
COMMIT TRANSACTION;
END TRY
BEGIN CATCH
IF ##TRANCOUNT > 0
ROLLBACK TRANSACTION
DECLARE #ErrMsg nvarchar(4000), #ErrSeverity int
SELECT #ErrMsg = ERROR_MESSAGE(),
#ErrSeverity = ERROR_SEVERITY()
RAISERROR(#ErrMsg, #ErrSeverity, 1)
END CATCH
END
GO
thanks
how catch error message etc "Error converting data type varchar to datetime"
and this error put in Select output
BEGIN
SET NOCOUNT ON;
begin try
UPDATE projects
SET
projectUser = #projectUser,
projectStartDate = #projectStartDate
where projectId = #projectId
SELECT 'OK'
end try
begin catch
SELECT 'ERROR - msg error'
end catch
COMMIT
END
I don't need ==> https://postimg.org/image/u8mohtl9b/
Any solution?
The issue you are having is that the error is not occuring in the procedure, it is occuring when calling the procedure. In a simple example, create the following procedure:
IF OBJECT_ID(N'dbo.ErrorCatchTest', 'P') IS NOT NULL
DROP PROCEDURE dbo.ErrorCatchTest;
GO
CREATE PROCEDURE dbo.ErrorCatchTest #int INT
AS
BEGIN
SET NOCOUNT ON;
BEGIN TRY
DECLARE #T TABLE (I INT);
INSERT #T (I) VALUES (5.0 / #int);
SELECT 'OK';
END TRY
BEGIN CATCH
SELECT CONCAT('Error_Message: ', ERROR_MESSAGE());
END CATCH
END;
If I pass a valid INT to the procedure:
EXECUTE dbo.ErrorCatchTest #int = 1;
The I get OK as required.
If I a pass 0 to force an error:
EXECUTE dbo.ErrorCatchTest #int = 0;
You get the error message as required, but if I try an pass an invalid integer:
EXECUTE dbo.ErrorCatchTest #int = 'Not a number';
Then I get the error message, because the error is not within the proceudure, but while doing an implicit convert on the parameters.
The way around this is to call the procedure within a try/catch block:
BEGIN TRY
EXECUTE dbo.ErrorCatchTest #int = 'Not a number';
END TRY
BEGIN CATCH
SELECT CONCAT('Error_Message: ', ERROR_MESSAGE());
END CATCH
You can select the error message like below...
Begin Catch
SELECT 'Error_Message: ' + ERROR_MESSAGE() + ' Error_Line: ' + ERROR_LINE() AS ErrorMessage
End Catch
If you need only error message,use the below script.
BEGIN CATCH
SELECT 'Error_Message :'+ERROR_MESSAGE()
END CATCH
sample output :
Here is the scenario:
Stored procedure sproc_a calls sproc_b. Then sproc_b calls sproc_c. A typical nested procedure.
Sproc_a did a SET XACT_ABORT ON; and used named transaction.
Sproc_c raised an error.
tSQLt.ExpectException failed to acknowledge the error. The test should be successful but it failed.
Below is the code to replicate the scenario.
create procedure sproc_c
as
RAISERROR('An error is found', 11, 1)
go
create procedure sproc_b
as
exec dbo.sproc_c;
go
create procedure sproc_a
as
SET QUOTED_IDENTIFIER OFF
SET ANSI_NULLS ON
SET NOCOUNT ON
SET XACT_ABORT ON
SET ANSI_WARNINGS OFF
declare #transactionName as varchar(50) = '[POC]';
begin tran #transactionName
save tran #transactionName
exec dbo.sproc_b;
commit tran #transactionName
go
CREATE PROCEDURE [test sproc_a]
AS
-- Assert
BEGIN
EXEC tSQLt.ExpectException
#ExpectedMessage = 'An error is found'
END
-- Act
BEGIN
EXEC dbo.sproc_a
END
GO
EXEC tSQLt.Run '[test sproc_a]'
When I removed the SET XACT_ABORT ON, the unit test is successful but it hitches an error with it: Transaction count after EXECUTE indicates a mismatching number of BEGIN and COMMIT statements. Previous count = 0, current count = 1.
This is more like a bug report. Well I guess maybe the question is: anyone who has an idea on how to fix it? :)
Applying the logic from How to ROLLBACK a transaction when testing using tSQLt add a TRY CATCH that checks to see if a ROLLBACK is still needed.
create procedure sproc_c
as
RAISERROR('An error is found', 11, 1)
go
create procedure sproc_b
as
exec dbo.sproc_c;
go
create procedure sproc_a
as
SET QUOTED_IDENTIFIER OFF
SET ANSI_NULLS ON
SET NOCOUNT ON
SET XACT_ABORT ON
SET ANSI_WARNINGS OFF
declare #transactionName as varchar(50) = '[POC]';
BEGIN TRY
begin tran #transactionName
save tran #transactionName
exec dbo.sproc_b;
commit tran #transactionName
END TRY
BEGIN CATCH
IF ##TRANCOUNT > 0
ROLLBACK;
-- Do some exception handling
-- You'll need to reraise the error to prevent exceptions about inconsistent
-- ##TRANCOUNT before / after execution of the stored proc.
RAISERROR('An error is found', 11, 1);
END CATCH
go
CREATE PROCEDURE [test sproc_a]
AS
-- Assert
BEGIN
EXEC tSQLt.ExpectException
#ExpectedMessage = 'An error is found'
END
-- Act
BEGIN
EXEC dbo.sproc_a
END
GO
EXEC tSQLt.Run '[test sproc_a]'
I'm making a separate comment to answer my own question. I've investigated tSQLt.Private_RunTest. It turns out:
Private_RunTest has a BEGIN TRAN. Then it will save a named transaction.
It is followed by a TRY-CATCH, it will do an exec(#cmd). This basically executes your unit tests. For example: "EXEC tSQLt.Run '[test sproc_a]'".
When sproc_a raises an error, Private_RunTest will try to do a ROLLBACK TRAN #TranName. This will fail because it does not rollback the named transaction in sproc_a.
As a resolution, I hacked tSQLt.Private_RunTest and replaced the code "ROLLBACK TRAN #TranName;" with "ROLLBACK TRAN;".
I also added a condition when doing a commit.
I'm not sure what the implications are after doing this change. We'll see how it goes. Below are my changes:
CREATE PROCEDURE tSQLt.Private_RunTest
#TestName NVARCHAR(MAX),
#SetUp NVARCHAR(MAX) = NULL
AS
BEGIN
DECLARE #Msg NVARCHAR(MAX); SET #Msg = '';
DECLARE #Msg2 NVARCHAR(MAX); SET #Msg2 = '';
DECLARE #Cmd NVARCHAR(MAX); SET #Cmd = '';
DECLARE #TestClassName NVARCHAR(MAX); SET #TestClassName = '';
DECLARE #TestProcName NVARCHAR(MAX); SET #TestProcName = '';
DECLARE #Result NVARCHAR(MAX); SET #Result = 'Success';
DECLARE #TranName CHAR(32); EXEC tSQLt.GetNewTranName #TranName OUT;
DECLARE #TestResultId INT;
DECLARE #PreExecTrancount INT;
TRUNCATE TABLE tSQLt.CaptureOutputLog;
CREATE TABLE #ExpectException(ExpectException INT,ExpectedMessage NVARCHAR(MAX), ExpectedSeverity INT, ExpectedState INT, ExpectedMessagePattern NVARCHAR(MAX), ExpectedErrorNumber INT, FailMessage NVARCHAR(MAX));
IF EXISTS (SELECT 1 FROM sys.extended_properties WHERE name = N'SetFakeViewOnTrigger')
BEGIN
RAISERROR('Test system is in an invalid state. SetFakeViewOff must be called if SetFakeViewOn was called. Call SetFakeViewOff after creating all test case procedures.', 16, 10) WITH NOWAIT;
RETURN -1;
END;
SELECT #Cmd = 'EXEC ' + #TestName;
SELECT #TestClassName = OBJECT_SCHEMA_NAME(OBJECT_ID(#TestName)), --tSQLt.Private_GetCleanSchemaName('', #TestName),
#TestProcName = tSQLt.Private_GetCleanObjectName(#TestName);
INSERT INTO tSQLt.TestResult(Class, TestCase, TranName, Result)
SELECT #TestClassName, #TestProcName, #TranName, 'A severe error happened during test execution. Test did not finish.'
OPTION(MAXDOP 1);
SELECT #TestResultId = SCOPE_IDENTITY();
BEGIN TRAN;
SAVE TRAN #TranName;
SET #PreExecTrancount = ##TRANCOUNT;
TRUNCATE TABLE tSQLt.TestMessage;
DECLARE #TmpMsg NVARCHAR(MAX);
BEGIN TRY
IF (#SetUp IS NOT NULL) EXEC #SetUp;
EXEC (#Cmd);
IF(EXISTS(SELECT 1 FROM #ExpectException WHERE ExpectException = 1))
BEGIN
SET #TmpMsg = COALESCE((SELECT FailMessage FROM #ExpectException)+' ','')+'Expected an error to be raised.';
EXEC tSQLt.Fail #TmpMsg;
END
END TRY
BEGIN CATCH
IF ERROR_MESSAGE() LIKE '%tSQLt.Failure%'
BEGIN
SELECT #Msg = Msg FROM tSQLt.TestMessage;
SET #Result = 'Failure';
END
ELSE
BEGIN
DECLARE #ErrorInfo NVARCHAR(MAX);
SELECT #ErrorInfo =
COALESCE(ERROR_MESSAGE(), '<ERROR_MESSAGE() is NULL>') +
'[' +COALESCE(LTRIM(STR(ERROR_SEVERITY())), '<ERROR_SEVERITY() is NULL>') + ','+COALESCE(LTRIM(STR(ERROR_STATE())), '<ERROR_STATE() is NULL>') + ']' +
'{' + COALESCE(ERROR_PROCEDURE(), '<ERROR_PROCEDURE() is NULL>') + ',' + COALESCE(CAST(ERROR_LINE() AS NVARCHAR), '<ERROR_LINE() is NULL>') + '}';
IF(EXISTS(SELECT 1 FROM #ExpectException))
BEGIN
DECLARE #ExpectException INT;
DECLARE #ExpectedMessage NVARCHAR(MAX);
DECLARE #ExpectedMessagePattern NVARCHAR(MAX);
DECLARE #ExpectedSeverity INT;
DECLARE #ExpectedState INT;
DECLARE #ExpectedErrorNumber INT;
DECLARE #FailMessage NVARCHAR(MAX);
SELECT #ExpectException = ExpectException,
#ExpectedMessage = ExpectedMessage,
#ExpectedSeverity = ExpectedSeverity,
#ExpectedState = ExpectedState,
#ExpectedMessagePattern = ExpectedMessagePattern,
#ExpectedErrorNumber = ExpectedErrorNumber,
#FailMessage = FailMessage
FROM #ExpectException;
IF(#ExpectException = 1)
BEGIN
SET #Result = 'Success';
SET #TmpMsg = COALESCE(#FailMessage+' ','')+'Exception did not match expectation!';
IF(ERROR_MESSAGE() <> #ExpectedMessage)
BEGIN
SET #TmpMsg = #TmpMsg +CHAR(13)+CHAR(10)+
'Expected Message: <'+#ExpectedMessage+'>'+CHAR(13)+CHAR(10)+
'Actual Message : <'+ERROR_MESSAGE()+'>';
SET #Result = 'Failure';
END
IF(ERROR_MESSAGE() NOT LIKE #ExpectedMessagePattern)
BEGIN
SET #TmpMsg = #TmpMsg +CHAR(13)+CHAR(10)+
'Expected Message to be like <'+#ExpectedMessagePattern+'>'+CHAR(13)+CHAR(10)+
'Actual Message : <'+ERROR_MESSAGE()+'>';
SET #Result = 'Failure';
END
IF(ERROR_NUMBER() <> #ExpectedErrorNumber)
BEGIN
SET #TmpMsg = #TmpMsg +CHAR(13)+CHAR(10)+
'Expected Error Number: '+CAST(#ExpectedErrorNumber AS NVARCHAR(MAX))+CHAR(13)+CHAR(10)+
'Actual Error Number : '+CAST(ERROR_NUMBER() AS NVARCHAR(MAX));
SET #Result = 'Failure';
END
IF(ERROR_SEVERITY() <> #ExpectedSeverity)
BEGIN
SET #TmpMsg = #TmpMsg +CHAR(13)+CHAR(10)+
'Expected Severity: '+CAST(#ExpectedSeverity AS NVARCHAR(MAX))+CHAR(13)+CHAR(10)+
'Actual Severity : '+CAST(ERROR_SEVERITY() AS NVARCHAR(MAX));
SET #Result = 'Failure';
END
IF(ERROR_STATE() <> #ExpectedState)
BEGIN
SET #TmpMsg = #TmpMsg +CHAR(13)+CHAR(10)+
'Expected State: '+CAST(#ExpectedState AS NVARCHAR(MAX))+CHAR(13)+CHAR(10)+
'Actual State : '+CAST(ERROR_STATE() AS NVARCHAR(MAX));
SET #Result = 'Failure';
END
IF(#Result = 'Failure')
BEGIN
SET #Msg = #TmpMsg;
END
END
ELSE
BEGIN
SET #Result = 'Failure';
SET #Msg =
COALESCE(#FailMessage+' ','')+
'Expected no error to be raised. Instead this error was encountered:'+
CHAR(13)+CHAR(10)+
#ErrorInfo;
END
END
ELSE
BEGIN
SET #Result = 'Error';
SET #Msg = #ErrorInfo;
END
END;
END CATCH
BEGIN TRY
-- Replaced "ROLLBACK TRAN #TranName;" with "ROLLBACK TRAN;". The prior approach can't handle nested named transactions.
--ROLLBACK TRAN #TranName;
ROLLBACK TRAN;
END TRY
BEGIN CATCH
DECLARE #PostExecTrancount INT;
SET #PostExecTrancount = #PreExecTrancount - ##TRANCOUNT;
IF (##TRANCOUNT > 0) ROLLBACK;
BEGIN TRAN;
IF( #Result <> 'Success'
OR #PostExecTrancount <> 0
)
BEGIN
SELECT #Msg = COALESCE(#Msg, '<NULL>') + ' (There was also a ROLLBACK ERROR --> ' + COALESCE(ERROR_MESSAGE(), '<ERROR_MESSAGE() is NULL>') + '{' + COALESCE(ERROR_PROCEDURE(), '<ERROR_PROCEDURE() is NULL>') + ',' + COALESCE(CAST(ERROR_LINE() AS NVARCHAR), '<ERROR_LINE() is NULL>') + '})';
SET #Result = 'Error';
END
END CATCH
If(#Result <> 'Success')
BEGIN
SET #Msg2 = #TestName + ' failed: (' + #Result + ') ' + #Msg;
EXEC tSQLt.Private_Print #Message = #Msg2, #Severity = 0;
END
IF EXISTS(SELECT 1 FROM tSQLt.TestResult WHERE Id = #TestResultId)
BEGIN
UPDATE tSQLt.TestResult SET
Result = #Result,
Msg = #Msg
WHERE Id = #TestResultId;
END
ELSE
BEGIN
INSERT tSQLt.TestResult(Class, TestCase, TranName, Result, Msg)
SELECT #TestClassName,
#TestProcName,
'?',
'Error',
'TestResult entry is missing; Original outcome: ' + #Result + ', ' + #Msg;
END
-- Add "IF (##TRANCOUNT > 0)" so that it will only do the commit if there is a transaction.
IF (##TRANCOUNT > 0)
COMMIT;
END;
I'm working with SQL Server Express 2012 and I have this stored procedure:
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
ALTER procedure [dbo].[usp_AsyncExecActivated]
as
begin
set nocount on;
declare #h uniqueidentifier
, #messageTypeName sysname
, #messageBody varbinary(max)
, #xmlBody xml
, #procedureName sysname
, #startTime datetime
, #finishTime datetime
, #execErrorNumber int
, #execErrorMessage nvarchar(2048)
, #xactState smallint
, #token uniqueidentifier;
begin transaction;
begin try;
receive top(1)
#h = [conversation_handle]
, #messageTypeName = [message_type_name]
, #messageBody = [message_body]
from [AsyncExecQueue];
if (#h is not null)
begin
if (#messageTypeName = N'DEFAULT')
begin
-- The DEFAULT message type is a procedure invocation.
-- Extract the name of the procedure from the message body.
--
select #xmlBody = CAST(#messageBody as xml);
select #procedureName = #xmlBody.value(
'(//procedure/name)[1]'
, 'sysname');
update dbo.Configurations with (serializable) set conf_value = 1
where sp_name = #procedureName
if ##rowcount = 0
begin
insert dbo.Configurations(sp_name, conf_value) values (#procedureName, 1)
end
save transaction usp_AsyncExec_procedure;
select #startTime = GETUTCDATE();
begin try
exec #procedureName;
end try
begin catch
-- This catch block tries to deal with failures of the procedure execution
-- If possible it rolls back to the savepoint created earlier, allowing
-- the activated procedure to continue. If the executed procedure
-- raises an error with severity 16 or higher, it will doom the transaction
-- and thus rollback the RECEIVE. Such case will be a poison message,
-- resulting in the queue disabling.
--
select #execErrorNumber = ERROR_NUMBER(),
#execErrorMessage = ERROR_MESSAGE(),
#xactState = XACT_STATE();
if (#xactState = -1)
begin
rollback;
raiserror(N'Unrecoverable error in procedure %s: %i: %s', 16, 10,
#procedureName, #execErrorNumber, #execErrorMessage);
end
else if (#xactState = 1)
begin
rollback transaction usp_AsyncExec_procedure;
end
end catch
select #finishTime = GETUTCDATE();
select #token = [conversation_id]
from sys.conversation_endpoints
where [conversation_handle] = #h;
if (#token is null)
begin
raiserror(N'Internal consistency error: conversation not found', 16, 20);
end
update [AsyncExecResults] set
[start_time] = #starttime
, [finish_time] = #finishTime
, [error_number] = #execErrorNumber
, [error_message] = #execErrorMessage
where [token] = #token;
if (0 = ##ROWCOUNT)
begin
raiserror(N'Internal consistency error: token not found', 16, 30);
end
end conversation #h;
end
else if (#messageTypeName = N'http://schemas.microsoft.com/SQL/ServiceBroker/EndDialog')
begin
end conversation #h;
end
else if (#messageTypeName = N'http://schemas.microsoft.com/SQL/ServiceBroker/Error')
begin
declare #errorNumber int
, #errorMessage nvarchar(4000);
select #xmlBody = CAST(#messageBody as xml);
with xmlnamespaces (DEFAULT N'http://schemas.microsoft.com/SQL/ServiceBroker/Error')
select #errorNumber = #xmlBody.value ('(/Error/Code)[1]', 'INT'),
#errorMessage = #xmlBody.value ('(/Error/Description)[1]', 'NVARCHAR(4000)');
-- Update the request with the received error
select #token = [conversation_id]
from sys.conversation_endpoints
where [conversation_handle] = #h;
update [AsyncExecResults] set
[error_number] = #errorNumber
, [error_message] = #errorMessage
where [token] = #token;
end conversation #h;
end
else
begin
raiserror(N'Received unexpected message type: %s', 16, 50, #messageTypeName);
end
end
commit;
end try
begin catch
declare #error int
, #message nvarchar(2048);
select #error = ERROR_NUMBER()
, #message = ERROR_MESSAGE()
, #xactState = XACT_STATE();
if (#xactState <> 0)
begin
rollback;
end;
update dbo.Configurations with (serializable)
set conf_value = 0
where sp_name = #procedureName
raiserror(N'Error: %i, %s', 1, 60, #error, #message) with log;
end catch
update dbo.Configurations with (serializable) set conf_value = 0
where sp_name = #procedureName
end
I have to do this:
update dbo.Configurations with (serializable)
set conf_value = 0
where sp_name = #procedureName
Every time before stored procedure ends. I'll check dbo.Configurations to see if usp_AsyncExecActivated is running or not.
Do I have to add that update on CATCH BLOCK and after the CATCH BLOCK?
I'm not sure if after catch block runs anything else or it ends stored procedure execution.
It depends on severity, if there's a session sborting error it will stop executing the procedure. Otherwise, it will continue after CATCH block. See this simplified example:
create proc x
as
begin try
select 1/0
end try
begin catch
select error_message()
raiserror (N'Received unexpected message type', 16, 50);
end catch
select 'after catch'
go
exec x;
I'm trying to execute a sproc but I'm not sure if I'm going in the right direction. When my IF conditions are true it will not print my raiseerrors...
set transaction isolation level repeatable read
declare #return_value int = 0
declare #someValue int = 3
SET #retry = 3;
--Keep trying to update
--table if this task is
--selected as the deadlock
--victim.
WHILE (#retry > 0)
BEGIN
BEGIN TRY
BEGIN TRANSACTION;
--check someValue
if #someValue < 5
begin
raiserror ('number is less than 5', 16,1)
ROLLBACK TRANSACTION
return 99
end
--all o.k , set retry 0 ending the while, commit transaction--
SET #retry = 0;
COMMIT TRANSACTION;
END TRY
BEGIN CATCH
RAISERROR ('Errors found, please fix these errors and retry. Transaction Rolled back', 16, 2);
-- Check error number.
-- If deadlock victim error,
-- then reduce retry count
-- for next update retry.
-- If some other error
-- occurred, then exit
-- retry WHILE loop.
IF (ERROR_NUMBER() = 1205)
SET #retry = #retry - 1;
ELSE
SET #retry = -1;
IF XACT_STATE() <> 0
ROLLBACK TRANSACTION;
END CATCH;
END; -- End WHILE loop.
The first RaIsError will be consumed by the catch block. If you want to preserve it, and perhaps add additional information, you can do something like this:
set xact_abort, nocount on;
set transaction isolation level repeatable read; -- Scope is this stored procedure.
declare #LocalTransaction as Bit = case when ##TranCount = 0 then 1 else 0 end;
declare #Return_Value as Int = 0;
declare #SomeValue int = 3;
declare #Retry as Int = 3;
while #Retry > 0
begin
begin try
if #LocalTransaction = 1
begin transaction;
if #SomeValue < 5
RaIsError ( 'Number is less than 5.', 16, 1 );
set #Retry = 0;
if #LocalTransaction = 1
commit transaction;
end try
begin catch
if Error_Number() = 1205
set #Retry -= 1;
else
begin
set #Retry = -1;
-- Save the exception.
declare #ErrorLine as Int = Error_Line();
declare #ErrorMessage as NVarChar(4000) = Error_Message();
declare #ErrorNumber as Int = Error_Number();
declare #ErrorProcedure as NVarChar(126) = Error_Procedure();
declare #ErrorSeverity as Int = Error_Severity();
declare #ErrorState as Int = Error_State();
declare #NewLine as Char(2) = Char( 13 ) + Char( 10 ); -- '\r\n'.
-- Rollback only transactions when there is an active transaction that we started.
if Xact_State() <> 0 and #LocalTransaction = 1
rollback transaction;
-- Exit with the exception.
RaIsError( '%s%s#%i [Proc: %s/Line %i]', #ErrorSeverity, #ErrorState, #ErrorMessage, #NewLine, #ErrorNumber, #ErrorProcedure, #ErrorLine );
return 99;
end;
end catch;
end;
Note that the error return is also handled by the catch block since code in the try block after the RaIsError shouldn't execute.