Condividi tramite

COMINCIARE... FINE (Transact-SQL)

Si applica a:SQL ServerDatabase SQL di AzureIstanza gestita di SQL di AzureAzure Synapse AnalyticsPiattaforma di analisi (PDW)Endpoint di analisi SQL in Microsoft FabricMagazzino in Microsoft FabricDatabase SQL in Microsoft Fabric

Racchiude una sequenza di istruzioni Transact-SQL in un blocco logico di codice. Questo uso di BEGIN non è correlato alle BEGIN TRANSACTION istruzioni e BEGIN ATOMIC di e.

Puoi usare BEGIN...END blocchi con un'istruzione di controllo del flusso precedente come IF, ELSE, e WHILE. Tuttavia, puoi anche usare questi blocchi senza alcuna precedente istruzione di controllo del flusso per raggruppare sequenze di istruzioni in modo organizzato. Tuttavia, ogni nuovo BEGIN...END blocco non crea un nuovo ambito lessicale.

Convenzioni relative alla sintassi Transact-SQL

Syntax

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

Arguments

{ sql_statement | statement_block }

Qualsiasi istruzione Transact-SQL valida o raggruppamento di istruzioni come definito tramite un blocco di istruzioni.

Remarks

Un BEGIN...END blocco deve contenere almeno una affermazione. Se provi a usare un blocco vuoto BEGIN...END , ottieni un errore di sintassi, anche se usi un punto e virgola dopo ogni parola chiave. Puoi evitare blocchi vuoti BEGIN...END usando un'etichetta GOTO come dichiarazione segnaposto. Vedi Esempio C: Usa un'etichetta GOTO per BEGIN... generato dinamicamente... END blocchi.

BEGIN...END i blocchi possono essere annidati.

BEGIN...END I blocchi non definiscono alcun ambito lessicale. Se dichiari una variabile all'interno di un blocco, essa è visibile in tutto il lotto genitore, non solo all'interno del blocco che contiene l'istruzione DECLARE .

Non puoi usare BEGIN...END blocchi distribuiti su più lotti. Ad esempio, non puoi usare il GO separatore batch all'interno di un BEGIN...END blocco.

Usare un BEGIN...END blocco per raggruppare le istruzioni non significa che tutte le istruzioni del gruppo siano attive atomicamente. Quando un batch viene eseguito al di fuori di una transazione e viene sollevato un errore o viene lanciata un'eccezione dalla seconda istruzione di un blocco multistatement BEGIN...END , la prima istruzione non viene annullata all'indietro.

Le parole chiave e virgola dopo e BEGINEND sono opzionali ma raccomandate, tranne nei seguenti casi:

  • Serve un punto e virgola prima della WITH parola chiave che avvia un'espressione comune della tabella (CTE).

  • Serve un punto e virgola con un'affermazione THROW all'interno di un blocco.

  • Usa un punto e virgola dopo BEGIN per evitare confusione con le BEGIN TRANSACTION istruzioni op BEGIN ATOMIC .

  • Usare un punto e virgola dopo END garantisce che qualsiasi affermazione successiva, in particolare una WITH parola chiave o THROW un'affermazione, non abbia bisogno di un punto e virgola precedente.

Anche se tutte le Transact-SQL istruzioni sono valide all'interno di un BEGIN...END blocco, non dovresti raggruppare certe istruzioni Transact-SQL nello stesso lotto o blocco di istruzioni. Assicurati che le dichiarazioni non entrino in conflitto con i requisiti esistenti Transact-SQL lotti.

Examples

Gli esempi di codice in questo articolo usano il database di esempio AdventureWorks2025 o AdventureWorksDW2025, che è possibile scaricare dalla home page Microsoft SQL Server Samples and Community Projects.

Nel seguente esempio, BEGIN e END definire sequenze di istruzioni Transact-SQL logicamente correlate da eseguire in ordine. L'esempio mostra anche i blocchi annidati.

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. Usa BEGIN... FINE di una transazione

Nell'esempio seguente BEGIN ed END definiscono una serie di istruzioni Transact-SQL eseguite insieme. Se il BEGIN...END blocco non è incluso, entrambe ROLLBACK TRANSACTION le istruzioni vengono eseguite e entrambi PRINT i messaggi vengono restituiti.

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.';

C. Usa un'etichetta GOTO per BEGIN... generato dinamicamente... Blocchi END

Se generi Transact-SQL dinamici con un BEGIN...END blocco e vuoi che il tuo programma visualizzi sempre le BEGIN...END parole chiave, puoi usare un'etichetta GOTO come istruzione segnaposto per evitare un blocco vuoto BEGIN...END .

BEGIN
    unusedLabel:
END

Esempi: Azure Synapse Analytics e Piattaforma di strumenti analitici (PDW)

C. Definisci una serie di affermazioni che si combinano

Nell'esempio seguente BEGIN ed END definiscono una serie di istruzioni SQL eseguite insieme.

Attenzione

Se rimuovi le BEGIN parole chiave e, END il seguente esempio gira in un ciclo infinito. L'istruzione WHILE riproduce solo la SELECT query e non raggiunge mai l'affermazione 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

Contenuti correlati

  • Last updated on