SAVE TRANSACTION (Transact-SQL)

Syntaxe

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

Arguments

• savepoint_name
  Nom affecté au point de sauvegarde. Les noms des points de sauvegarde doivent respecter les règles d'appellation des identificateurs, à la différence que leur nom est limité à 32 caractères.

• **@**savepoint_variable
  Nom d'une variable définie par l'utilisateur et contenant un nom de point de sauvegarde valide. La variable doit être déclarée selon le type de données char, varchar, nchar ou nvarchar. Plus de 32 caractères peuvent être passés à la variable, mais seuls les 32 premiers peuvent être utilisés.

Notes

L'utilisateur peut placer un point de sauvegarde, ou marqueur, à l'intérieur d'une transaction. Le point de sauvegarde définit un emplacement auquel une transaction peut revenir si une partie de celle-ci est annulée par une condition. Si une transaction est restaurée à un point de sauvegarde, elle doit soit se poursuivre jusqu'à son exécution complète (avec davantage d'instructions Transact-SQL si nécessaire et une instruction COMMIT TRANSACTION), soit être restaurée entièrement (à partir du début). Pour annuler l'intégralité d'une transaction, utilisez la syntaxe ROLLBACK TRANSACTION transaction_name. Toutes les instructions ou procédures de la transaction sont ainsi annulées.

Dans une transaction, les noms de point de sauvegarde dupliqués sont autorisés. Toutefois, une instruction ROLLBACK TRANSACTION contenant le nom d'un point de sauvegarde en double n'effectue la restauration que jusqu'à l'instruction SAVE TRANSACTION la plus récente utilisant ce nom.

L'instruction SAVE TRANSACTION n'est pas prise en charge dans les transactions distribuées démarrées soit explicitement à l'aide de BEGIN DISTRIBUTED TRANSACTION, soit issues d'une transaction locale.

Autorisations

Nécessite l'appartenance au rôle public.

Exemple

L'exemple suivant montre comment utiliser un point de sauvegarde de transaction pour ne restaurer que les modifications apportées par une procédure stockée exécutée après que la transaction active ait été lancée.

USE AdventureWorks;
GO
IF EXISTS (SELECT name FROM sys.objects
           WHERE name = N'SaveTranExample')
    DROP PROCEDURE SaveTranExample;
GO
CREATE PROCEDURE SaveTranExample
    @InputCandidateID INT
AS
    -- Detect if 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

Voir aussi

Référence

Concepts