SAVE TRANSACTION (Transact-SQL)

Artikel
10/16/2024

Gilt für: SQL Server Azure SQL-Datenbank Azure SQL Managed Instance

Legt einen Sicherungspunkt in einer Transaktion fest.

Syntax

SAVE { TRAN | TRANSACTION } { savepoint_name | @savepoint_variable }  
[ ; ]

Argumente

savepoint_name
Dies ist der Name, der dem Sicherungspunkt zugewiesen ist. Sicherungspunktnamen müssen den Regeln für Bezeichner entsprechen, sind jedoch auf 32 Zeichen begrenzt. savepoint_name berücksichtigt immer die Groß-/Kleinschreibung, auch wenn die Instanz von SQL Server nicht zwischen Groß- und Kleinschreibung unterscheidet.

@savepoint_variable
Dies ist der Name einer benutzerdefinierten Variablen, die einen gültigen Sicherungspunktnamen enthält. Die Variable muss mit einem der folgenden Datentypen deklariert werden: char, varchar, nchar oder nvarchar. Es können mehr als 32 Zeichen an die Variable übergeben werden, jedoch werden nur die ersten 32 Zeichen verwendet.

Bemerkungen

Ein Benutzer kann einen Sicherungspunkt oder Marker innerhalb einer Transaktion festlegen. Der Sicherungspunkt definiert die Position, zu der eine Transaktion zurückkehren kann, wenn ein Teil der Transaktion bedingt abgebrochen wird. Falls für eine Transaktion ein Rollback bis zu einem Sicherungspunkt ausgeführt wird, muss sie abgeschlossen werden, bei Bedarf mit weiteren Transact-SQL-Anweisungen und einer COMMIT TRANSACTION-Anweisung. Alternativ dazu muss sie ganz abgebrochen werden, indem ein Rollback der Transaktion zurück zum Anfang ausgeführt wird. Zum Abbrechen der gesamten Transaktion verwenden Sie die Syntax ROLLBACK TRANSACTION transaction_name. Alle Anweisungen oder Prozeduren der Transaktion werden rückgängig gemacht.

Doppelte Sicherungspunktnamen sind in einer Transaktion zulässig. Eine ROLLBACK TRANSACTION-Anweisung, die den Sicherungspunktnamen angibt, führt jedoch nur ein Rollback der Transaktion bis zur letzten SAVE TRANSACTION-Anweisung mit diesem Namen aus.

SAVE TRANSACTION wird nicht in verteilten Transaktionen unterstützt, die explizit mit BEGIN DISTRIBUTED TRANSACTION gestartet wurden oder aus einer lokalen Transaktion stammen.

Wichtig

Mit einer ROLLBACK TRANSACTION-Anweisung, in der savepoint_name angegeben ist, werden alle Sperren freigegeben, die außerhalb des Sicherungspunkts aktiviert werden, mit Ausnahme von Ausweitungen und Konvertierungen. Diese Sperren werden nicht aufgehoben, und sie werden nicht in ihren vorherigen Sperrmodus zurückkonvertiert.

Berechtigungen

Erfordert die Mitgliedschaft in der public-Rolle.

Beispiele

Im folgenden Beispiel wird das Verwenden eines Sicherungspunkts für eine Transaktion zur Ausführung eines Rollbacks nur der Änderungen veranschaulicht, die von einer gespeicherten Prozedur vorgenommen werden, wenn eine aktive Transaktion vor der Ausführung der gespeicherten Prozedur gestartet wird.

USE AdventureWorks2022;  
GO  
IF EXISTS (SELECT name FROM sys.objects  
           WHERE name = N'SaveTranExample')  
    DROP PROCEDURE SaveTranExample;  
GO  
CREATE PROCEDURE SaveTranExample  
    @InputCandidateID INT  
AS  
    -- Detect whether the procedure was called  
    -- from an active transaction and save  
    -- that for later use.  
    -- In the procedure, @TranCounter = 0  
    -- means there was no active transaction  
    -- and the procedure started one.  
    -- @TranCounter > 0 means an active  
    -- transaction was started before the   
    -- procedure was called.  
    DECLARE @TranCounter INT;  
    SET @TranCounter = @@TRANCOUNT;  
    IF @TranCounter > 0  
        -- Procedure called when there is  
        -- an active transaction.  
        -- Create a savepoint to be able  
        -- to roll back only the work done  
        -- in the procedure if there is an  
        -- error.  
        SAVE TRANSACTION ProcedureSave;  
    ELSE  
        -- Procedure must start its own  
        -- transaction.  
        BEGIN TRANSACTION;  
    -- Modify database.  
    BEGIN TRY  
        DELETE HumanResources.JobCandidate  
            WHERE JobCandidateID = @InputCandidateID;  
        -- Get here if no errors; must commit  
        -- any transaction started in the  
        -- procedure, but not commit a transaction  
        -- started before the transaction was called.  
        IF @TranCounter = 0  
            -- @TranCounter = 0 means no transaction was  
            -- started before the procedure was called.  
            -- The procedure must commit the transaction  
            -- it started.  
            COMMIT TRANSACTION;  
    END TRY  
    BEGIN CATCH  
        -- An error occurred; must determine  
        -- which type of rollback will roll  
        -- back only the work done in the  
        -- procedure.  
        IF @TranCounter = 0  
            -- Transaction started in procedure.  
            -- Roll back complete transaction.  
            ROLLBACK TRANSACTION;  
        ELSE  
            -- Transaction started before procedure  
            -- called, do not roll back modifications  
            -- made before the procedure was called.  
            IF XACT_STATE() <> -1  
                -- If the transaction is still valid, just  
                -- roll back to the savepoint set at the  
                -- start of the stored procedure.  
                ROLLBACK TRANSACTION ProcedureSave;  
                -- If the transaction is uncommitable, a  
                -- rollback to the savepoint is not allowed  
                -- because the savepoint rollback writes to  
                -- the log. Just return to the caller, which  
                -- should roll back the outer transaction.  
  
        -- After the appropriate rollback, echo error  
        -- information to the caller.  
        DECLARE @ErrorMessage NVARCHAR(4000);  
        DECLARE @ErrorSeverity INT;  
        DECLARE @ErrorState INT;  
  
        SELECT @ErrorMessage = ERROR_MESSAGE();  
        SELECT @ErrorSeverity = ERROR_SEVERITY();  
        SELECT @ErrorState = ERROR_STATE();  
  
        RAISERROR (@ErrorMessage, -- Message text.  
                   @ErrorSeverity, -- Severity.  
                   @ErrorState -- State.  
                   );  
    END CATCH  
GO

Weitere Informationen

BEGIN TRANSACTION (Transact-SQL)
COMMIT TRANSACTION (Transact-SQL)
COMMIT WORK (Transact-SQL)
ERROR_LINE (Transact-SQL)
ERROR_MESSAGE (Transact-SQL)
ERROR_NUMBER (Transact-SQL)
ERROR_PROCEDURE (Transact-SQL)
ERROR_SEVERITY (Transact-SQL)
ERROR_STATE (Transact-SQL)
RAISERROR (Transact-SQL)
ROLLBACK TRANSACTION (Transact-SQL)
ROLLBACK WORK (Transact-SQL)
TRY...CATCH (Transact-SQL)
XACT_STATE (Transact-SQL)

Freigeben über