Partage via

COMMENCER... FIN (Transact-SQL)

S’applique à :SQL ServerAzure SQL DatabaseAzure SQL Managed InstanceAzure Synapse AnalyticsAnalytics Platform System (PDW)Point de terminaison d’analytique SQL dans Microsoft FabricEntrepôt dans Microsoft FabricBase de données SQL dans Microsoft Fabric

Enferme une séquence d’instructions Transact-SQL dans un bloc logique de code. Cet usage de BEGIN n’a aucun lien avec les BEGIN TRANSACTION énoncés et BEGIN ATOMIC .

Vous pouvez utiliser BEGIN...END des blocs avec une instruction de contrôle de flux précédente comme IF, ELSE, et WHILE. Cependant, vous pouvez aussi utiliser ces blocs sans aucune instruction de contrôle de flux préalable pour regrouper des séquences d’instructions de manière organisée. Cependant, chaque nouveau BEGIN...END bloc ne crée pas un nouveau champ lexical.

Conventions de la syntaxe Transact-SQL

Syntax

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

Arguments

{ sql_statement | statement_block}

Toute instruction Transact-SQL valide ou regroupement d’instructions tel que défini à l’aide d’un bloc d’instructions.

Remarks

Un BEGIN...END bloc doit contenir au moins une affirmation. Si vous essayez d’utiliser un bloc vide BEGIN...END , vous obtenez une erreur de syntaxe, même si vous utilisez un point-virgule après chaque mot-clé. Vous pouvez éviter les blocs vides BEGIN...END en utilisant une GOTO étiquette comme instruction provisoire. Voir l’exemple C : Utilisez une étiquette GOTO pour BEGIN... END blocks.

BEGIN...END les blocs peuvent être imbriqués.

BEGIN...END Les blocs ne définissent aucun champ lexical. Si vous déclarez une variable dans un bloc, elle est visible dans tout le lot parent, pas seulement dans le bloc contenant l’énoncé DECLARE .

On ne peut pas utiliser BEGIN...END des blocs répartis sur plusieurs lots. Par exemple, vous ne pouvez pas utiliser le GO séparateur de lots à l’intérieur d’un BEGIN...END bloc.

Utiliser un BEGIN...END bloc pour regrouper des instructions ne signifie pas que toutes les instructions du groupe s’exécutent atomiquement. Lorsqu’un lot s’exécute en dehors d’une transaction et qu’une erreur est générée ou qu’une exception est lancée par la deuxième instruction d’un bloc multistatement BEGIN...END , la première instruction n’est pas annulée.

Les mots-clés et en points-virgules après BEGIN et END sont optionnels mais recommandés, sauf dans les cas suivants :

  • Il faut un point-virgule avant le WITH mot-clé qui déclenche une expression commune de tableau (CTE).

  • Il faut un point-virgule avec une THROW déclaration dans un bloc.

  • Utilisez un point-virgule après BEGIN pour éviter toute confusion avec les BEGIN TRANSACTION instructions ou.BEGIN ATOMIC

  • Utiliser un point-virgule après END garantit que toute déclaration ultérieure, en particulier un WITH mot-clé ou THROW une affirmation, n’a pas besoin d’un point et virgule précédent.

Bien que toutes les Transact-SQL instructions soient valides dans un BEGIN...END bloc, vous ne devriez pas regrouper certaines Transact-SQL instructions dans le même lot ou bloc d’instructions. Assurez-vous que les relevés ne contredisent pas les exigences existantes Transact-SQL lot.

Examples

Les exemples de code de cet article utilisent les bases de données d'exemple AdventureWorks2025 ou AdventureWorksDW2025, que vous pouvez télécharger à partir de la page d'accueil Microsoft SQL Server Samples and Community Projects.

Dans l’exemple suivant, BEGIN et END définissez des suites d’instructions Transact-SQL logiquement liées à exécuter dans l’ordre. L’exemple montre également des blocs imbriqués.

USE AdventureWorks2025;
GO

DECLARE @personId AS INT = (
    SELECT p.BusinessEntityID
    FROM Person.Person AS p
    WHERE p.rowguid = { GUID '92C4279F-1207-48A3-8448-4636514EB7E2' }
);

IF (@personId IS NULL)
    THROW 50001, 'Person not found.', 1;

/* Concatenate the person's name fields: */;
BEGIN
    DECLARE @title AS NVARCHAR (8),
            @first AS NVARCHAR (50),
            @middle AS NVARCHAR (50),
            @last AS NVARCHAR (50),
            @suffix AS NVARCHAR (10);

    SELECT @title = NULLIF (p.Title, N''),
           @first = p.FirstName,
           @middle = NULLIF (p.MiddleName, N''),
           @last = p.LastName,
           @suffix = NULLIF (p.Suffix, N'')
    FROM Person.Person AS p
    WHERE p.BusinessEntityID = @personId;

    DECLARE @nameConcat AS NVARCHAR (255) = CONCAT_WS(N' ', @title, @first, @middle, @last, @suffix);

    /* This is a nested BEGIN...END block: */;
    BEGIN
        DECLARE @emails AS NVARCHAR (MAX) = (
            SELECT STRING_AGG(e.EmailAddress, /*separator:*/N'; ')
            FROM Person.EmailAddress AS e
            WHERE e.BusinessEntityID = @personId
        );

        SET @nameConcat = CONCAT(@nameConcat, N' (', @emails, N')');
    END
END

/* BEGIN...END blocks do not define a lexical scope, so
   even though @nameAndEmails is declared above, it is
   still in-scope after the END keyword. */
SELECT @nameConcat AS NameAndEmails;

B. Utilise COMMENCE... FIN d’une transaction

Dans l'exemple suivant, BEGIN et END délimitent une série d'instructions Transact-SQL qui sont exécutées ensemble. Si le BEGIN...END bloc n’est pas inclus, les deux ROLLBACK TRANSACTION instructions s’exécutent, et les deux PRINT messages sont renvoyés.

USE AdventureWorks2025;
GO

BEGIN TRANSACTION;

IF @@TRANCOUNT = 0
    BEGIN
        SELECT FirstName,
               MiddleName
        FROM Person.Person
        WHERE LastName = 'Adams';

        ROLLBACK TRANSACTION;

        PRINT N'Rolling back the transaction two times causes an error.';
    END

ROLLBACK TRANSACTION;

PRINT N'Rolled back the transaction.';

Chapitre C. Utilisez une étiquette GOTO pour BEGIN... Blocs END

Si vous générez des Transact-SQL dynamiques avec un BEGIN...END bloc et que vous voulez que votre programme affiche toujours les BEGIN...END mots-clés, vous pouvez utiliser une GOTO étiquette comme instruction de remplacement pour éviter d’avoir un bloc vide BEGIN...END .

BEGIN
    unusedLabel:
END

Exemples : Azure Synapse Analytics et Analytics Platform System (PDW)

Chapitre C. Définissons une série d’énoncés qui s’enchaînent

Dans l’exemple suivant, BEGIN et END définissent une série d’instructions SQL qui s’exécutent ensemble.

Caution

Si vous supprimez les BEGIN mots-clés et END , l’exemple suivant s’exécute dans une boucle infinie. L’instruction WHILE ne boucle que la SELECT requête, et n’atteint jamais l’énoncé.SET @Iteration += 1

-- Uses AdventureWorksDW;
DECLARE @Iteration AS INT = 0;

WHILE @Iteration < 10
    BEGIN
        SELECT FirstName,
               MiddleName
        FROM dbo.DimCustomer
        WHERE LastName = 'Adams';
        SET @Iteration + = 1;
    END

Contenu connexe

  • Last updated on