TRY...CATCH (Transact-SQL)TRY...CATCH (Transact-SQL)

Dieses Thema gilt für: JaSQL Server (ab 2008)JaAzure SQL-DatenbankJaAzure SQL Data Warehouse Ja Parallel Datawarehouse THIS TOPIC APPLIES TO: yesSQL Server (starting with 2008)yesAzure SQL DatabaseyesAzure SQL Data Warehouse yesParallel Data Warehouse

Implementiert die Fehlerbehandlung für Transact-SQLTransact-SQL, die Ähnlichkeiten mit der Ausnahmebehandlung in den Sprachen MicrosoftMicrosoft Visual C# und MicrosoftMicrosoft Visual C++ hat.Implements error handling for Transact-SQLTransact-SQL that is similar to the exception handling in the MicrosoftMicrosoft Visual C# and MicrosoftMicrosoft Visual C++ languages. Eine Gruppe von Transact-SQLTransact-SQL-Anweisungen kann in einen TRY-Block eingeschlossen werden.A group of Transact-SQLTransact-SQL statements can be enclosed in a TRY block. Wenn innerhalb des TRY-Blocks ein Fehler auftritt, wird die Steuerung an eine andere Gruppe von Anweisungen innerhalb eines CATCH-Blocks übergeben.If an error occurs in the TRY block, control is passed to another group of statements that is enclosed in a CATCH block.

Themenlinksymbol Transact-SQL Syntax Conventions (Transact-SQL-Syntaxkonventionen)Topic link icon Transact-SQL Syntax Conventions

SyntaxSyntax

BEGIN TRY  
     { sql_statement | statement_block }  
END TRY  
BEGIN CATCH  
     [ { sql_statement | statement_block } ]  
END CATCH  
[ ; ]  

ArgumenteArguments

sql_statementsql_statement
Eine beliebige Transact-SQLTransact-SQL-Anweisung.Is any Transact-SQLTransact-SQL statement.

statement_blockstatement_block
Eine beliebige Gruppe von Transact-SQLTransact-SQL-Anweisungen in einem Batch oder in einem BEGIN…END-Block.Any group of Transact-SQLTransact-SQL statements in a batch or enclosed in a BEGIN…END block.

RemarksRemarks

Ein TRY…CATCH-Konstrukt fängt alle Ausführungsfehler ab, deren Schweregrad größer als 10 ist und durch die die Datenbankverbindung nicht geschlossen wird.A TRY…CATCH construct catches all execution errors that have a severity higher than 10 that do not close the database connection.

Auf einen TRY-Block muss direkt ein dazugehöriger CATCH-Block folgen.A TRY block must be immediately followed by an associated CATCH block. Werden andere Anweisungen zwischen die END TRY- und BEGIN CATCH-Anweisungen eingeschlossen, wird dadurch ein Syntaxfehler generiert.Including any other statements between the END TRY and BEGIN CATCH statements generates a syntax error.

Ein TRY…CATCH-Konstrukt darf sich nicht über mehrere Batches erstrecken.A TRY…CATCH construct cannot span multiple batches. Ein TRY…CATCH-Konstrukt darf sich nicht über mehrere Blöcke von Transact-SQLTransact-SQL-Anweisungen erstrecken.A TRY…CATCH construct cannot span multiple blocks of Transact-SQLTransact-SQL statements. So darf sich ein TRY…CATCH-Konstrukt beispielsweise nicht über zwei BEGIN…END-Blöcke von Transact-SQLTransact-SQL-Anweisungen und nicht über ein IF…ELSE-Konstrukt erstrecken.For example, a TRY…CATCH construct cannot span two BEGIN…END blocks of Transact-SQLTransact-SQL statements and cannot span an IF…ELSE construct.

Ist der Code in einem TRY-Block fehlerfrei, wird nach Abschluss der letzten Anweisung im TRY-Block die Steuerung an die Anweisung übergeben, die direkt auf die dazugehörige END CATCH-Anweisung folgt.If there are no errors in the code that is enclosed in a TRY block, when the last statement in the TRY block has finished running, control passes to the statement immediately after the associated END CATCH statement. Enthält der in einen TRY-Block eingeschlossene Code einen Fehler, wird die Steuerung an die erste Anweisung im dazugehörigen CATCH-Block übergeben.If there is an error in the code that is enclosed in a TRY block, control passes to the first statement in the associated CATCH block. Ist die END CATCH-Anweisung die letzte Anweisung in einer gespeicherten Prozedur oder in einem Trigger, wird die Steuerung wieder an die Anweisung zurückgegeben, die die gespeicherte Prozedur aufgerufen bzw. den Trigger ausgelöst hat.If the END CATCH statement is the last statement in a stored procedure or trigger, control is passed back to the statement that called the stored procedure or fired the trigger.

Wenn die Ausführung des Codes im CATCH-Block abgeschlossen ist, wird die Steuerung an die Anweisung übergeben, die direkt auf die END CATCH-Anweisung folgt.When the code in the CATCH block finishes, control passes to the statement immediately after the END CATCH statement. Fehler, die von einem CATCH-Block aufgefangen werden, werden nicht an die aufrufende Anwendung zurückgegeben.Errors trapped by a CATCH block are not returned to the calling application. Falls Fehlerinformationen an die Anwendung zurückgegeben werden sollen, müssen im Code im CATCH-Block bestimmte Mechanismen dafür verwendet werden, z. B. SELECT-Resultsets oder die RAISERROR-Anweisung und die PRINT-Anweisung.If any part of the error information must be returned to the application, the code in the CATCH block must do so by using mechanisms such as SELECT result sets or the RAISERROR and PRINT statements.

TRY…CATCH-Konstrukte können geschachtelt werden.TRY…CATCH constructs can be nested. Entweder ein TRY-Block oder ein CATCH-Block kann geschachtelte TRY…CATCH-Konstrukte enthalten.Either a TRY block or a CATCH block can contain nested TRY…CATCH constructs. So kann beispielsweise ein CATCH-Block ein eingebettetes TRY…CATCH-Konstrukt enthalten, das Fehler behandelt, die vom CATCH-Code festgestellt werden.For example, a CATCH block can contain an embedded TRY…CATCH construct to handle errors encountered by the CATCH code.

Fehler, die in einem CATCH-Block festgestellt werden, werden wie alle anderen Fehler behandelt.Errors encountered in a CATCH block are treated like errors generated anywhere else. Wenn der CATCH-Block ein geschachteltes TRY…CATCH-Konstrukt enthält, wird bei jedem Fehler im geschachtelten TRY-Block die Steuerung an den geschachtelten CATCH-Block übergeben.If the CATCH block contains a nested TRY…CATCH construct, any error in the nested TRY block will pass control to the nested CATCH block. Ist kein geschachteltes TRY…CATCH-Konstrukt vorhanden, wird der Fehler an den Aufrufer zurückgegeben.If there is no nested TRY…CATCH construct, the error is passed back to the caller.

TRY…CATCH-Konstrukte können nicht behandelte Fehler aus gespeicherten Prozeduren oder Triggern auffangen, die mit dem Code im TRY-Block ausgeführt werden.TRY…CATCH constructs catch unhandled errors from stored procedures or triggers executed by the code in the TRY block. Alternativ dazu können die gespeicherten Prozeduren oder Trigger eigene TRY…CATCH-Konstrukte enthalten, die vom Code generierte Fehler behandeln.Alternatively, the stored procedures or triggers can contain their own TRY…CATCH constructs to handle errors generated by their code. Wenn beispielsweise ein TRY-Block eine gespeicherte Prozedur ausführt und in dieser ein Fehler auftritt, dann gibt es folgende Möglichkeiten für die Behandlung des Fehlers:For example, when a TRY block executes a stored procedure and an error occurs in the stored procedure, the error can be handled in the following ways:

  • Wenn die gespeicherte Prozedur kein eigenes TRY…CATCH-Konstrukt enthält, übergibt der Fehler die Steuerung an den CATCH-Block, der mit dem TRY-Block verknüpft ist, der die EXECUTE-Anweisung enthält.If the stored procedure does not contain its own TRY…CATCH construct, the error returns control to the CATCH block associated with the TRY block that contains the EXECUTE statement.

  • Wenn die gespeicherte Prozedur ein TRY…CATCH-Konstrukt enthält, übergibt der Fehler die Steuerung an den CATCH-Block in der gespeicherten Prozedur.If the stored procedure contains a TRY…CATCH construct, the error transfers control to the CATCH block in the stored procedure. Wenn die Ausführung des Codes im CATCH-Block abgeschlossen ist, wird die Steuerung an die Anweisung zurückgegeben, die direkt auf die EXECUTE-Anweisung folgt, von der die gespeicherte Prozedur aufgerufen wurde.When the CATCH block code finishes, control is passed back to the statement immediately after the EXECUTE statement that called the stored procedure.

    GOTO-Anweisungen können nicht verwendet werden, um einen TRY- oder CATCH-Block einzugeben.GOTO statements cannot be used to enter a TRY or CATCH block. GOTO-Anweisungen können verwendet werden, um innerhalb eines TRY- oder CATCH-Blocks zu einer Marke zu springen oder um einen TRY- oder CATCH-Block zu verlassen.GOTO statements can be used to jump to a label inside the same TRY or CATCH block or to leave a TRY or CATCH block.

    Das TRY…CATCH-Konstrukt kann nicht in einer benutzerdefinierten Funktion verwendet werden.The TRY…CATCH construct cannot be used in a user-defined function.

Abrufen von FehlerinformationenRetrieving Error Information

Im Bereich eines CATCH-Blocks können folgende Systemfunktionen verwendet werden, um Informationen zu dem Fehler abzurufen, der zur Ausführung des CATCH-Blocks geführt hat:In the scope of a CATCH block, the following system functions can be used to obtain information about the error that caused the CATCH block to be executed:

  • ERROR_NUMBER() gibt die Fehlernummer zurück.ERROR_NUMBER() returns the number of the error.

  • ERROR_SEVERITY() gibt den Schweregrad zurück.ERROR_SEVERITY() returns the severity.

  • ERROR_STATE() gibt die Fehlerzustandsnummer zurück.ERROR_STATE() returns the error state number.

  • ERROR_PROCEDURE() gibt den Namen der gespeicherten Prozedur oder des Triggers zurück, in der bzw. in dem der Fehler aufgetreten ist.ERROR_PROCEDURE() returns the name of the stored procedure or trigger where the error occurred.

  • ERROR_LINE() gibt die Zeilennummer in der Routine zurück, die den Fehler verursacht hat.ERROR_LINE() returns the line number inside the routine that caused the error.

  • ERROR_MESSAGE() gibt den gesamten Text der Fehlermeldung zurück.ERROR_MESSAGE() returns the complete text of the error message. Der Text umfasst die Werte, die für alle ersetzbaren Parameter angegeben werden, wie z. B. Längen, Objektnamen oder Zeitangaben.The text includes the values supplied for any substitutable parameters, such as lengths, object names, or times.

    Diese Funktionen geben NULL zurück, wenn sie außerhalb des Bereichs eines CATCH-Blocks aufgerufen werden.These functions return NULL if they are called outside the scope of the CATCH block. Fehlerinformationen können mithilfe dieser Funktionen an beliebiger Stelle im Bereich des CATCH-Blocks abgerufen werden.Error information can be retrieved by using these functions from anywhere within the scope of the CATCH block. Das folgende Skript zeigt beispielsweise eine gespeicherte Prozedur, die Fehlerbehandlungsfunktionen umfasst.For example, the following script shows a stored procedure that contains error-handling functions. Im CATCH-Block eines TRY…CATCH-Konstrukts wird die gespeicherte Prozedur aufgerufen, und Informationen zum Fehler werden zurückgegeben.In the CATCH block of a TRY…CATCH construct, the stored procedure is called and information about the error is returned.

-- Verify that the stored procedure does not already exist.  
IF OBJECT_ID ( 'usp_GetErrorInfo', 'P' ) IS NOT NULL   
    DROP PROCEDURE usp_GetErrorInfo;  
GO  

-- Create procedure to retrieve error information.  
CREATE PROCEDURE usp_GetErrorInfo  
AS  
SELECT  
    ERROR_NUMBER() AS ErrorNumber  
    ,ERROR_SEVERITY() AS ErrorSeverity  
    ,ERROR_STATE() AS ErrorState  
    ,ERROR_PROCEDURE() AS ErrorProcedure  
    ,ERROR_LINE() AS ErrorLine  
    ,ERROR_MESSAGE() AS ErrorMessage;  
GO  

BEGIN TRY  
    -- Generate divide-by-zero error.  
    SELECT 1/0;  
END TRY  
BEGIN CATCH  
    -- Execute error retrieval routine.  
    EXECUTE usp_GetErrorInfo;  
END CATCH;   

Die ERROR_*-Funktionen können auch in einem CATCH-Block in einer nativ kompilierten gespeicherten Prozedur ausgeführt werden.The ERROR_* functions also work in a CATCH block inside a natively compiled stored procedure.

Fehler, auf die sich ein TRY…CATCH-Konstrukt nicht auswirktErrors Unaffected by a TRY…CATCH Construct

TRY…CATCH-Konstrukte fangen folgende Bedingungen nicht auf:TRY…CATCH constructs do not trap the following conditions:

  • Warnungen oder Informationsmeldungen mit einem Schweregrad von 10 oder niedriger.Warnings or informational messages that have a severity of 10 or lower.

  • Fehler mit einem Schweregrad von 20 oder höher, die dazu führen, dass die Verarbeitung des SQL Server-DatenbankmodulSQL Server Database Engine-Tasks für die Sitzung beendet wird.Errors that have a severity of 20 or higher that stop the SQL Server-DatenbankmodulSQL Server Database Engine task processing for the session. Wenn ein Fehler mit einem Schweregrad von 20 oder höher auftritt und die Datenbankverbindung nicht unterbrochen wird, wird der Fehler durch TRY…CATCH behandelt.If an error occurs that has severity of 20 or higher and the database connection is not disrupted, TRY…CATCH will handle the error.

  • Warnungen, z. B. Clientunterbrechungsanforderungen oder unterbrochene Clientverbindungen.Attentions, such as client-interrupt requests or broken client connections.

  • Wenn die Sitzung von einem Systemadministrator mit der KILL-Anweisung beendet wird.When the session is ended by a system administrator by using the KILL statement.

    Die folgenden Fehlertypen werden von einem CATCH-Block nicht behandelt, wenn sie auf der gleichen Ausführungsebene wie das TRY…CATCH-Konstrukt auftreten:The following types of errors are not handled by a CATCH block when they occur at the same level of execution as the TRY…CATCH construct:

  • Kompilierungsfehler, z. B. Syntaxfehler, die die Ausführung eines Batches verhindern.Compile errors, such as syntax errors, that prevent a batch from running.

  • Fehler, die bei der Neukompilierung auf Anweisungsebene auftreten, beispielsweise Fehler bei der Objektnamensauflösung, die aufgrund einer verzögerten Namensauflösung nach der Kompilierung auftreten.Errors that occur during statement-level recompilation, such as object name resolution errors that occur after compilation because of deferred name resolution.

    Diese Fehler werden auf die Ebene zurückgegeben, auf der der Batch, die gespeicherte Prozedur oder der Trigger ausgeführt wurden.These errors are returned to the level that ran the batch, stored procedure, or trigger.

    Tritt ein Fehler bei der Kompilierung oder Neukompilierung auf Anweisungsebene auf einer niedrigeren Ausführungsebene (z. B. bei Ausführung von sp_executesql oder einer benutzerdefinierten gespeicherten Prozedur) innerhalb des TRY-Blocks auf, befindet sich der Fehler auf einer niedrigeren Ebene als das TRY…CATCH-Konstrukt und wird vom dazugehörigen CATCH-Block behandelt.If an error occurs during compilation or statement-level recompilation at a lower execution level (for example, when executing sp_executesql or a user-defined stored procedure) inside the TRY block, the error occurs at a lower level than the TRY…CATCH construct and will be handled by the associated CATCH block.

    Das folgende Beispiel zeigt, wie ein Fehler bei der Objektnamensauflösung, der von einer SELECT-Anweisung generiert wurde, nicht vom TRY…CATCH-Konstrukt erfasst wurde. Er wird jedoch vom CATCH-Block erfasst, wenn dieselbe SELECT-Anweisung innerhalb einer gespeicherten Prozedur ausgeführt wird.The following example shows how an object name resolution error generated by a SELECT statement is not caught by the TRY…CATCH construct, but is caught by the CATCH block when the same SELECT statement is executed inside a stored procedure.

BEGIN TRY  
    -- Table does not exist; object name resolution  
    -- error not caught.  
    SELECT * FROM NonexistentTable;  
END TRY  
BEGIN CATCH  
    SELECT   
        ERROR_NUMBER() AS ErrorNumber  
       ,ERROR_MESSAGE() AS ErrorMessage;  
END CATCH  

Der Fehler wird nicht erfasst, und die Steuerung wird vom TRY…CATCH-Konstrukt an die nächsthöhere Ebene weitergegeben.The error is not caught and control passes out of the TRY…CATCH construct to the next higher level.

Das Ausführen der SELECT-Anweisung innerhalb einer gespeicherten Prozedur führt dazu, dass der Fehler auf einer Ebene unter dem TRY-Block auftritt.Running the SELECT statement inside a stored procedure will cause the error to occur at a level lower than the TRY block. Der Fehler wird vom TRY…CATCH-Konstrukt behandelt.The error will be handled by the TRY…CATCH construct.

-- Verify that the stored procedure does not exist.  
IF OBJECT_ID ( N'usp_ExampleProc', N'P' ) IS NOT NULL   
    DROP PROCEDURE usp_ExampleProc;  
GO  

-- Create a stored procedure that will cause an   
-- object resolution error.  
CREATE PROCEDURE usp_ExampleProc  
AS  
    SELECT * FROM NonexistentTable;  
GO  

BEGIN TRY  
    EXECUTE usp_ExampleProc;  
END TRY  
BEGIN CATCH  
    SELECT   
        ERROR_NUMBER() AS ErrorNumber  
        ,ERROR_MESSAGE() AS ErrorMessage;  
END CATCH;  

Nicht commitfähige Transaktionen und XACT_STATEUncommittable Transactions and XACT_STATE

Wenn ein Fehler, der in einem TRY-Block generiert wurde, dazu führt, dass der Status der aktuellen Transaktion ungültig wird, dann wird die Transaktion als nicht commitfähige Transaktion klassifiziert.If an error generated in a TRY block causes the state of the current transaction to be invalidated, the transaction is classified as an uncommittable transaction. Ein Fehler, der außerhalb eines TRY-Blocks normalerweise zur Beendigung einer Transaktion führt, hat bei Auftreten innerhalb eines TRY-Blocks zur Folge, dass eine Transaktion zu einer nicht commitfähigen Transaktion wird.An error that ordinarily ends a transaction outside a TRY block causes a transaction to enter an uncommittable state when the error occurs inside a TRY block. Eine nicht commitfähige Transaktion kann nur Leseoperationen oder ROLLBACK TRANSACTION durchführen.An uncommittable transaction can only perform read operations or a ROLLBACK TRANSACTION. Die Transaktion kann keine Transact-SQLTransact-SQL-Anweisungen ausführen, die eine Schreiboperation oder COMMIT TRANSACTION generieren.The transaction cannot execute any Transact-SQLTransact-SQL statements that would generate a write operation or a COMMIT TRANSACTION. Die XACT_STATE-Funktion gibt den Wert -1 zurück, wenn eine Transaktion als nicht commitfähige Transaktion klassifiziert wurde.The XACT_STATE function returns a value of -1 if a transaction has been classified as an uncommittable transaction. Nach Abschluss einer Batchausführung wird für alle aktiven nicht commitfähigen Transaktionen von DatenbankmodulDatabase Engine ein Rollback ausgeführt.When a batch finishes, the DatenbankmodulDatabase Engine rolls back any active uncommittable transactions. Falls keine Fehlermeldung gesendet wurde, als die Transaktion in den nicht commitfähigen Status überging, wird bei Abschluss des Batches eine Fehlermeldung an die Clientanwendung gesendet.If no error message was sent when the transaction entered an uncommittable state, when the batch finishes, an error message will be sent to the client application. Auf diese Weise wird angezeigt, dass eine nicht commitfähige Transaktion erkannt und ein Rollback für sie ausgeführt wurde.This indicates that an uncommittable transaction was detected and rolled back.

Weitere Informationen zu nicht commitfähigen Transaktionen und zur XACT_STATE-Funktion finden Sie unter XACT_STATE (Transact-SQL).For more information about uncommittable transactions and the XACT_STATE function, see XACT_STATE (Transact-SQL).

BeispieleExamples

A.A. Verwenden von TRY…CATCHUsing TRY…CATCH

Das folgende Beispiel zeigt eine SELECT-Anweisung, die einen Fehler aufgrund einer Division durch 0 (null) generiert.The following example shows a SELECT statement that will generate a divide-by-zero error. Der Fehler führt dazu, dass die Ausführung zum dazugehörigen CATCH-Block wechselt.The error causes execution to jump to the associated CATCH block.

BEGIN TRY  
    -- Generate a divide-by-zero error.  
    SELECT 1/0;  
END TRY  
BEGIN CATCH  
    SELECT  
        ERROR_NUMBER() AS ErrorNumber  
        ,ERROR_SEVERITY() AS ErrorSeverity  
        ,ERROR_STATE() AS ErrorState  
        ,ERROR_PROCEDURE() AS ErrorProcedure  
        ,ERROR_LINE() AS ErrorLine  
        ,ERROR_MESSAGE() AS ErrorMessage;  
END CATCH;  
GO  

B.B. Verwenden von TRY…CATCH in einer TransaktionUsing TRY…CATCH in a transaction

Das folgende Beispiel zeigt die Funktionsweise eines TRY…CATCH-Blocks innerhalb einer Transaktion.The following example shows how a TRY…CATCH block works inside a transaction. Die Anweisung innerhalb des TRY-Blocks generiert einen Fehler aufgrund einer Einschränkungsverletzung.The statement inside the TRY block generates a constraint violation error.

BEGIN TRANSACTION;  

BEGIN TRY  
    -- Generate a constraint violation error.  
    DELETE FROM Production.Product  
    WHERE ProductID = 980;  
END TRY  
BEGIN CATCH  
    SELECT   
        ERROR_NUMBER() AS ErrorNumber  
        ,ERROR_SEVERITY() AS ErrorSeverity  
        ,ERROR_STATE() AS ErrorState  
        ,ERROR_PROCEDURE() AS ErrorProcedure  
        ,ERROR_LINE() AS ErrorLine  
        ,ERROR_MESSAGE() AS ErrorMessage;  

    IF @@TRANCOUNT > 0  
        ROLLBACK TRANSACTION;  
END CATCH;  

IF @@TRANCOUNT > 0  
    COMMIT TRANSACTION;  
GO  

C.C. Verwenden von TRY…CATCH mit XACT_STATEUsing TRY…CATCH with XACT_STATE

Das folgende Beispiel zeigt, wie das TRY…CATCH-Konstrukt zur Behandlung von Fehlern verwendet wird, die innerhalb einer Transaktion auftreten.The following example shows how to use the TRY…CATCH construct to handle errors that occur inside a transaction. Über die XACT_STATE-Funktion wird bestimmt, ob für die Transaktion ein Commit oder ein Rollback ausgeführt werden soll.The XACT_STATE function determines whether the transaction should be committed or rolled back. In diesem Beispiel hat SET XACT_ABORT den Wert ON.In this example, SET XACT_ABORT is ON. Dies bewirkt, dass die Transaktion nach dem Fehler aufgrund einer Einschränkungsverletzung nicht commitfähig ist.This makes the transaction uncommittable when the constraint violation error occurs.

-- Check to see whether this stored procedure exists.  
IF OBJECT_ID (N'usp_GetErrorInfo', N'P') IS NOT NULL  
    DROP PROCEDURE usp_GetErrorInfo;  
GO  

-- Create procedure to retrieve error information.  
CREATE PROCEDURE usp_GetErrorInfo  
AS  
    SELECT   
         ERROR_NUMBER() AS ErrorNumber  
        ,ERROR_SEVERITY() AS ErrorSeverity  
        ,ERROR_STATE() AS ErrorState  
        ,ERROR_LINE () AS ErrorLine  
        ,ERROR_PROCEDURE() AS ErrorProcedure  
        ,ERROR_MESSAGE() AS ErrorMessage;  
GO  

-- SET XACT_ABORT ON will cause the transaction to be uncommittable  
-- when the constraint violation occurs.   
SET XACT_ABORT ON;  

BEGIN TRY  
    BEGIN TRANSACTION;  
        -- A FOREIGN KEY constraint exists on this table. This   
        -- statement will generate a constraint violation error.  
        DELETE FROM Production.Product  
            WHERE ProductID = 980;  

    -- If the DELETE statement succeeds, commit the transaction.  
    COMMIT TRANSACTION;  
END TRY  
BEGIN CATCH  
    -- Execute error retrieval routine.  
    EXECUTE usp_GetErrorInfo;  

    -- Test XACT_STATE:  
        -- If 1, the transaction is committable.  
        -- If -1, the transaction is uncommittable and should   
        --     be rolled back.  
        -- XACT_STATE = 0 means that there is no transaction and  
        --     a commit or rollback operation would generate an error.  

    -- Test whether the transaction is uncommittable.  
    IF (XACT_STATE()) = -1  
    BEGIN  
        PRINT  
            N'The transaction is in an uncommittable state.' +  
            'Rolling back transaction.'  
        ROLLBACK TRANSACTION;  
    END;  

    -- Test whether the transaction is committable.  
    IF (XACT_STATE()) = 1  
    BEGIN  
        PRINT  
            N'The transaction is committable.' +  
            'Committing transaction.'  
        COMMIT TRANSACTION;     
    END;  
END CATCH;  
GO  

Beispiele: Azure SQL Data WarehouseAzure SQL Data Warehouse und Parallel Data WarehouseParallel Data Warehouse.Examples: Azure SQL Data WarehouseAzure SQL Data Warehouse and Parallel Data WarehouseParallel Data Warehouse

D.D. Verwenden von TRY…CATCHUsing TRY…CATCH

Das folgende Beispiel zeigt eine SELECT-Anweisung, die einen Fehler aufgrund einer Division durch 0 (null) generiert.The following example shows a SELECT statement that will generate a divide-by-zero error. Der Fehler führt dazu, dass die Ausführung zum dazugehörigen CATCH-Block wechselt.The error causes execution to jump to the associated CATCH block.

BEGIN TRY  
    -- Generate a divide-by-zero error.  
    SELECT 1/0;  
END TRY  
BEGIN CATCH  
    SELECT  
        ERROR_NUMBER() AS ErrorNumber  
        ,ERROR_SEVERITY() AS ErrorSeverity  
        ,ERROR_STATE() AS ErrorState  
        ,ERROR_PROCEDURE() AS ErrorProcedure  
        ,ERROR_MESSAGE() AS ErrorMessage;  
END CATCH;  
GO  

Weitere Informationen finden Sie unterSee Also

THROW (Transact-SQL) THROW (Transact-SQL)
Database Engine Error Severities (Schweregrad von Datenbank-Engine-Fehlern) Database Engine Error Severities
ERROR_LINE (Transact-SQL) ERROR_LINE (Transact-SQL)
ERROR_MESSAGE (Transact-SQL) ERROR_MESSAGE (Transact-SQL)
ERROR_NUMBER (Transact-SQL) ERROR_NUMBER (Transact-SQL)
ERROR_PROCEDURE (Transact-SQL) ERROR_PROCEDURE (Transact-SQL)
ERROR_SEVERITY (Transact-SQL) ERROR_SEVERITY (Transact-SQL)
ERROR_STATE (Transact-SQL) ERROR_STATE (Transact-SQL)
RAISERROR (Transact-SQL) RAISERROR (Transact-SQL)
@@ERROR (Transact-SQL) @@ERROR (Transact-SQL)
GOTO (Transact-SQL) GOTO (Transact-SQL)
BEGIN...END (Transact-SQL) BEGIN...END (Transact-SQL)
XACT_STATE (Transact-SQL) XACT_STATE (Transact-SQL)
SET XACT_ABORT (Transact-SQL)SET XACT_ABORT (Transact-SQL)