wie man dieselbe Ausnahme in SQL Server erneut auslöst

Ich möchte dieselbe Ausnahme in SQL Server erneut auslösen, die in meinem Try-Block aufgetreten ist. Ich kann dieselbe Nachricht senden, aber ich möchte denselben Fehler auslösen.

BEGIN TRANSACTION
    BEGIN TRY
            INSERT INTO Tags.tblDomain 
            (DomainName, SubDomainId, DomainCode, Description)
            VALUES(@DomainName, @SubDomainId, @DomainCode, @Description)
            COMMIT TRANSACTION
    END TRY

    BEGIN CATCH
            declare @severity int; 
            declare @state int;

            select @severity=error_severity(), @state=error_state();

            RAISERROR(@@Error,@ErrorSeverity,@state);
            ROLLBACK TRANSACTION
    END CATCH

RAISERROR(@@Error, @ErrorSeverity, @state);

Diese Zeile zeigt Fehler, aber ich möchte Funktionalität so etwas. Dies löst einen Fehler mit der Fehlernummer 50000 aus, aber ich möchte, dass eine Fehlernummer ausgegeben wird, die ich übergebe @@error.

Ich möchte diesen Fehler nicht im Frontend erfassen

dh

catch (SqlException ex)
{
if ex.number==2627
MessageBox.show("Duplicate value cannot be inserted");
}

Ich möchte diese Funktionalität. was mit Raiseerror nicht erreicht werden kann. Ich möchte keine benutzerdefinierte Fehlermeldung am Backend geben.

RAISEERROR sollte den unten genannten Fehler zurückgeben, wenn ich ErrorNo übergebe, um in catch geworfen zu werden

Msg 2627, Level 14, State 1, Procedure spOTest_DomainInsert,

Zeile 14 Verletzung der UNIQUE KEY-Einschränkung 'UK_DomainCode'. Es kann kein doppelter Schlüssel in das Objekt 'Tags.tblDomain' eingefügt werden. Die Anweisung wurde beendet.

BEARBEITEN:

Was kann der Nachteil sein, wenn der try catch-Block nicht verwendet wird, wenn eine Ausnahme im Frontend behandelt werden soll, wenn die gespeicherte Prozedur mehrere Abfragen enthält, die ausgeführt werden müssen

Hier ist ein voll funktionsfähiges Beispiel für einen sauberen Code, mit dem eine Reihe von Anweisungen zurückgesetzt werden können, wenn ein Fehler auftritt, und die Fehlermeldung gemeldet wird.

begin try
    begin transaction;

    ...

    commit transaction;
end try
begin catch
    if @@trancount > 0 rollback transaction;
    throw;
end catch

Vor SQL 2012

begin try
    begin transaction;
    
    ...
    
    commit transaction;
end try
begin catch
    declare @ErrorMessage nvarchar(max), @ErrorSeverity int, @ErrorState int;
    select @ErrorMessage = ERROR_MESSAGE() + ' Line ' + cast(ERROR_LINE() as nvarchar(5)), @ErrorSeverity = ERROR_SEVERITY(), @ErrorState = ERROR_STATE();
    if @@trancount > 0 rollback transaction;
    raiserror (@ErrorMessage, @ErrorSeverity, @ErrorState);
end catch

SQL 2012 führt die throw-Anweisung ein:

http://msdn.microsoft.com/en-us/library/ee677615.aspx

Wenn die THROW-Anweisung ohne Parameter angegeben wird, muss sie in einem CATCH-Block erscheinen. Dadurch wird die abgefangene Ausnahme ausgelöst.

BEGIN TRY
    BEGIN TRANSACTION
    ...
    COMMIT TRANSACTION
END TRY
BEGIN CATCH
    ROLLBACK TRANSACTION;
    THROW
END CATCH

Erneutes Werfen innerhalb des CATCH-Blocks (Code vor SQL2012, verwenden Sie die Anweisung THROW für SQL2012 und höher):

DECLARE
    @ErrorMessage nvarchar(4000) = ERROR_MESSAGE(),
    @ErrorNumber int = ERROR_NUMBER(),
    @ErrorSeverity int = ERROR_SEVERITY(),
    @ErrorState int = ERROR_STATE(),
    @ErrorLine int = ERROR_LINE(),
    @ErrorProcedure nvarchar(200) = ISNULL(ERROR_PROCEDURE(), '-');
SELECT @ErrorMessage = N'Error %d, Level %d, State %d, Procedure %s, Line %d, ' + 'Message: ' + @ErrorMessage;
RAISERROR (@ErrorMessage, @ErrorSeverity, 1, @ErrorNumber, @ErrorSeverity, @ErrorState, @ErrorProcedure, @ErrorLine)

Ich denke, Ihre Entscheidungen sind:

• Den Fehler nicht abfangen (sprudeln lassen)
• Erhöhen Sie eine benutzerdefinierte

Irgendwann wird SQL wahrscheinlich einen Reraise-Befehl einführen oder nur bestimmte Fehler abfangen. Verwenden Sie vorerst eine Problemumgehung. Es tut uns leid.

Sie können nicht: Nur die Engine kann Fehler unter 50000 auslösen. Sie können lediglich eine Ausnahme auslösen, die so aussieht ...

Siehe meine Antwort hier bitte

Der Fragesteller hier hat clientseitige Transaktionen verwendet, um das zu tun, was er wollte, was ich für ein bisschen albern halte ...

Ok, das ist eine Problemumgehung ... :-)

DECLARE @Error_Number INT
BEGIN TRANSACTION 
    BEGIN TRY
    INSERT INTO Test(Id, Name) VALUES (newID(),'Ashish') 
    /* Column 'Name' has unique constraint on it*/
    END TRY
    BEGIN CATCH

            SELECT ERROR_NUMBER()
            --RAISERROR (@ErrorMessage,@Severity,@State)
            ROLLBACK TRAN
    END CATCH

Wenn Sie den catch-Block notieren, wird der Fehler nicht ausgelöst, sondern die tatsächliche Fehlernummer zurückgegeben (und die Transaktion wird ebenfalls zurückgesetzt). Wenn Sie jetzt in Ihrem .NET-Code die Ausnahme abfangen und ExecuteScalar () verwenden, erhalten Sie die gewünschte tatsächliche Fehlernummer und zeigen die entsprechende Nummer an.

int errorNumber=(int)command.ExecuteScalar();
if(errorNumber=<SomeNumber>)
{
    MessageBox.Show("Some message");
}

Hoffe das hilft,

BEARBEITEN: - Nur ein Hinweis: Wenn Sie die Anzahl der betroffenen Datensätze ermitteln und versuchen möchten, ExecuteNonQuery zu verwenden, funktioniert die oben genannte Lösung möglicherweise nicht für Sie. Ansonsten denke ich, es würde passen, was Sie brauchen. Gib mir Bescheid.

Die Möglichkeit, die Ausführung in einer gespeicherten Prozedur zu stoppen, nachdem ein Fehler aufgetreten ist, und den Fehler an das aufrufende Programm zurückzusenden, besteht darin, jeder Anweisung zu folgen, die einen Fehler mit diesem Code auslösen könnte:

If @@ERROR > 0
Return

Ich war selbst überrascht, als ich herausfand, dass die Ausführung in einer gespeicherten Prozedur nach einem Fehler fortgesetzt werden kann. Wenn Sie dies nicht bemerken, kann dies zu schwer auffindbaren Fehlern führen.

Diese Art der Fehlerbehandlung Parallelen (vor .Net) Visual Basic 6. Wir freuen uns auf den Befehl Throw in SQL Server 2012.

Da Sie noch nicht zu 2012 gewechselt sind, besteht eine Möglichkeit, das Sprudeln des ursprünglichen Fehlercodes zu implementieren, darin, den Textnachrichtenteil der Ausnahme zu verwenden, die Sie aus dem catch-Block (erneut) auslösen. Denken Sie daran, dass es eine Struktur enthalten kann, z. B. XML-Text, den Ihr Aufrufercode in seinem catch-Block analysieren kann.

Sie können auch eine Wrapper-gespeicherte Prozedur für diese Szenarien erstellen, wenn die SQL-Anweisung innerhalb der Transaktion ausgeführt werden soll, und den Fehler an Ihren Code weiterleiten.

CREATE PROCEDURE usp_Execute_SQL_Within_Transaction
(
    @SQL nvarchar(max)
)
AS

SET NOCOUNT ON

BEGIN TRY
    BEGIN TRANSACTION
        EXEC(@SQL)
    COMMIT TRANSACTION
END TRY

BEGIN CATCH
    DECLARE @ErrorMessage nvarchar(max), @ErrorSeverity int, @ErrorState int
    SELECT @ErrorMessage = N'Error Number: ' + CONVERT(nvarchar(5), ERROR_NUMBER()) + N'. ' + ERROR_MESSAGE() + ' Line ' + CONVERT(nvarchar(5), ERROR_LINE()), @ErrorSeverity = ERROR_SEVERITY(), @ErrorState = ERROR_STATE()
    ROLLBACK TRANSACTION
    RAISERROR (@ErrorMessage, @ErrorSeverity, @ErrorState)
END CATCH

GO

-- Test it
EXEC usp_Execute_SQL_Within_Transaction @SQL = 'SELECT 1; SELECT 2'
EXEC usp_Execute_SQL_Within_Transaction @SQL = 'SELECT 1/0; SELECT 2'
EXEC usp_Execute_SQL_Within_Transaction @SQL = 'EXEC usp_Another_SP'

Was bringt es aus gestalterischer Sicht, Ausnahmen mit ursprünglichen Fehlernummern und benutzerdefinierten Meldungen auszulösen? Bis zu einem gewissen Grad bricht es den Schnittstellenvertrag zwischen Anwendungen und der Datenbank. Wenn Sie Originalfehler abfangen und in höherem Code behandeln möchten, behandeln Sie sie nicht in der Datenbank. Wenn Sie dann eine Ausnahme abfangen, können Sie die dem Benutzer präsentierte Nachricht in eine beliebige Nachricht ändern. Ich würde es aber nicht tun, weil es Ihren Datenbankcode hmm 'nicht richtig' macht. Wie andere sagten, sollten Sie einen Satz Ihrer eigenen Fehlercodes (über 50000) definieren und diese stattdessen auslösen. Anschließend können Sie Integritätsprobleme ("Doppelte Werte sind nicht zulässig") getrennt von potenziellen geschäftlichen Problemen behandeln - "Postleitzahl ist ungültig", "Es wurden keine Zeilen gefunden, die den Kriterien entsprechen" usw.