Bagikan melalui

MULAI... AKHIR (Transact-SQL)

Berlaku untuk:SQL ServerAzure SQL DatabaseAzure SQL Managed InstanceAzure Synapse AnalyticsSistem Platform Analitik (PDW)Titik akhir analitik SQL di Microsoft FabricGudang di Microsoft FabricDatabase SQL di Microsoft Fabric

Menyertakan urutan pernyataan Transact-SQL ke dalam blok kode logis. Penggunaan BEGIN ini tidak terkait dengan BEGIN TRANSACTION pernyataan dan BEGIN ATOMIC .

Anda dapat menggunakan BEGIN...END blok dengan pernyataan kontrol alur sebelumnya seperti IF, ELSE, dan WHILE. Namun, Anda juga dapat menggunakan blok ini tanpa pernyataan kontrol alur sebelumnya untuk mengelompokkan urutan pernyataan secara terorganisir. Namun, setiap blok baru BEGIN...END tidak membuat cakupan leksikal baru.

Konvensi sintaks transact-SQL

Syntax

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

Arguments

{ sql_statement | statement_block }

Setiap pernyataan Transact-SQL atau pengelompokan pernyataan yang valid seperti yang didefinisikan dengan menggunakan blok pernyataan.

Remarks

Sebuah BEGIN...END blok harus berisi setidaknya satu pernyataan. Jika Anda mencoba menggunakan blok kosong BEGIN...END , Anda mendapatkan kesalahan sintaks, bahkan jika Anda menggunakan titik koma setelah setiap kata kunci. Anda dapat menghindari blok kosong BEGIN...END dengan menggunakan GOTO label sebagai pernyataan placeholder. Lihat Contoh C: Menggunakan label GOTO untuk BEGIN yang dihasilkan secara dinamis... Blok END.

BEGIN...END blok dapat ditumpuk.

BEGIN...END blok tidak menentukan cakupan leksikal apa pun. Jika Anda mendeklarasikan variabel dalam blok, variabel tersebut terlihat di seluruh batch induk, bukan hanya di dalam blok yang berisi DECLARE pernyataan.

Anda tidak dapat menggunakan BEGIN...END blok di beberapa batch. Misalnya, Anda tidak dapat menggunakan GO pemisah batch di dalam BEGIN...END blok.

Menggunakan BEGIN...END pernyataan blok untuk mengelompokkan tidak berarti semua pernyataan dalam grup berjalan secara atomik. Ketika batch berjalan di luar transaksi dan kesalahan dimunculkan atau pengecualian dilemparkan oleh pernyataan kedua dari blok multistatement BEGIN...END , pernyataan pertama tidak diputar kembali.

Titik koma setelah kata BEGIN kunci dan END bersifat opsional tetapi direkomendasikan, kecuali dalam kasus berikut:

  • Anda memerlukan titik koma sebelum WITH kata kunci yang memulai ekspresi tabel umum (CTE).

  • Anda memerlukan titik koma dengan THROW pernyataan dalam blok.

  • Gunakan titik koma setelahnya BEGIN untuk mencegah kebingungan dengan BEGIN TRANSACTION pernyataan atau BEGIN ATOMIC .

  • Menggunakan titik koma setelah END memastikan bahwa pernyataan berikutnya, terutama WITH kata kunci atau THROW pernyataan, tidak memerlukan titik koma sebelumnya.

Meskipun semua pernyataan Transact-SQL valid dalam BEGIN...END blok, Anda tidak boleh mengelompokkan pernyataan Transact-SQL tertentu bersama-sama dalam batch atau blok pernyataan yang sama. Pastikan pernyataan tidak bertentangan dengan persyaratan batch Transact-SQL yang ada.

Examples

Sampel kode dalam artikel ini menggunakan database sampel AdventureWorks2025 atau AdventureWorksDW2025, yang dapat Anda unduh dari halaman beranda Sampel dan Proyek Komunitas Microsoft SQL Server.

Dalam contoh berikut, BEGIN dan END tentukan urutan pernyataan Transact-SQL yang terkait secara logis untuk dieksekusi secara berurutan. Contoh ini juga menunjukkan blok berlapis.

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. Gunakan MULAI... END dalam transaksi

Dalam contoh berikut, BEGIN dan END tentukan serangkaian pernyataan Transact-SQL yang dijalankan bersama-sama. Jika BEGIN...END blok tidak disertakan, kedua ROLLBACK TRANSACTION pernyataan dieksekusi, dan kedua PRINT pesan dikembalikan.

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. Gunakan label GOTO untuk BEGIN yang dihasilkan secara dinamis... Blok END

Jika Anda menghasilkan Transact-SQL dinamis dengan BEGIN...END blok dan Anda ingin program Anda selalu merender BEGIN...END kata kunci, Anda dapat menggunakan GOTO label sebagai pernyataan placeholder untuk menghindari blok kosong BEGIN...END .

BEGIN
    unusedLabel:
END

Contoh: Azure Synapse Analytics and Analytics Platform System (PDW)

C. Menentukan serangkaian pernyataan yang berjalan bersama

Dalam contoh berikut, BEGIN dan END tentukan serangkaian pernyataan SQL yang berjalan bersama-sama.

Perhatian

Jika Anda menghapus BEGIN kata kunci dan, END contoh berikut berjalan dalam perulangan tak terbatas. Pernyataan WHILE hanya SELECT mengulang kueri, dan tidak pernah mencapai pernyataan 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

Konten terkait

  • Last updated on